/[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 30 by matty, Fri Sep 14 13:51:38 2001 UTC revision 73 by astrand, Mon Jul 29 19:21:51 2002 UTC
# Line 7  Line 7 
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,
36                          uint8 * client_rsa)
37  {  {
38          uint8 session_key[48];          uint8 session_key[48];
39          uint8 temp_hash[48];          uint8 temp_hash[48];
# Line 48  licence_generate_keys(uint8 *client_key, Line 49  licence_generate_keys(uint8 *client_key,
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((char *)(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  static void
102  licence_send_request(uint8 *client_random, uint8 *rsa_data,  licence_send_request(uint8 * client_random, uint8 * rsa_data,
103                       char *user, char *host)                       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 65  licence_send_request(uint8 *client_rando Line 114  licence_send_request(uint8 *client_rando
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 90  static void Line 140  static void
140  licence_process_demand(STREAM s)  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 100  licence_process_demand(STREAM s) Line 155  licence_process_demand(STREAM s)
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  static void
181  licence_send_authresp(uint8 *token, uint8 *crypt_hwid, 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 133  licence_send_authresp(uint8 *token, uint Line 205  licence_send_authresp(uint8 *token, uint
205    
206  /* Parse an authentication request packet */  /* Parse an authentication request packet */
207  static BOOL  static BOOL
208  licence_parse_authreq(STREAM s, uint8 **token, uint8 **signature)  licence_parse_authreq(STREAM s, uint8 ** token, uint8 ** signature)
209  {  {
210          uint16 tokenlen;          uint16 tokenlen;
211    
# Line 172  licence_process_authreq(STREAM s) Line 244  licence_process_authreq(STREAM s)
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 214  licence_process_issue(STREAM s) Line 283  licence_process_issue(STREAM s)
283                  return;                  return;
284    
285          licence_issued = True;          licence_issued = True;
286            save_licence(s->p, length - 2);
         /* We should save the licence here */  
287  }  }
288    
289  /* Process a licence packet */  /* Process a licence packet */
# Line 241  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    
Legend:
Removed from v.30  
changed lines
  Added in v.73
  ViewVC Help
Powered by ViewVC 1.1.26