/[rdesktop]/jpeg/rdesktop/trunk/licence.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /jpeg/rdesktop/trunk/licence.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 39 by matthewc, Fri Apr 5 07:57:43 2002 UTC revision 214 by matthewc, Sun Oct 6 13:57:39 2002 UTC
# Line 1  Line 1 
1  /*  /*
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     RDP licensing negotiation     RDP licensing negotiation
4     Copyright (C) Matthew Chapman 1999-2001     Copyright (C) Matthew Chapman 1999-2002
5        
6     This program is free software; you can redistribute it and/or modify     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.     (at your option) any later version.
10      
11     This program is distributed in the hope that it will be useful,     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# Line 23  Line 23 
23    
24  extern char username[16];  extern char username[16];
25  extern char hostname[16];  extern char hostname[16];
 extern BOOL licence;  
26    
27  static uint8 licence_key[16];  static uint8 licence_key[16];
28  static uint8 licence_sign_key[16];  static uint8 licence_sign_key[16];
# Line 32  BOOL licence_issued = False; Line 31  BOOL licence_issued = False;
31    
32  /* Generate a session key and RC4 keys, given client and server randoms */  /* Generate a session key and RC4 keys, given client and server randoms */
33  static void  static void
34  licence_generate_keys(uint8 *client_key, uint8 *server_key, uint8 *client_rsa)  licence_generate_keys(uint8 * client_key, uint8 * server_key, uint8 * client_rsa)
35  {  {
36          uint8 session_key[48];          uint8 session_key[48];
37          uint8 temp_hash[48];          uint8 temp_hash[48];
# Line 49  licence_generate_keys(uint8 *client_key, Line 48  licence_generate_keys(uint8 *client_key,
48  }  }
49    
50  static void  static void
51  licence_generate_hwid(uint8 *hwid)  licence_generate_hwid(uint8 * hwid)
52  {  {
53          buf_out_uint32(hwid, 2);          buf_out_uint32(hwid, 2);
54          strncpy(hwid + 4, hostname, LICENCE_HWID_SIZE - 4);          strncpy((char *) (hwid + 4), hostname, LICENCE_HWID_SIZE - 4);
55  }  }
56    
57    #ifdef SAVE_LICENCE
58  /* Present an existing licence to the server */  /* Present an existing licence to the server */
59  static void  static void
60  licence_present(uint8 *client_random, uint8 *rsa_data,  licence_present(uint8 * client_random, uint8 * rsa_data,
61                  uint8 *licence_data, int licence_size,                  uint8 * licence_data, int licence_size, uint8 * hwid, uint8 * signature)
                 uint8 *hwid, uint8 *signature)  
62  {  {
63          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
64          uint16 length = 16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE          uint16 length =
65                          + licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;                  16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE +
66                    licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;
67          STREAM s;          STREAM s;
68    
69          s = sec_init(sec_flags, length + 4);          s = sec_init(sec_flags, length + 4);
# Line 94  licence_present(uint8 *client_random, ui Line 94  licence_present(uint8 *client_random, ui
94          s_mark_end(s);          s_mark_end(s);
95          sec_send(s, sec_flags);          sec_send(s, sec_flags);
96  }  }
97    #endif
98    
99  /* Send a licence request packet */  /* Send a licence request packet */
100  static void  static void
101  licence_send_request(uint8 *client_random, uint8 *rsa_data,  licence_send_request(uint8 * client_random, uint8 * rsa_data, char *user, char *host)
                      char *user, char *host)  
