/[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 64 by astrand, Thu Jul 18 16:38:31 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,
36                          uint8 * client_rsa)
37  {  {
38          uint8 session_key[48];          uint8 session_key[48];
39          uint8 temp_hash[48];          uint8 temp_hash[48];
# Line 46  void licence_generate_keys(uint8 *client Line 49  void licence_generate_keys(uint8 *client
49          sec_hash_16(licence_key, &session_key[16], client_key, server_key);          sec_hash_16(licence_key, &session_key[16], client_key, server_key);
50  }  }
51    
52    static void
53    licence_generate_hwid(uint8 * hwid)
54    {
55            buf_out_uint32(hwid, 2);
56            strncpy(hwid + 4, hostname, LICENCE_HWID_SIZE - 4);
57    }
58    
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,
63                    uint8 * hwid, uint8 * signature)
64    {
65            uint32 sec_flags = SEC_LICENCE_NEG;
66            uint16 length =
67                    16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE +
68                    licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;
69            STREAM s;
70    
71            s = sec_init(sec_flags, length + 4);
72    
73            out_uint16_le(s, LICENCE_TAG_PRESENT);
74            out_uint16_le(s, length);
75    
76            out_uint32_le(s, 1);
77            out_uint16(s, 0);
78            out_uint16_le(s, 0x0201);
79    
80            out_uint8p(s, client_random, SEC_RANDOM_SIZE);
81            out_uint16(s, 0);
82            out_uint16_le(s, (SEC_MODULUS_SIZE + SEC_PADDING_SIZE));
83            out_uint8p(s, rsa_data, SEC_MODULUS_SIZE);
84            out_uint8s(s, SEC_PADDING_SIZE);
85    
86            out_uint16_le(s, 1);
87            out_uint16_le(s, licence_size);
88            out_uint8p(s, licence_data, licence_size);
89    
90            out_uint16_le(s, 1);
91            out_uint16_le(s, LICENCE_HWID_SIZE);
92            out_uint8p(s, hwid, LICENCE_HWID_SIZE);
93    
94            out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE);
95    
96            s_mark_end(s);
97            sec_send(s, sec_flags);
98    }
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,
103                         char *user, char *host)
104  {  {
105          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
106          uint16 userlen = strlen(user) + 1;          uint16 userlen = strlen(user) + 1;
107          uint16 hostlen = strlen(host) + 1;          uint16 hostlen = strlen(host) + 1;
108          uint16 length = 120 + userlen + hostlen;          uint16 length = 128 + userlen + hostlen;
109          STREAM s;          STREAM s;
110    
111          s = sec_init(sec_flags, length + 2);          s = sec_init(sec_flags, length + 2);
# Line 62  static void licence_send_request(uint8 * Line 114  static void licence_send_request(uint8 *
114          out_uint16_le(s, length);          out_uint16_le(s, length);
115    
116          out_uint32_le(s, 1);          out_uint32_le(s, 1);
117          out_uint32_le(s, 0xff010000);          out_uint16(s, 0);
118            out_uint16_le(s, 0xff01);
119    
120          out_uint8p(s, client_random, SEC_RANDOM_SIZE);          out_uint8p(s, client_random, SEC_RANDOM_SIZE);
121          out_uint16(s, 0);          out_uint16(s, 0);
# Line 83  static void licence_send_request(uint8 * Line 136  static void licence_send_request(uint8 *
136  }  }
137    
138  /* Process a licence demand packet */  /* Process a licence demand packet */
139  static void licence_process_demand(STREAM s)  static void
140    licence_process_demand(STREAM s)
141  {  {
142          uint8 null_data[SEC_MODULUS_SIZE];          uint8 null_data[SEC_MODULUS_SIZE];
143            uint8 hwid[LICENCE_HWID_SIZE];
144            uint8 signature[LICENCE_SIGNATURE_SIZE];
145          uint8 *server_random;          uint8 *server_random;
146            uint8 *licence_data;
147            int licence_size;
148            RC4_KEY crypt_key;
149    
150          /* Retrieve the server random from the incoming packet */          /* Retrieve the server random from the incoming packet */
151          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 155  static void licence_process_demand(STREA
155          memset(null_data, 0, sizeof(null_data));          memset(null_data, 0, sizeof(null_data));
156          licence_generate_keys(null_data, server_random, null_data);          licence_generate_keys(null_data, server_random, null_data);
157    
158          /* Send a certificate request back to the server */          licence_size = load_licence(&licence_data);
159          licence_send_request(null_data, null_data, username, hostname);          if (licence_size == -1)
160            {
161                    licence_send_request(null_data, null_data, username,
162                                         hostname);
163                    return;
164            }
165    
166            /* Generate a signature for the HWID buffer */
167            licence_generate_hwid(hwid);
168            sec_sign(signature, 16, licence_sign_key, 16, hwid, sizeof(hwid));
169    
170            /* Now encrypt the HWID */
171            RC4_set_key(&crypt_key, 16, licence_key);
172            RC4(&crypt_key, sizeof(hwid), hwid, hwid);
173    
174            licence_present(null_data, null_data, licence_data, licence_size,
175                            hwid, signature);
176            xfree(licence_data);
177  }  }
178    
179  /* Send an authentication response packet */  /* Send an authentication response packet */
180  static void licence_send_authresp(uint8 *token, uint8 *crypt_hwid,  static void
181                                    uint8 *signature)  licence_send_authresp(uint8 * token, uint8 * crypt_hwid, uint8 * signature)
182  {  {
183          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
184          uint16 length = 58;          uint16 length = 58;
# Line 128  static void licence_send_authresp(uint8 Line 204  static void licence_send_authresp(uint8
204  }  }
205    
206  /* Parse an authentication request packet */  /* Parse an authentication request packet */
207  static BOOL licence_parse_authreq(STREAM s, uint8 **token, uint8 **signature)  static BOOL
208    licence_parse_authreq(STREAM s, uint8 ** token, uint8 ** signature)
209  {  {
210          uint16 tokenlen;          uint16 tokenlen;
211    
# Line 137  static BOOL licence_parse_authreq(STREAM Line 214  static BOOL licence_parse_authreq(STREAM
214          in_uint16_le(s, tokenlen);          in_uint16_le(s, tokenlen);
215          if (tokenlen != LICENCE_TOKEN_SIZE)          if (tokenlen != LICENCE_TOKEN_SIZE)
216          {          {
217                  ERROR("token len %d\n", tokenlen);                  error("token len %d\n", tokenlen);
218                  return False;                  return False;
219          }          }
220    
# Line 148  static BOOL licence_parse_authreq(STREAM Line 225  static BOOL licence_parse_authreq(STREAM
225  }  }
226    
227  /* Process an authentication request packet */  /* Process an authentication request packet */
228  static void licence_process_authreq(STREAM s)  static void
229    licence_process_authreq(STREAM s)
230  {  {
231          uint8 *in_token, *in_sig;          uint8 *in_token, *in_sig;
232          uint8 out_token[LICENCE_TOKEN_SIZE],          uint8 out_token[LICENCE_TOKEN_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,
252                   sealed_buffer, sizeof(sealed_buffer));                   sealed_buffer, sizeof(sealed_buffer));
253    
254          /* Deliberately break signature if licencing disabled */          /* Deliberately break signature if licencing disabled */
# Line 188  static void licence_process_authreq(STRE Line 263  static void licence_process_authreq(STRE
263  }  }
264    
265  /* Process an licence issue packet */  /* Process an licence issue packet */
266  static void licence_process_issue(STREAM s)  static void
267    licence_process_issue(STREAM s)
268  {  {
269          RC4_KEY crypt_key;          RC4_KEY crypt_key;
270          uint32 length;          uint32 length;
# Line 206  static void licence_process_issue(STREAM Line 282  static void licence_process_issue(STREAM
282          if (check != 0)          if (check != 0)
283                  return;                  return;
284    
285          /* We should save the licence here */          licence_issued = True;
286          STATUS("Server issued licence.\n");          save_licence(s->p, length - 2);
287  }  }
288    
289  /* Process a licence packet */  /* Process a licence packet */
290  void licence_process(STREAM s)  void
291    licence_process(STREAM s)
292  {  {
293          uint16 tag;          uint16 tag;
294    
# Line 232  void licence_process(STREAM s) Line 309  void licence_process(STREAM s)
309                          licence_process_issue(s);                          licence_process_issue(s);
310                          break;                          break;
311    
312                    case LICENCE_TAG_REISSUE:
313                            break;
314    
315                  case LICENCE_TAG_RESULT:                  case LICENCE_TAG_RESULT:
316                          break;                          break;
317    
318                  default:                  default:
319                          NOTIMP("licence tag 0x%x\n", tag);                          unimpl("licence tag 0x%x\n", tag);
320          }          }
321  }  }
Legend:
Removed from v.24  
changed lines
  Added in v.64
  ViewVC Help
Powered by ViewVC 1.1.26