/[rdesktop]/sourceforge.net/trunk/rdesktop/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 /sourceforge.net/trunk/rdesktop/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 359 by forsberg, Thu Apr 3 13:52:41 2003 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 19  Line 19 
19  */  */
20    
21  #include "rdesktop.h"  #include "rdesktop.h"
22    
23    #ifdef WITH_OPENSSL
24    #include <openssl/rc4.h>
25    #else
26  #include "crypto/rc4.h"  #include "crypto/rc4.h"
27    #endif
28    
29  extern char username[16];  extern char username[16];
30  extern char hostname[16];  extern char hostname[16];
 extern BOOL licence;  
31    
32  static uint8 licence_key[16];  static uint8 licence_key[16];
33  static uint8 licence_sign_key[16];  static uint8 licence_sign_key[16];
# Line 32  BOOL licence_issued = False; Line 36  BOOL licence_issued = False;
36    
37  /* Generate a session key and RC4 keys, given client and server randoms */  /* Generate a session key and RC4 keys, given client and server randoms */
38  static void  static void
39  licence_generate_keys(uint8 *client_key, uint8 *server_key, uint8 *client_rsa)  licence_generate_keys(uint8 * client_key, uint8 * server_key, uint8 * client_rsa)
40  {  {
41          uint8 session_key[48];          uint8 session_key[48];
42          uint8 temp_hash[48];          uint8 temp_hash[48];
# Line 49  licence_generate_keys(uint8 *client_key, Line 53  licence_generate_keys(uint8 *client_key,
53  }  }
54    
55  static void  static void
56  licence_generate_hwid(uint8 *hwid)  licence_generate_hwid(uint8 * hwid)
57  {  {
58          buf_out_uint32(hwid, 2);          buf_out_uint32(hwid, 2);
59          strncpy(hwid + 4, hostname, LICENCE_HWID_SIZE - 4);          strncpy((char *) (hwid + 4), hostname, LICENCE_HWID_SIZE - 4);
60  }  }
61    
62  /* Present an existing licence to the server */  /* Present an existing licence to the server */
63  static void  static void
64  licence_present(uint8 *client_random, uint8 *rsa_data,  licence_present(uint8 * client_random, uint8 * rsa_data,
65                  uint8 *licence_data, int licence_size,                  uint8 * licence_data, int licence_size, uint8 * hwid, uint8 * signature)
                 uint8 *hwid, uint8 *signature)  
