/[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 24 by matty, Sat Jan 6 03:12:10 2001 UTC revision 190 by matthewc, Tue Sep 24 07:33:17 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-2000     Copyright (C) Matthew Chapman 1999-2001
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 28  extern BOOL licence; Line 28  extern BOOL licence;
28  static uint8 licence_key[16];  static uint8 licence_key[16];
29  static uint8 licence_sign_key[16];  static uint8 licence_sign_key[16];
30    
31    BOOL licence_issued = False;
32    
33  /* Generate a session key and RC4 keys, given client and server randoms */  /* Generate a session key and RC4 keys, given client and server randoms */
34  void licence_generate_keys(uint8 *client_key, uint8 *server_key,  static void
35                             uint8 *client_rsa)  licence_generate_keys(uint8 * client_key, uint8 * server_key, uint8 * client_rsa)
36  {  {
37          uint8 session_key[48];          uint8 session_key[48];
38          uint8 temp_hash[48];          uint8 temp_hash[48];
# Line 46  void licence_generate_keys(uint8 *client Line 48  void licence_generate_keys(uint8 *client
48          sec_hash_16(licence_key, &session_key[16], client_key, server_key);          sec_hash_16(licence_key, &session_key[16], client_key, server_key);
49  }  }
50    
51    static void
52    licence_generate_hwid(uint8 * hwid)
53    {
54            buf_out_uint32(hwid, 2);
55            strncpy((char *) (hwid + 4), hostname, LICENCE_HWID_SIZE - 4);
56    }
57    
58    #ifdef SAVE_LICENCE
59    /* Present an existing licence to the server */
60    static void
61    licence_present(uint8 * client_random, uint8 * rsa_data,
62                    uint8 * licence_data, int licence_size, uint8 * hwid, uint8 * signature)
63    {
64            uint32 sec_flags = SEC_LICENCE_NEG;
65            uint16 length =
66                    16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE +
67                    licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;
68            STREAM s;
69    
70            s = sec_init(sec_flags, length + 4);
71    
72            out_uint16_le(s, LICENCE_TAG_PRESENT);
73            out_uint16_le(s, length);
74    
75            out_uint32_le(s, 1);
76            out_uint16(s, 0);
77            out_uint16_le(s, 0x0201);
78    
79            out_uint8p(s, client_random, SEC_RANDOM_SIZE);
80            out_uint16(s, 0);
81            out_uint16_le(s, (SEC_MODULUS_SIZE + SEC_PADDING_SIZE));
82            out_uint8p(s, rsa_data, SEC_MODULUS_SIZE);
83            out_uint8s(s, SEC_PADDING_SIZE);
84    
85            out_uint16_le(s, 1);
86            out_uint16_le(s, licence_size);
87            out_uint8p(s, licence_data, licence_size);
88    
89            out_uint16_le(s, 1);
90            out_uint16_le(s, LICENCE_HWID_SIZE);
91            out_uint8p(s, hwid, LICENCE_HWID_SIZE);
92    
93            out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE);
94    
95            s_mark_end(s);
96            sec_send(s, sec_flags);
97    }
98    #endif
99    
100  /* Send a licence request packet */  /* Send a licence request packet */
101  static void licence_send_request(uint8 *client_random, uint8 *rsa_data,  static void
102                                   char *user, char *host)  licence_send_request(uint8 * client_random, uint8 * rsa_data, char *user, char *host)
103  {  {
104          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
105          uint16 userlen = strlen(user) + 1;          uint16 userlen = strlen(user) + 1;
106          uint16 hostlen = strlen(host) + 1;          uint16 hostlen = strlen(host) + 1;
107          uint16 length = 120 + userlen + hostlen;          uint16 length = 128 + userlen + hostlen;
108          STREAM s;          STREAM s;
109    
110          s = sec_init(sec_flags, length + 2);          s = sec_init(sec_flags, length + 2);
# Line 62  static void licence_send_request(uint8 * Line 113  static void licence_send_request(uint8 *
113          out_uint16_le(s, length);          out_uint16_le(s, length);
114    
115          out_uint32_le(s, 1);          out_uint32_le(s, 1);
116          out_uint32_le(s, 0xff010000);          out_uint16(s, 0);
117            out_uint16_le(s, 0xff01);
118    
119          out_uint8p(s, client_random, SEC_RANDOM_SIZE);          out_uint8p(s, client_random, SEC_RANDOM_SIZE);
120          out_uint16(s, 0);          out_uint16(s, 0);
# Line 83  static void licence_send_request(uint8 * Line 135  static void licence_send_request(uint8 *
135  }  }
136    
137  /* Process a licence demand packet */  /* Process a licence demand packet */
138  static void licence_process_demand(STREAM s)  static void
139    licence_process_demand(STREAM s)
140  {  {
141          uint8 null_data[SEC_MODULUS_SIZE];          uint8 null_data[SEC_MODULUS_SIZE];
142          uint8 *server_random;          uint8 *server_random;
143    #ifdef SAVE_LICENCE
144            uint8 signature[LICENCE_SIGNATURE_SIZE];
145            uint8 hwid[LICENCE_HWID_SIZE];
146            uint8 *licence_data;
147            int licence_size;
148            RC4_KEY crypt_key;
149    #endif
150    
151          /* Retrieve the server random from the incoming packet */          /* Retrieve the server random from the incoming packet */
152          in_uint8p(s, server_random, SEC_RANDOM_SIZE);          in_uint8p(s, server_random, SEC_RANDOM_SIZE);
# Line 96  static void licence_process_demand(STREA Line 156  static void licence_process_demand(STREA
156          memset(null_data, 0, sizeof(null_data));          memset(null_data, 0, sizeof(null_data));
157          licence_generate_keys(null_data, server_random, null_data);          licence_generate_keys(null_data, server_random, null_data);
158    
159          /* Send a certificate request back to the server */  #ifdef SAVE_LICENCE
160            licence_size = load_licence(&licence_data);
161            if (licence_size != -1)
162            {
163                    /* Generate a signature for the HWID buffer */
164                    licence_generate_hwid(hwid);
165                    sec_sign(signature, 16, licence_sign_key, 16, hwid, sizeof(hwid));
166    
167                    /* Now encrypt the HWID */
168                    RC4_set_key(&crypt_key, 16, licence_key);
169                    RC4(&crypt_key, sizeof(hwid), hwid, hwid);
170    
171                    licence_present(null_data, null_data, licence_data, licence_size, hwid, signature);
172                    xfree(licence_data);
173                    return;
174            }
175    #endif
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 licence_send_authresp(uint8 *token, uint8 *crypt_hwid,  static void
182                                    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 128  static void licence_send_authresp(uint8 Line 205  static void licence_send_authresp(uint8
205  }  }
206    
207  /* Parse an authentication request packet */  /* Parse an authentication request packet */
208  static BOOL licence_parse_authreq(STREAM s, uint8 **token, uint8 **signature)  static BOOL
209    licence_parse_authreq(STREAM s, uint8 ** token, uint8 ** signature)
210  {  {
211          uint16 tokenlen;          uint16 tokenlen;
212    
# Line 137  static BOOL licence_parse_authreq(STREAM Line 215  static BOOL licence_parse_authreq(STREAM
215          in_uint16_le(s, tokenlen);          in_uint16_le(s, tokenlen);
216          if (tokenlen != LICENCE_TOKEN_SIZE)          if (tokenlen != LICENCE_TOKEN_SIZE)
217          {          {
218                  ERROR("token len %d\n", tokenlen);                  error("token len %d\n", tokenlen);
219                  return False;                  return False;
220          }          }
221    
# Line 148  static BOOL licence_parse_authreq(STREAM Line 226  static BOOL licence_parse_authreq(STREAM
226  }  }
227    
228  /* Process an authentication request packet */  /* Process an authentication request packet */
229  static void licence_process_authreq(STREAM s)  static void
230    licence_process_authreq(STREAM s)
231  {  {
232          uint8 *in_token, *in_sig;          uint8 *in_token, *in_sig;
233          uint8 out_token[LICENCE_TOKEN_SIZE],          uint8 out_token[LICENCE_TOKEN_SIZE], decrypt_token[LICENCE_TOKEN_SIZE];
                 decrypt_token[LICENCE_TOKEN_SIZE];  
234          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];
235          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];
236          uint8 out_sig[LICENCE_SIGNATURE_SIZE];          uint8 out_sig[LICENCE_SIGNATURE_SIZE];
# Line 166  static void licence_process_authreq(STRE Line 244  static void licence_process_authreq(STRE
244          RC4_set_key(&crypt_key, 16, licence_key);          RC4_set_key(&crypt_key, 16, licence_key);
245          RC4(&crypt_key, LICENCE_TOKEN_SIZE, in_token, decrypt_token);          RC4(&crypt_key, LICENCE_TOKEN_SIZE, in_token, decrypt_token);
246    
         /* Construct HWID */  
         buf_out_uint32(hwid, 2);  
         strncpy(hwid + 4, hostname, LICENCE_HWID_SIZE - 4);  
   
247          /* Generate a signature for a buffer of token and HWID */          /* Generate a signature for a buffer of token and HWID */
248            licence_generate_hwid(hwid);
249          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);
250          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);
251          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));  
252    
253          /* Deliberately break signature if licencing disabled */          /* Deliberately break signature if licencing disabled */
254          if (!licence)          if (!licence)
# Line 188  static void licence_process_authreq(STRE Line 262  static void licence_process_authreq(STRE
262  }  }
263    
264  /* Process an licence issue packet */  /* Process an licence issue packet */
265  static void licence_process_issue(STREAM s)  static void
266    licence_process_issue(STREAM s)
267  {  {
268          RC4_KEY crypt_key;          RC4_KEY crypt_key;
269          uint32 length;          uint32 length;
# Line 206  static void licence_process_issue(STREAM Line 281  static void licence_process_issue(STREAM
281          if (check != 0)          if (check != 0)
282                  return;                  return;
283    
284          /* We should save the licence here */          licence_issued = True;
285          STATUS("Server issued licence.\n");  
286    #ifdef SAVE_LICENCE
287            save_licence(s->p, length - 2);
288    #endif
289  }  }
290    
291  /* Process a licence packet */  /* Process a licence packet */
292  void licence_process(STREAM s)  void
293    licence_process(STREAM s)
294  {  {
295          uint16 tag;          uint16 tag;
296    
# Line 232  void licence_process(STREAM s) Line 311  void licence_process(STREAM s)
311                          licence_process_issue(s);                          licence_process_issue(s);
312                          break;                          break;
313    
314                    case LICENCE_TAG_REISSUE:
315                            break;
316    
317                  case LICENCE_TAG_RESULT:                  case LICENCE_TAG_RESULT:
318                          break;                          break;
319    
320                  default:                  default:
321                          NOTIMP("licence tag 0x%x\n", tag);                          unimpl("licence tag 0x%x\n", tag);
322          }          }
323  }  }
Legend:
Removed from v.24  
changed lines
  Added in v.190
  ViewVC Help
Powered by ViewVC 1.1.26