/[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 82 by astrand, Tue Jul 30 07:18:48 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    /* 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, uint8 * hwid, uint8 * signature)
62    {
63            uint32 sec_flags = SEC_LICENCE_NEG;
64            uint16 length =
65                    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, char *user, char *host)
101  {  {
102          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
103          uint16 userlen = strlen(user) + 1;          uint16 userlen = strlen(user) + 1;
104          uint16 hostlen = strlen(host) + 1;          uint16 hostlen = strlen(host) + 1;
105          uint16 length = 120 + userlen + hostlen;          uint16 length = 128 + userlen + hostlen;
106          STREAM s;          STREAM s;
107    
108          s = sec_init(sec_flags, length + 2);          s = sec_init(sec_flags, length + 2);
# Line 62  static void licence_send_request(uint8 * Line 111  static void licence_send_request(uint8 *
111          out_uint16_le(s, length);          out_uint16_le(s, length);
112    
113          out_uint32_le(s, 1);          out_uint32_le(s, 1);
114          out_uint32_le(s, 0xff010000);          out_uint16(s, 0);
115            out_uint16_le(s, 0xff01);
116    
117          out_uint8p(s, client_random, SEC_RANDOM_SIZE);          out_uint8p(s, client_random, SEC_RANDOM_SIZE);
118          out_uint16(s, 0);          out_uint16(s, 0);
# Line 83  static void licence_send_request(uint8 * Line 133  static void licence_send_request(uint8 *
133  }  }
134    
135  /* Process a licence demand packet */  /* Process a licence demand packet */
136  static void licence_process_demand(STREAM s)  static void
137    licence_process_demand(STREAM s)
138  {  {
139          uint8 null_data[SEC_MODULUS_SIZE];          uint8 null_data[SEC_MODULUS_SIZE];
140            uint8 hwid[LICENCE_HWID_SIZE];
141            uint8 signature[LICENCE_SIGNATURE_SIZE];
142          uint8 *server_random;          uint8 *server_random;
143            uint8 *licence_data;
144            int licence_size;
145            RC4_KEY crypt_key;
146    
147          /* Retrieve the server random from the incoming packet */          /* Retrieve the server random from the incoming packet */
148          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 152  static void licence_process_demand(STREA
152          memset(null_data, 0, sizeof(null_data));          memset(null_data, 0, sizeof(null_data));
153          licence_generate_keys(null_data, server_random, null_data);          licence_generate_keys(null_data, server_random, null_data);
154    
155          /* Send a certificate request back to the server */          licence_size = load_licence(&licence_data);
156          licence_send_request(null_data, null_data, username, hostname);          if (licence_size == -1)
157            {
158                    licence_send_request(null_data, null_data, username, hostname);
159                    return;
160            }
161    
162            /* 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  }  }
173    
174  /* Send an authentication response packet */  /* Send an authentication response packet */
175  static void licence_send_authresp(uint8 *token, uint8 *crypt_hwid,  static void
176                                    uint8 *signature)  licence_send_authresp(uint8 * token, uint8 * crypt_hwid, uint8 * signature)
177  {  {
178          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
179          uint16 length = 58;          uint16 length = 58;
# Line 128  static void licence_send_authresp(uint8 Line 199  static void licence_send_authresp(uint8
199  }  }
200    
201  /* Parse an authentication request packet */  /* Parse an authentication request packet */
202  static BOOL licence_parse_authreq(STREAM s, uint8 **token, uint8 **signature)  static BOOL
203    licence_parse_authreq(STREAM s, uint8 ** token, uint8 ** signature)
204  {  {
205          uint16 tokenlen;          uint16 tokenlen;
206    
# Line 137  static BOOL licence_parse_authreq(STREAM Line 209  static BOOL licence_parse_authreq(STREAM
209          in_uint16_le(s, tokenlen);          in_uint16_le(s, tokenlen);
210          if (tokenlen != LICENCE_TOKEN_SIZE)          if (tokenlen != LICENCE_TOKEN_SIZE)
211          {          {
212                  ERROR("token len %d\n", tokenlen);                  error("token len %d\n", tokenlen);
213                  return False;                  return False;
214          }          }
215    
# Line 148  static BOOL licence_parse_authreq(STREAM Line 220  static BOOL licence_parse_authreq(STREAM
220  }  }
221    
222  /* Process an authentication request packet */  /* Process an authentication request packet */
223  static void licence_process_authreq(STREAM s)  static void
224    licence_process_authreq(STREAM s)
225  {  {
226          uint8 *in_token, *in_sig;          uint8 *in_token, *in_sig;
227          uint8 out_token[LICENCE_TOKEN_SIZE],          uint8 out_token[LICENCE_TOKEN_SIZE], decrypt_token[LICENCE_TOKEN_SIZE];
                 decrypt_token[LICENCE_TOKEN_SIZE];  
228          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];
229          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];
230          uint8 out_sig[LICENCE_SIGNATURE_SIZE];          uint8 out_sig[LICENCE_SIGNATURE_SIZE];
# Line 166  static void licence_process_authreq(STRE Line 238  static void licence_process_authreq(STRE
238          RC4_set_key(&crypt_key, 16, licence_key);          RC4_set_key(&crypt_key, 16, licence_key);
239          RC4(&crypt_key, LICENCE_TOKEN_SIZE, in_token, decrypt_token);          RC4(&crypt_key, LICENCE_TOKEN_SIZE, in_token, decrypt_token);
240    
         /* Construct HWID */  
         buf_out_uint32(hwid, 2);  
         strncpy(hwid + 4, hostname, LICENCE_HWID_SIZE - 4);  
   
241          /* Generate a signature for a buffer of token and HWID */          /* Generate a signature for a buffer of token and HWID */
242            licence_generate_hwid(hwid);
243          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);
244          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);
245          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));  
246    
247          /* Deliberately break signature if licencing disabled */          /* Deliberately break signature if licencing disabled */
248          if (!licence)          if (!licence)
# Line 188  static void licence_process_authreq(STRE Line 256  static void licence_process_authreq(STRE
256  }  }
257    
258  /* Process an licence issue packet */  /* Process an licence issue packet */
259  static void licence_process_issue(STREAM s)  static void
260    licence_process_issue(STREAM s)
261  {  {
262          RC4_KEY crypt_key;          RC4_KEY crypt_key;
263          uint32 length;          uint32 length;
# Line 206  static void licence_process_issue(STREAM Line 275  static void licence_process_issue(STREAM
275          if (check != 0)          if (check != 0)
276                  return;                  return;
277    
278          /* We should save the licence here */          licence_issued = True;
279          STATUS("Server issued licence.\n");          save_licence(s->p, length - 2);
280  }  }
281    
282  /* Process a licence packet */  /* Process a licence packet */
283  void licence_process(STREAM s)  void
284    licence_process(STREAM s)
285  {  {
286          uint16 tag;          uint16 tag;
287    
# Line 232  void licence_process(STREAM s) Line 302  void licence_process(STREAM s)
302                          licence_process_issue(s);                          licence_process_issue(s);
303                          break;                          break;
304    
305                    case LICENCE_TAG_REISSUE:
306                            break;
307    
308                  case LICENCE_TAG_RESULT:                  case LICENCE_TAG_RESULT:
309                          break;                          break;
310    
311                  default:                  default:
312                          NOTIMP("licence tag 0x%x\n", tag);                          unimpl("licence tag 0x%x\n", tag);
313          }          }
314  }  }
Legend:
Removed from v.24  
changed lines
  Added in v.82
  ViewVC Help
Powered by ViewVC 1.1.26