/[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 28 by matty, Wed Jun 20 13:54:48 2001 UTC revision 159 by matthewc, Sun Sep 15 12:36:55 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 31  static uint8 licence_sign_key[16]; Line 31  static uint8 licence_sign_key[16];
31  BOOL licence_issued = False;  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  static void
35  licence_generate_keys(uint8 *client_key, uint8 *server_key, 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 48  licence_generate_keys(uint8 *client_key, Line 48  licence_generate_keys(uint8 *client_key,
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  static void
102  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)  
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 65  licence_send_request(uint8 *client_rando Line 113  licence_send_request(uint8 *client_rando
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 90  static void Line 139  static void
139  licence_process_demand(STREAM s)  licence_process_demand(STREAM s)
140  {  {
141          uint8 null_data[SEC_MODULUS_SIZE];          uint8 null_data[SEC_MODULUS_SIZE];
142            uint8 hwid[LICENCE_HWID_SIZE];
143            uint8 signature[LICENCE_SIGNATURE_SIZE];
144          uint8 *server_random;          uint8 *server_random;
145            uint8 *licence_data;
146            int licence_size;
147            RC4_KEY crypt_key;
148    
149          /* Retrieve the server random from the incoming packet */          /* Retrieve the server random from the incoming packet */
150          in_uint8p(s, server_random, SEC_RANDOM_SIZE);          in_uint8p(s, server_random, SEC_RANDOM_SIZE);
# Line 100  licence_process_demand(STREAM s) Line 154  licence_process_demand(STREAM s)
154          memset(null_data, 0, sizeof(null_data));          memset(null_data, 0, sizeof(null_data));
155          licence_generate_keys(null_data, server_random, null_data);          licence_generate_keys(null_data, server_random, null_data);
156    
157          /* Send a certificate request back to the server */  #ifdef SAVE_LICENCE
158            licence_size = load_licence(&licence_data);
159            if (licence_size != -1)
160            {
161                    /* Generate a signature for the HWID buffer */
162                    licence_generate_hwid(hwid);
163                    sec_sign(signature, 16, licence_sign_key, 16, hwid, sizeof(hwid));
164    
165                    /* Now encrypt the HWID */
166                    RC4_set_key(&crypt_key, 16, licence_key);
167                    RC4(&crypt_key, sizeof(hwid), hwid, hwid);
168    
169                    licence_present(null_data, null_data, licence_data, licence_size, hwid, signature);
170                    xfree(licence_data);
171                    return;
172            }
173    #endif
174    
175          licence_send_request(null_data, null_data, username, hostname);          licence_send_request(null_data, null_data, username, hostname);
176  }  }
177    
178  /* Send an authentication response packet */  /* Send an authentication response packet */
179  static void  static void
180  licence_send_authresp(uint8 *token, uint8 *crypt_hwid, uint8 *signature)  licence_send_authresp(uint8 * token, uint8 * crypt_hwid, uint8 * signature)
181  {  {
182          uint32 sec_flags = SEC_LICENCE_NEG;          uint32 sec_flags = SEC_LICENCE_NEG;
183          uint16 length = 58;          uint16 length = 58;
# Line 133  licence_send_authresp(uint8 *token, uint Line 204  licence_send_authresp(uint8 *token, uint
204    
205  /* Parse an authentication request packet */  /* Parse an authentication request packet */
206  static BOOL  static BOOL
207  licence_parse_authreq(STREAM s, uint8 **token, uint8 **signature)  licence_parse_authreq(STREAM s, uint8 ** token, uint8 ** signature)
208  {  {
209          uint16 tokenlen;          uint16 tokenlen;
210    
# Line 142  licence_parse_authreq(STREAM s, uint8 ** Line 213  licence_parse_authreq(STREAM s, uint8 **
213          in_uint16_le(s, tokenlen);          in_uint16_le(s, tokenlen);
214          if (tokenlen != LICENCE_TOKEN_SIZE)          if (tokenlen != LICENCE_TOKEN_SIZE)
215          {          {
216                  ERROR("token len %d\n", tokenlen);                  error("token len %d\n", tokenlen);
217                  return False;                  return False;
218          }          }
219    
# Line 157  static void Line 228  static void
228  licence_process_authreq(STREAM s)  licence_process_authreq(STREAM s)
229  {  {
230          uint8 *in_token, *in_sig;          uint8 *in_token, *in_sig;
231          uint8 out_token[LICENCE_TOKEN_SIZE],          uint8 out_token[LICENCE_TOKEN_SIZE], decrypt_token[LICENCE_TOKEN_SIZE];
                 decrypt_token[LICENCE_TOKEN_SIZE];  
232          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];          uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];
233          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];          uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];
234          uint8 out_sig[LICENCE_SIGNATURE_SIZE];          uint8 out_sig[LICENCE_SIGNATURE_SIZE];
# Line 172  licence_process_authreq(STREAM s) Line 242  licence_process_authreq(STREAM s)
242          RC4_set_key(&crypt_key, 16, licence_key);          RC4_set_key(&crypt_key, 16, licence_key);
243          RC4(&crypt_key, LICENCE_TOKEN_SIZE, in_token, decrypt_token);          RC4(&crypt_key, LICENCE_TOKEN_SIZE, in_token, decrypt_token);
244    
         /* Construct HWID */  
         buf_out_uint32(hwid, 2);  
         strncpy(hwid + 4, hostname, LICENCE_HWID_SIZE - 4);  
   
245          /* Generate a signature for a buffer of token and HWID */          /* Generate a signature for a buffer of token and HWID */
246            licence_generate_hwid(hwid);
247          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);          memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);
248          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);          memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);
249          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));  
250    
251          /* Deliberately break signature if licencing disabled */          /* Deliberately break signature if licencing disabled */
252          if (!licence)          if (!licence)
# Line 215  licence_process_issue(STREAM s) Line 281  licence_process_issue(STREAM s)
281    
282          licence_issued = True;          licence_issued = True;
283    
284          /* We should save the licence here */  #ifdef SAVE_LICENCE
285          STATUS("Server issued licence.\n");          save_licence(s->p, length - 2);
286    #endif
287  }  }
288    
289  /* Process a licence packet */  /* Process a licence packet */
# Line 242  licence_process(STREAM s) Line 309  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.28  
changed lines
  Added in v.159
  ViewVC Help
Powered by ViewVC 1.1.26