/[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 61 by matthewc, Sun Jul 14 12:06:03 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(hwid + 4, hostname, LICENCE_HWID_SIZE - 4);
56    }
57    
58    /* Present an existing licence to the server */
59    static void
60    licence_present(uint8 *client_random, uint8 *rsa_data,
61                    uint8 *licence_data, int licence_size,
62                    uint8 *hwid, uint8 *signature)
63    {
64            uint32 sec_flags = SEC_LICENCE_NEG;
65            uint16 length = 16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE
66                            + licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;
67            STREAM s;
68    
69            s = sec_init(sec_flags, length + 4);
70    
71            out_uint16_le(s, LICENCE_TAG_PRESENT);
72            out_uint16_le(s, length);
73    
74            out_uint32_le(s, 1);
75            out_uint16(s, 0);
76            out_uint16_le(s, 0x0201);
77    
78            out_uint8p(s, client_random, SEC_RANDOM_SIZE);
79            out_uint16(s, 0);
80            out_uint16_le(s, (SEC_MODULUS_SIZE + SEC_PADDING_SIZE));
81            out_uint8p(s, rsa_data, SEC_MODULUS_SIZE);
82            out_uint8s(s, SEC_PADDING_SIZE);
83    
84            out_uint16_le(s, 1);
85            out_uint16_le(s, licence_size);
86            out_uint8p(s, licence_data, licence_size);
87    
88            out_uint16_le(s, 1);
89            out_uint16_le(s, LICENCE_HWID_SIZE);
90            out_uint8p(s, hwid, LICENCE_HWID_SIZE);
91    
92            out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE);
93    
94            s_mark_end(s);
95            sec_send(s, sec_flags);
96    }
97    
98  /* Send a licence request packet */  /* Send a licence request packet */
99  static void licence_send_request(uint8 *client_random, uint8 *rsa_data,  static void
100                                   char *user, char *host)  licence_send_request(uint8 *client_random, uint8 *rsa_data,
101                         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 62  static void licence_send_request(uint8 * Line 112  static void licence_send_request(uint8 *
112          out_uint16_le(s, length);          out_uint16_le(s, length);
113    
114          out_uint32_le(s, 1);          out_uint32_le(s, 1);
115          out_uint32_le(s, 0xff010000);          out_uint16(s, 0);
116            out_uint16_le(s, 0xff01);
117    
118          out_uint8p(s, client_random, SEC_RANDOM_SIZE);          out_uint8p(s, client_random, SEC_RANDOM_SIZE);
119          out_uint16(s, 0);          out_uint16(s, 0);
# Line 83  static void licence_send_request(uint8 * Line 134  static void licence_send_request(uint8 *
134  }  }
135    
136  /* Process a licence demand packet */  /* Process a licence demand packet */
137  static void licence_process_demand(STREAM s)  static void
138    licence_process_demand(STREAM s)
139  {  {
140          uint8 null_data[SEC_MODULUS_SIZE];          uint8 null_data[SEC_MODULUS_SIZE];
141            uint8 hwid[LICENCE_HWID_SIZE];
142            uint8 signature[LICENCE_SIGNATURE_SIZE];
143          uint8 *server_random;          uint8 *server_random;
144            uint8 *licence_data;
145            int licence_size;
146            RC4_KEY crypt_key;
147    
148          /* Retrieve the server random from the incoming packet */          /* Retrieve the server random from the incoming packet */
149          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 153  static void licence_process_demand(STREA
153          memset(null_data, 0, sizeof(null_data));          memset(null_data, 0, sizeof(null_data));
154          licence_generate_keys(null_data, server_random, null_data);          licence_generate_keys(null_data, server_random, null_data);
155    
156          /* Send a certificate request back to the server */          licence_size = load_licence(&licence_data);
157          licence_send_request(null_data, null_data, username, hostname);          if (licence_size == -1)
158            {
159                    licence_send_request(null_data, null_data, username, hostname);
160                    return;
161            }
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,
172                                            hwid, signature);
173            xfree(licence_data);
174  }  }
175    
176  /* Send an authentication response packet */  /* Send an authentication response packet */
177  static void licence_send_authresp(uint8 *token, uint8 *crypt_hwid,  static void
178                                    uint8 *signature)  licence_send_authresp(uint8 *token, uint8 *crypt_hwid, uint8 *signature)
179  {  {
180          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
181          uint16 length = 58;          uint16 length = 58;
# Line 128  static void licence_send_authresp(uint8 Line 201  static void licence_send_authresp(uint8
201  }  }
202    
203  /* Parse an authentication request packet */  /* Parse an authentication request packet */
204  static BOOL licence_parse_authreq(STREAM s, uint8 **token, uint8 **signature)  static BOOL
205    licence_parse_authreq(STREAM s, uint8 **token, uint8 **signature)
206  {  {
207          uint16 tokenlen;          uint16 tokenlen;
208    
# Line 137  static BOOL licence_parse_authreq(STREAM Line 211  static BOOL licence_parse_authreq(STREAM
211          in_uint16_le(s, tokenlen);          in_uint16_le(s, tokenlen);
212          if (tokenlen != LICENCE_TOKEN_SIZE)          if (tokenlen != LICENCE_TOKEN_SIZE)
213          {          {
214                  ERROR("token len %d\n", tokenlen);                  error("token len %d\n", tokenlen);
215                  return False;                  return False;
216          }          }
217    
# Line 148  static BOOL licence_parse_authreq(STREAM Line 222  static BOOL licence_parse_authreq(STREAM
222  }  }
223    
224  /* Process an authentication request packet */  /* Process an authentication request packet */
225  static void licence_process_authreq(STREAM s)  static void
226    licence_process_authreq(STREAM s)
227  {  {
228          uint8 *in_token, *in_sig;          uint8 *in_token, *in_sig;
229          uint8 out_token[LICENCE_TOKEN_SIZE],          uint8 out_token[LICENCE_TOKEN_SIZE],
# Line 166  static void licence_process_authreq(STRE Line 241  static void licence_process_authreq(STRE
241          RC4_set_key(&crypt_key, 16, licence_key);          RC4_set_key(&crypt_key, 16, licence_key);
242          RC4(&crypt_key, LICENCE_TOKEN_SIZE, in_token, decrypt_token);          RC4(&crypt_key, LICENCE_TOKEN_SIZE, in_token, decrypt_token);
243    
         /* Construct HWID */  
         buf_out_uint32(hwid, 2);  
         strncpy(hwid + 4, hostname, LICENCE_HWID_SIZE - 4);  
   
244          /* Generate a signature for a buffer of token and HWID */          /* Generate a signature for a buffer of token and HWID */
245            licence_generate_hwid(hwid);
246          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);
247          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);
248          sec_sign(out_sig, licence_sign_key, 16,          sec_sign(out_sig, 16, licence_sign_key, 16,
249                   sealed_buffer, sizeof(sealed_buffer));                   sealed_buffer, sizeof(sealed_buffer));
250    
251          /* Deliberately break signature if licencing disabled */          /* Deliberately break signature if licencing disabled */
# Line 188  static void licence_process_authreq(STRE Line 260  static void licence_process_authreq(STRE
260  }  }
261    
262  /* Process an licence issue packet */  /* Process an licence issue packet */
263  static void licence_process_issue(STREAM s)  static void
264    licence_process_issue(STREAM s)
265  {  {
266          RC4_KEY crypt_key;          RC4_KEY crypt_key;
267          uint32 length;          uint32 length;
# Line 206  static void licence_process_issue(STREAM Line 279  static void licence_process_issue(STREAM
279          if (check != 0)          if (check != 0)
280                  return;                  return;
281    
282          /* We should save the licence here */          licence_issued = True;
283          STATUS("Server issued licence.\n");          save_licence(s->p, length-2);
284  }  }
285    
286  /* Process a licence packet */  /* Process a licence packet */
287  void licence_process(STREAM s)  void
288    licence_process(STREAM s)
289  {  {
290          uint16 tag;          uint16 tag;
291    
# Line 232  void licence_process(STREAM s) Line 306  void licence_process(STREAM s)
306                          licence_process_issue(s);                          licence_process_issue(s);
307                          break;                          break;
308    
309                    case LICENCE_TAG_REISSUE:
310                            break;
311    
312                  case LICENCE_TAG_RESULT:                  case LICENCE_TAG_RESULT:
313                          break;                          break;
314    
315                  default:                  default:
316                          NOTIMP("licence tag 0x%x\n", tag);                          unimpl("licence tag 0x%x\n", tag);
317          }          }
318  }  }
Legend:
Removed from v.24  
changed lines
  Added in v.61
  ViewVC Help
Powered by ViewVC 1.1.26