66  {  {
67          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
68          uint16 length = 16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE          uint16 length =
69                          + licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;                  16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE +
70                    licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;
71          STREAM s;          STREAM s;
72    
73          s = sec_init(sec_flags, length + 4);          s = sec_init(sec_flags, length + 4);
# Line 97  licence_present(uint8 *client_random, ui Line 101  licence_present(uint8 *client_random, ui
101    
102  /* Send a licence request packet */  /* Send a licence request packet */
103  static void  static void
104  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)  
105  {  {
106          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
107          uint16 userlen = strlen(user) + 1;          uint16 userlen = strlen(user) + 1;
108          uint16 hostlen = strlen(host) + 1;          uint16 hostlen = strlen(host) + 1;
109          uint16 length = 120 + userlen + hostlen;          uint16 length = 128 + userlen + hostlen;
110          STREAM s;          STREAM s;
111    
112          s = sec_init(sec_flags, length + 2);          s = sec_init(sec_flags, length + 2);
# Line 138  static void Line 141  static void
141  licence_process_demand(STREAM s)  licence_process_demand(STREAM s)
142  {  {
143          uint8 null_data[SEC_MODULUS_SIZE];          uint8 null_data[SEC_MODULUS_SIZE];
         uint8 hwid[LICENCE_HWID_SIZE];  
         uint8 signature[LICENCE_SIGNATURE_SIZE];  
144          uint8 *server_random;          uint8 *server_random;
145            uint8 signature[LICENCE_SIGNATURE_SIZE];
146            uint8 hwid[LICENCE_HWID_SIZE];
147          uint8 *licence_data;          uint8 *licence_data;
148          int licence_size;          int licence_size;
149          RC4_KEY crypt_key;          RC4_KEY crypt_key;
# Line 154  licence_process_demand(STREAM s) Line 157  licence_process_demand(STREAM s)
157          licence_generate_keys(null_data, server_random, null_data);          licence_generate_keys(null_data, server_random, null_data);
158    
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    
175          /* 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);  
176  }  }
177    
178  /* Send an authentication response packet */  /* Send an authentication response packet */
179  static void  static void
180  licence_send_authresp(uint8 *token, uint8 *crypt_hwid, uint8 *signature)  licence_send_authresp(uint8 * token, uint8 * crypt_hwid, uint8 * signature)
181  {  {
182          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
183          uint16 length = 58;          uint16 length = 58;
# Line 202  licence_send_authresp(uint8 *token, uint Line 204  licence_send_authresp(uint8 *token, uint
204    
205  /* Parse an authentication request packet */  /* Parse an authentication request packet */
206  static BOOL  static BOOL
207  licence_parse_authreq(STREAM s, uint8 **token, uint8 **signature)  licence_parse_authreq(STREAM s, uint8 ** token, uint8 ** signature)
208  {  {
209          uint16 tokenlen;          uint16 tokenlen;
210    
# Line 226  static void Line 228  static void
228  licence_process_authreq(STREAM s)  licence_process_authreq(STREAM s)
229  {  {
230          uint8 *in_token, *in_sig;          uint8 *in_token, *in_sig;
231          uint8 out_token[LICENCE_TOKEN_SIZE],          uint8 out_token[LICENCE_TOKEN_SIZE], decrypt_token[LICENCE_TOKEN_SIZE];
                 decrypt_token[LICENCE_TOKEN_SIZE];  
232          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];
233          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];
234          uint8 out_sig[LICENCE_SIGNATURE_SIZE];          uint8 out_sig[LICENCE_SIGNATURE_SIZE];
# Line 245  licence_process_authreq(STREAM s) Line 246  licence_process_authreq(STREAM s)
246          licence_generate_hwid(hwid);          licence_generate_hwid(hwid);
247          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);
248          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);
249          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));  
250    
251          /* Now encrypt the HWID */          /* Now encrypt the HWID */
252          RC4_set_key(&crypt_key, 16, licence_key);          RC4_set_key(&crypt_key, 16, licence_key);
# Line 280  licence_process_issue(STREAM s) Line 276  licence_process_issue(STREAM s)
276                  return;                  return;
277    
278          licence_issued = True;          licence_issued = True;
279          save_licence(s->p, length-2);          save_licence(s->p, length - 2);
280  }  }
281    
282  /* Process a licence packet */  /* Process a licence packet */
# Line 295  licence_process(STREAM s) Line 291  licence_process(STREAM s)
291          switch (tag)          switch (tag)
292          {          {
293                  case LICENCE_TAG_DEMAND:                  case LICENCE_TAG_DEMAND:
294                    case LICENCE_TAG_DEMAND_5:
295                          licence_process_demand(s);                          licence_process_demand(s);
296                          break;                          break;
297    
298                  case LICENCE_TAG_AUTHREQ:                  case LICENCE_TAG_AUTHREQ:
299                    case LICENCE_TAG_AUTHREQ_5:
300                          licence_process_authreq(s);                          licence_process_authreq(s);
301                          break;                          break;
302    
303                  case LICENCE_TAG_ISSUE:                  case LICENCE_TAG_ISSUE:
304                    case LICENCE_TAG_ISSUE_5:
305                          licence_process_issue(s);                          licence_process_issue(s);
306                          break;                          break;
307    
308                  case LICENCE_TAG_REISSUE:                  case LICENCE_TAG_REISSUE:
309                    case LICENCE_TAG_REISSUE_5:
310                          break;                          break;
311    
312                  case LICENCE_TAG_RESULT:                  case LICENCE_TAG_RESULT:
313                    case LICENCE_TAG_RESULT_5:
314                          break;                          break;
315    
316                  default:                  default:
Legend:
Removed from v.39  
changed lines
  Added in v.359
  ViewVC Help
Powered by ViewVC 1.1.26