/[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 293 by astrand, Tue Jan 21 20:22:44 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    #ifdef SAVE_LICENCE
63  /* Present an existing licence to the server */  /* Present an existing licence to the server */
64  static void  static void
65  licence_present(uint8 *client_random, uint8 *rsa_data,  licence_present(uint8 * client_random, uint8 * rsa_data,
66                  uint8 *licence_data, int licence_size,                  uint8 * licence_data, int licence_size, uint8 * hwid, uint8 * signature)
                 uint8 *hwid, uint8 *signature)  
67  {  {
68          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
69          uint16 length = 16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE          uint16 length =
70                          + licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;                  16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE +
71                    licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;
72          STREAM s;          STREAM s;
73    
74          s = sec_init(sec_flags, length + 4);          s = sec_init(sec_flags, length + 4);
# Line 94  licence_present(uint8 *client_random, ui Line 99  licence_present(uint8 *client_random, ui
99          s_mark_end(s);          s_mark_end(s);
100          sec_send(s, sec_flags);          sec_send(s, sec_flags);
101  }  }
102    #endif
103    
104  /* Send a licence request packet */  /* Send a licence request packet */
105  static void  static void
106  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)  
107  {  {
108          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
109          uint16 userlen = strlen(user) + 1;          uint16 userlen = strlen(user) + 1;
110          uint16 hostlen = strlen(host) + 1;          uint16 hostlen = strlen(host) + 1;
111          uint16 length = 120 + userlen + hostlen;          uint16 length = 128 + userlen + hostlen;
112          STREAM s;          STREAM s;
113    
114          s = sec_init(sec_flags, length + 2);          s = sec_init(sec_flags, length + 2);
# Line 138  static void Line 143  static void
143  licence_process_demand(STREAM s)  licence_process_demand(STREAM s)
144  {  {
145          uint8 null_data[SEC_MODULUS_SIZE];          uint8 null_data[SEC_MODULUS_SIZE];
         uint8 hwid[LICENCE_HWID_SIZE];  
         uint8 signature[LICENCE_SIGNATURE_SIZE];  
146          uint8 *server_random;          uint8 *server_random;
147    #ifdef SAVE_LICENCE
148            uint8 signature[LICENCE_SIGNATURE_SIZE];
149            uint8 hwid[LICENCE_HWID_SIZE];
150          uint8 *licence_data;          uint8 *licence_data;
151          int licence_size;          int licence_size;
152          RC4_KEY crypt_key;          RC4_KEY crypt_key;
153    #endif
154    
155          /* Retrieve the server random from the incoming packet */          /* Retrieve the server random from the incoming packet */
156          in_uint8p(s, server_random, SEC_RANDOM_SIZE);          in_uint8p(s, server_random, SEC_RANDOM_SIZE);
# Line 153  licence_process_demand(STREAM s) Line 160  licence_process_demand(STREAM s)
160          memset(null_data, 0, sizeof(null_data));          memset(null_data, 0, sizeof(null_data));
161          licence_generate_keys(null_data, server_random, null_data);          licence_generate_keys(null_data, server_random, null_data);
162    
163    #ifdef SAVE_LICENCE
164          licence_size = load_licence(&licence_data);          licence_size = load_licence(&licence_data);
165          if (licence_size == -1)          if (licence_size != -1)
166          {          {
167                  licence_send_request(null_data, null_data, username, hostname);                  /* Generate a signature for the HWID buffer */
168                    licence_generate_hwid(hwid);
169                    sec_sign(signature, 16, licence_sign_key, 16, hwid, sizeof(hwid));
170    
171                    /* Now encrypt the HWID */
172                    RC4_set_key(&crypt_key, 16, licence_key);
173                    RC4(&crypt_key, sizeof(hwid), hwid, hwid);
174    
175                    licence_present(null_data, null_data, licence_data, licence_size, hwid, signature);
176                    xfree(licence_data);
177                  return;                  return;
178          }          }
179    #endif
180    
181          /* 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);  
182  }  }
183    
184  /* Send an authentication response packet */  /* Send an authentication response packet */
185  static void  static void
186  licence_send_authresp(uint8 *token, uint8 *crypt_hwid, uint8 *signature)  licence_send_authresp(uint8 * token, uint8 * crypt_hwid, uint8 * signature)
187  {  {
188          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
189          uint16 length = 58;          uint16 length = 58;
# Line 202  licence_send_authresp(uint8 *token, uint Line 210  licence_send_authresp(uint8 *token, uint
210    
211  /* Parse an authentication request packet */  /* Parse an authentication request packet */
212  static BOOL  static BOOL
213  licence_parse_authreq(STREAM s, uint8 **token, uint8 **signature)  licence_parse_authreq(STREAM s, uint8 ** token, uint8 ** signature)
214  {  {
215          uint16 tokenlen;          uint16 tokenlen;
216    
# Line 226  static void Line 234  static void
234  licence_process_authreq(STREAM s)  licence_process_authreq(STREAM s)
235  {  {
236          uint8 *in_token, *in_sig;          uint8 *in_token, *in_sig;
237          uint8 out_token[LICENCE_TOKEN_SIZE],          uint8 out_token[LICENCE_TOKEN_SIZE], decrypt_token[LICENCE_TOKEN_SIZE];
                 decrypt_token[LICENCE_TOKEN_SIZE];  
238          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];
239          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];
240          uint8 out_sig[LICENCE_SIGNATURE_SIZE];          uint8 out_sig[LICENCE_SIGNATURE_SIZE];
# Line 245  licence_process_authreq(STREAM s) Line 252  licence_process_authreq(STREAM s)
252          licence_generate_hwid(hwid);          licence_generate_hwid(hwid);
253          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);
254          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);
255          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));  
256    
257          /* Now encrypt the HWID */          /* Now encrypt the HWID */
258          RC4_set_key(&crypt_key, 16, licence_key);          RC4_set_key(&crypt_key, 16, licence_key);
# Line 280  licence_process_issue(STREAM s) Line 282  licence_process_issue(STREAM s)
282                  return;                  return;
283    
284          licence_issued = True;          licence_issued = True;
285          save_licence(s->p, length-2);  
286    #ifdef SAVE_LICENCE
287            save_licence(s->p, length - 2);
288    #endif
289  }  }
290    
291  /* Process a licence packet */  /* Process a licence packet */
Legend:
Removed from v.39  
changed lines
  Added in v.293
  ViewVC Help
Powered by ViewVC 1.1.26