/[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 30 by matty, Fri Sep 14 13:51:38 2001 UTC revision 380 by jsorg71, Fri May 30 21:44:06 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 g_licence_key[16];
33  static uint8 licence_sign_key[16];  static uint8 g_licence_sign_key[16];
34    
35  BOOL licence_issued = False;  BOOL g_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  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 42  licence_generate_keys(uint8 *client_key, Line 46  licence_generate_keys(uint8 *client_key,
46          sec_hash_48(session_key, temp_hash, server_key, client_key, 65);          sec_hash_48(session_key, temp_hash, server_key, client_key, 65);
47    
48          /* Store first 16 bytes of session key, for generating signatures */          /* Store first 16 bytes of session key, for generating signatures */
49          memcpy(licence_sign_key, session_key, 16);          memcpy(g_licence_sign_key, session_key, 16);
50    
51          /* Generate RC4 key */          /* Generate RC4 key */
52          sec_hash_16(licence_key, &session_key[16], client_key, server_key);          sec_hash_16(g_licence_key, &session_key[16], client_key, server_key);
53    }
54    
55    static void
56    licence_generate_hwid(uint8 * hwid)
57    {
58            buf_out_uint32(hwid, 2);
59            strncpy((char *) (hwid + 4), hostname, LICENCE_HWID_SIZE - 4);
60    }
61    
62    /* Present an existing licence to the server */
63    static void
64    licence_present(uint8 * client_random, uint8 * rsa_data,
65                    uint8 * licence_data, int licence_size, uint8 * hwid, uint8 * signature)
66    {
67            uint32 sec_flags = SEC_LICENCE_NEG;
68            uint16 length =
69                    16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE +
70                    licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;
71            STREAM s;
72    
73            s = sec_init(sec_flags, length + 4);
74    
75            out_uint8(s, LICENCE_TAG_PRESENT);
76            out_uint8(s, 2); /* version */
77            out_uint16_le(s, length);
78    
79            out_uint32_le(s, 1);
80            out_uint16(s, 0);
81            out_uint16_le(s, 0x0201);
82    
83            out_uint8p(s, client_random, SEC_RANDOM_SIZE);
84            out_uint16(s, 0);
85            out_uint16_le(s, (SEC_MODULUS_SIZE + SEC_PADDING_SIZE));
86            out_uint8p(s, rsa_data, SEC_MODULUS_SIZE);
87            out_uint8s(s, SEC_PADDING_SIZE);
88    
89            out_uint16_le(s, 1);
90            out_uint16_le(s, licence_size);
91            out_uint8p(s, licence_data, licence_size);
92    
93            out_uint16_le(s, 1);
94            out_uint16_le(s, LICENCE_HWID_SIZE);
95            out_uint8p(s, hwid, LICENCE_HWID_SIZE);
96    
97            out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE);
98    
99            s_mark_end(s);
100            sec_send(s, sec_flags);
101  }  }
102    
103  /* Send a licence request packet */  /* Send a licence request packet */
104  static void  static void
105  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)  
106  {  {
107          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
108          uint16 userlen = strlen(user) + 1;          uint16 userlen = strlen(user) + 1;
109          uint16 hostlen = strlen(host) + 1;          uint16 hostlen = strlen(host) + 1;
110          uint16 length = 120 + userlen + hostlen;          uint16 length = 128 + userlen + hostlen;
111          STREAM s;          STREAM s;
112    
113          s = sec_init(sec_flags, length + 2);          s = sec_init(sec_flags, length + 2);
114    
115          out_uint16_le(s, LICENCE_TAG_REQUEST);          out_uint8(s, LICENCE_TAG_REQUEST);
116            out_uint8(s, 2); /* version */
117          out_uint16_le(s, length);          out_uint16_le(s, length);
118    
119          out_uint32_le(s, 1);          out_uint32_le(s, 1);
120          out_uint32_le(s, 0xff010000);          out_uint16(s, 0);
121            out_uint16_le(s, 0xff01);
122    
123          out_uint8p(s, client_random, SEC_RANDOM_SIZE);          out_uint8p(s, client_random, SEC_RANDOM_SIZE);
124          out_uint16(s, 0);          out_uint16(s, 0);
# Line 73  licence_send_request(uint8 *client_rando Line 126  licence_send_request(uint8 *client_rando
126          out_uint8p(s, rsa_data, SEC_MODULUS_SIZE);          out_uint8p(s, rsa_data, SEC_MODULUS_SIZE);
127          out_uint8s(s, SEC_PADDING_SIZE);          out_uint8s(s, SEC_PADDING_SIZE);
128    
129          out_uint16(s, LICENCE_TAG_USER);          out_uint16_le(s, LICENCE_TAG_USER);
130          out_uint16(s, userlen);          out_uint16_le(s, userlen);
131          out_uint8p(s, user, userlen);          out_uint8p(s, user, userlen);
132    
133          out_uint16(s, LICENCE_TAG_HOST);          out_uint16_le(s, LICENCE_TAG_HOST);
134          out_uint16(s, hostlen);          out_uint16_le(s, hostlen);
135          out_uint8p(s, host, hostlen);          out_uint8p(s, host, hostlen);
136    
137          s_mark_end(s);          s_mark_end(s);
# Line 91  licence_process_demand(STREAM s) Line 144  licence_process_demand(STREAM s)
144  {  {
145          uint8 null_data[SEC_MODULUS_SIZE];          uint8 null_data[SEC_MODULUS_SIZE];
146          uint8 *server_random;          uint8 *server_random;
147            uint8 signature[LICENCE_SIGNATURE_SIZE];
148            uint8 hwid[LICENCE_HWID_SIZE];
149            uint8 *licence_data;
150            int licence_size;
151            RC4_KEY crypt_key;
152    
153          /* Retrieve the server random from the incoming packet */          /* Retrieve the server random from the incoming packet */
154          in_uint8p(s, server_random, SEC_RANDOM_SIZE);          in_uint8p(s, server_random, SEC_RANDOM_SIZE);
# Line 100  licence_process_demand(STREAM s) Line 158  licence_process_demand(STREAM s)
158          memset(null_data, 0, sizeof(null_data));          memset(null_data, 0, sizeof(null_data));
159          licence_generate_keys(null_data, server_random, null_data);          licence_generate_keys(null_data, server_random, null_data);
160    
161          /* Send a certificate request back to the server */          licence_size = load_licence(&licence_data);
162            if (licence_size > 0)
163            {
164                    /* Generate a signature for the HWID buffer */
165                    licence_generate_hwid(hwid);
166                    sec_sign(signature, 16, g_licence_sign_key, 16, hwid, sizeof(hwid));
167    
168                    /* Now encrypt the HWID */
169                    RC4_set_key(&crypt_key, 16, g_licence_key);
170                    RC4(&crypt_key, sizeof(hwid), hwid, hwid);
171    
172                    licence_present(null_data, null_data, licence_data, licence_size, hwid, signature);
173                    xfree(licence_data);
174                    return;
175            }
176    
177          licence_send_request(null_data, null_data, username, hostname);          licence_send_request(null_data, null_data, username, hostname);
178  }  }
179    
180  /* Send an authentication response packet */  /* Send an authentication response packet */
181  static void  static void
182  licence_send_authresp(uint8 *token, uint8 *crypt_hwid, uint8 *signature)  licence_send_authresp(uint8 * token, uint8 * crypt_hwid, uint8 * signature)
183  {  {
184          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
185          uint16 length = 58;          uint16 length = 58;
# Line 114  licence_send_authresp(uint8 *token, uint Line 187  licence_send_authresp(uint8 *token, uint
187    
188          s = sec_init(sec_flags, length + 2);          s = sec_init(sec_flags, length + 2);
189    
190          out_uint16_le(s, LICENCE_TAG_AUTHRESP);          out_uint8(s, LICENCE_TAG_AUTHRESP);
191            out_uint8(s, 2); /* version */
192          out_uint16_le(s, length);          out_uint16_le(s, length);
193    
194          out_uint16_le(s, 1);          out_uint16_le(s, 1);
# Line 133  licence_send_authresp(uint8 *token, uint Line 207  licence_send_authresp(uint8 *token, uint
207    
208  /* Parse an authentication request packet */  /* Parse an authentication request packet */
209  static BOOL  static BOOL
210  licence_parse_authreq(STREAM s, uint8 **token, uint8 **signature)  licence_parse_authreq(STREAM s, uint8 ** token, uint8 ** signature)
211  {  {
212          uint16 tokenlen;          uint16 tokenlen;
213    
# Line 157  static void Line 231  static void
231  licence_process_authreq(STREAM s)  licence_process_authreq(STREAM s)
232  {  {
233          uint8 *in_token, *in_sig;          uint8 *in_token, *in_sig;
234          uint8 out_token[LICENCE_TOKEN_SIZE],          uint8 out_token[LICENCE_TOKEN_SIZE], decrypt_token[LICENCE_TOKEN_SIZE];
                 decrypt_token[LICENCE_TOKEN_SIZE];  
235          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];
236          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];
237          uint8 out_sig[LICENCE_SIGNATURE_SIZE];          uint8 out_sig[LICENCE_SIGNATURE_SIZE];
# Line 169  licence_process_authreq(STREAM s) Line 242  licence_process_authreq(STREAM s)
242          memcpy(out_token, in_token, LICENCE_TOKEN_SIZE);          memcpy(out_token, in_token, LICENCE_TOKEN_SIZE);
243    
244          /* Decrypt the token. It should read TEST in Unicode. */          /* Decrypt the token. It should read TEST in Unicode. */
245          RC4_set_key(&crypt_key, 16, licence_key);          RC4_set_key(&crypt_key, 16, g_licence_key);
246          RC4(&crypt_key, LICENCE_TOKEN_SIZE, in_token, decrypt_token);          RC4(&crypt_key, LICENCE_TOKEN_SIZE, in_token, decrypt_token);
247    
         /* Construct HWID */  
         buf_out_uint32(hwid, 2);  
         strncpy(hwid + 4, hostname, LICENCE_HWID_SIZE - 4);  
   
248          /* Generate a signature for a buffer of token and HWID */          /* Generate a signature for a buffer of token and HWID */
249            licence_generate_hwid(hwid);
250          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);
251          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);
252          sec_sign(out_sig, licence_sign_key, 16,          sec_sign(out_sig, 16, g_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));  
253    
254          /* Now encrypt the HWID */          /* Now encrypt the HWID */
255          RC4_set_key(&crypt_key, 16, licence_key);          RC4_set_key(&crypt_key, 16, g_licence_key);
256          RC4(&crypt_key, LICENCE_HWID_SIZE, hwid, crypt_hwid);          RC4(&crypt_key, LICENCE_HWID_SIZE, hwid, crypt_hwid);
257    
258          licence_send_authresp(out_token, crypt_hwid, out_sig);          licence_send_authresp(out_token, crypt_hwid, out_sig);
# Line 200  licence_process_issue(STREAM s) Line 265  licence_process_issue(STREAM s)
265          RC4_KEY crypt_key;          RC4_KEY crypt_key;
266          uint32 length;          uint32 length;
267          uint16 check;          uint16 check;
268            int i;
269    
270          in_uint8s(s, 2);        /* 3d 45 - unknown */          in_uint8s(s, 2);        /* 3d 45 - unknown */
271          in_uint16_le(s, length);          in_uint16_le(s, length);
272          if (!s_check_rem(s, length))          if (!s_check_rem(s, length))
273                  return;                  return;
274    
275          RC4_set_key(&crypt_key, 16, licence_key);          RC4_set_key(&crypt_key, 16, g_licence_key);
276          RC4(&crypt_key, length, s->p, s->p);          RC4(&crypt_key, length, s->p, s->p);
277    
278          in_uint16(s, check);          in_uint16(s, check);
279          if (check != 0)          if (check != 0)
280                  return;                  return;
281    
282          licence_issued = True;          g_licence_issued = True;
283    
284            in_uint8s(s, 2);        /* pad */
285    
286            /* advance to fourth string */
287            length = 0;
288            for (i = 0; i < 4; i++)
289            {
290                    in_uint8s(s, length);
291                    in_uint32_le(s, length);
292                    if (!s_check_rem(s, length))
293                            return;
294            }
295    
296          /* We should save the licence here */          g_licence_issued = True;
297            save_licence(s->p, length);
298  }  }
299    
300  /* Process a licence packet */  /* Process a licence packet */
301  void  void
302  licence_process(STREAM s)  licence_process(STREAM s)
303  {  {
304          uint16 tag;          uint8 tag;
305    
306          in_uint16_le(s, tag);          in_uint8(s, tag);
307          in_uint8s(s, 2);        /* length */          in_uint8s(s, 3);        /* version, length */
308    
309          switch (tag)          switch (tag)
310          {          {
# Line 241  licence_process(STREAM s) Line 320  licence_process(STREAM s)
320                          licence_process_issue(s);                          licence_process_issue(s);
321                          break;                          break;
322    
323                    case LICENCE_TAG_REISSUE:
324                  case LICENCE_TAG_RESULT:                  case LICENCE_TAG_RESULT:
325                          break;                          break;
326    
Legend:
Removed from v.30  
changed lines
  Added in v.380
  ViewVC Help
Powered by ViewVC 1.1.26