102  {  {
103          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
104          uint16 userlen = strlen(user) + 1;          uint16 userlen = strlen(user) + 1;
105          uint16 hostlen = strlen(host) + 1;          uint16 hostlen = strlen(host) + 1;
106          uint16 length = 120 + userlen + hostlen;          uint16 length = 128 + userlen + hostlen;
107          STREAM s;          STREAM s;
108    
109          s = sec_init(sec_flags, length + 2);          s = sec_init(sec_flags, length + 2);
# Line 138  static void Line 138  static void
138  licence_process_demand(STREAM s)  licence_process_demand(STREAM s)
139  {  {
140          uint8 null_data[SEC_MODULUS_SIZE];          uint8 null_data[SEC_MODULUS_SIZE];
         uint8 hwid[LICENCE_HWID_SIZE];  
         uint8 signature[LICENCE_SIGNATURE_SIZE];  
141          uint8 *server_random;          uint8 *server_random;
142    #ifdef SAVE_LICENCE
143            uint8 signature[LICENCE_SIGNATURE_SIZE];
144            uint8 hwid[LICENCE_HWID_SIZE];
145          uint8 *licence_data;          uint8 *licence_data;
146          int licence_size;          int licence_size;
147          RC4_KEY crypt_key;          RC4_KEY crypt_key;
148    #endif
149    
150          /* Retrieve the server random from the incoming packet */          /* Retrieve the server random from the incoming packet */
151          in_uint8p(s, server_random, SEC_RANDOM_SIZE);          in_uint8p(s, server_random, SEC_RANDOM_SIZE);
# Line 153  licence_process_demand(STREAM s) Line 155  licence_process_demand(STREAM s)
155          memset(null_data, 0, sizeof(null_data));          memset(null_data, 0, sizeof(null_data));
156          licence_generate_keys(null_data, server_random, null_data);          licence_generate_keys(null_data, server_random, null_data);
157    
158    #ifdef SAVE_LICENCE
159          licence_size = load_licence(&licence_data);          licence_size = load_licence(&licence_data);
160          if (licence_size == -1)          if (licence_size != -1)
161          {          {
162                  licence_send_request(null_data, null_data, username, hostname);                  /* Generate a signature for the HWID buffer */
163                    licence_generate_hwid(hwid);
164                    sec_sign(signature, 16, licence_sign_key, 16, hwid, sizeof(hwid));
165    
166                    /* Now encrypt the HWID */
167                    RC4_set_key(&crypt_key, 16, licence_key);
168                    RC4(&crypt_key, sizeof(hwid), hwid, hwid);
169    
170                    licence_present(null_data, null_data, licence_data, licence_size, hwid, signature);
171                    xfree(licence_data);
172                  return;                  return;
173          }          }
174    #endif
175    
176          /* Generate a signature for the HWID buffer */          licence_send_request(null_data, null_data, username, hostname);
         licence_generate_hwid(hwid);  
         sec_sign(signature, licence_sign_key, 16, hwid, sizeof(hwid));  
   
         /* Now encrypt the HWID */  
         RC4_set_key(&crypt_key, 16, licence_key);  
         RC4(&crypt_key, sizeof(hwid), hwid, hwid);  
   
         licence_present(null_data, null_data, licence_data, licence_size,  
                                         hwid, signature);  
         xfree(licence_data);  
177  }  }
178    
179  /* Send an authentication response packet */  /* Send an authentication response packet */
180  static void  static void
181  licence_send_authresp(uint8 *token, uint8 *crypt_hwid, uint8 *signature)  licence_send_authresp(uint8 * token, uint8 * crypt_hwid, uint8 * signature)
182  {  {
183          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
184          uint16 length = 58;          uint16 length = 58;
# Line 202  licence_send_authresp(uint8 *token, uint Line 205  licence_send_authresp(uint8 *token, uint
205    
206  /* Parse an authentication request packet */  /* Parse an authentication request packet */
207  static BOOL  static BOOL
208  licence_parse_authreq(STREAM s, uint8 **token, uint8 **signature)  licence_parse_authreq(STREAM s, uint8 ** token, uint8 ** signature)
209  {  {
210          uint16 tokenlen;          uint16 tokenlen;
211    
# Line 226  static void Line 229  static void
229  licence_process_authreq(STREAM s)  licence_process_authreq(STREAM s)
230  {  {
231          uint8 *in_token, *in_sig;          uint8 *in_token, *in_sig;
232          uint8 out_token[LICENCE_TOKEN_SIZE],          uint8 out_token[LICENCE_TOKEN_SIZE], decrypt_token[LICENCE_TOKEN_SIZE];
                 decrypt_token[LICENCE_TOKEN_SIZE];  
233          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];
234          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];
235          uint8 out_sig[LICENCE_SIGNATURE_SIZE];          uint8 out_sig[LICENCE_SIGNATURE_SIZE];
# Line 245  licence_process_authreq(STREAM s) Line 247  licence_process_authreq(STREAM s)
247          licence_generate_hwid(hwid);          licence_generate_hwid(hwid);
248          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);
249          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);
250          sec_sign(out_sig, licence_sign_key, 16,          sec_sign(out_sig, 16, licence_sign_key, 16, sealed_buffer, sizeof(sealed_buffer));
                  sealed_buffer, sizeof(sealed_buffer));  
   
         /* Deliberately break signature if licencing disabled */  
         if (!licence)  
                 memset(out_sig, 0, sizeof(out_sig));  
251    
252          /* Now encrypt the HWID */          /* Now encrypt the HWID */
253          RC4_set_key(&crypt_key, 16, licence_key);          RC4_set_key(&crypt_key, 16, licence_key);
# Line 280  licence_process_issue(STREAM s) Line 277  licence_process_issue(STREAM s)
277                  return;                  return;
278    
279          licence_issued = True;          licence_issued = True;
280          save_licence(s->p, length-2);  
281    #ifdef SAVE_LICENCE
282            save_licence(s->p, length - 2);
283    #endif
284  }  }
285    
286  /* Process a licence packet */  /* Process a licence packet */
Legend:
Removed from v.39  
changed lines
  Added in v.214
  ViewVC Help
Powered by ViewVC 1.1.26