56c8bef117fba0929c4d2c3e129adfaf8be2bc44
[rdpsrv] / secure.c
1 /* -*- c-basic-offset: 8 -*-
2    rdesktop: A Remote Desktop Protocol client.
3    Protocol services - RDP encryption and licensing
4    Copyright (C) Matthew Chapman 1999-2002
5
6    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
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "rdesktop.h"
22
23 #include <openssl/rc4.h>
24 #include <openssl/md5.h>
25 #include <openssl/sha.h>
26 #include <openssl/bn.h>
27 #include <openssl/x509v3.h>
28
29 extern char hostname[16];
30 extern int g_width;
31 extern int g_height;
32 extern int keylayout;
33 extern BOOL g_encryption;
34 extern BOOL g_licence_issued;
35 extern BOOL g_use_rdp5;
36 extern BOOL g_console_session;
37 extern int g_server_bpp;
38 extern uint16 mcs_userid;
39 extern VCHANNEL g_channels[];
40 extern unsigned int g_num_channels;
41
42 static int rc4_key_len;
43 static RC4_KEY rc4_decrypt_key;
44 static RC4_KEY rc4_encrypt_key;
45 static RSA *server_public_key;
46
47 static uint8 sec_sign_key[16];
48 static uint8 sec_decrypt_key[16];
49 static uint8 sec_encrypt_key[16];
50 static uint8 sec_decrypt_update_key[16];
51 static uint8 sec_encrypt_update_key[16];
52 static uint8 sec_crypted_random[SEC_MODULUS_SIZE];
53
54 RSA *privkey;
55
56 uint16 g_server_rdp_version = 0;
57
58 /*
59  * General purpose 48-byte transformation, using two 32-byte salts (generally,
60  * a client and server salt) and a global salt value used for padding.
61  * Both SHA1 and MD5 algorithms are used.
62  */
63 void
64 sec_hash_48(uint8 * out, uint8 * in, uint8 * salt1, uint8 * salt2, uint8 salt)
65 {
66         uint8 shasig[20];
67         uint8 pad[4];
68         SHA_CTX sha;
69         MD5_CTX md5;
70         int i;
71
72         for (i = 0; i < 3; i++)
73         {
74                 memset(pad, salt + i, i + 1);
75
76                 SHA1_Init(&sha);
77                 SHA1_Update(&sha, pad, i + 1);
78                 SHA1_Update(&sha, in, 48);
79                 SHA1_Update(&sha, salt1, 32);
80                 SHA1_Update(&sha, salt2, 32);
81                 SHA1_Final(shasig, &sha);
82
83                 MD5_Init(&md5);
84                 MD5_Update(&md5, in, 48);
85                 MD5_Update(&md5, shasig, 20);
86                 MD5_Final(&out[i * 16], &md5);
87         }
88 }
89
90 /*
91  * Weaker 16-byte transformation, also using two 32-byte salts, but
92  * only using a single round of MD5.
93  */
94 void
95 sec_hash_16(uint8 * out, uint8 * in, uint8 * salt1, uint8 * salt2)
96 {
97         MD5_CTX md5;
98
99         MD5_Init(&md5);
100         MD5_Update(&md5, in, 16);
101         MD5_Update(&md5, salt1, 32);
102         MD5_Update(&md5, salt2, 32);
103         MD5_Final(out, &md5);
104 }
105
106 /* Reduce key entropy from 64 to 40 bits */
107 static void
108 sec_make_40bit(uint8 * key)
109 {
110         key[0] = 0xd1;
111         key[1] = 0x26;
112         key[2] = 0x9e;
113 }
114
115 /* Generate a session key and RC4 keys, given client and server randoms */
116 static void
117 sec_generate_keys(uint8 * client_key, uint8 * server_key, int rc4_key_size)
118 {
119         uint8 session_key[48];
120         uint8 temp_hash[48];
121         uint8 input[48];
122
123         /* Construct input data to hash */
124         memcpy(input, client_key, 24);
125         memcpy(input + 24, server_key, 24);
126
127         /* Generate session key - two rounds of sec_hash_48 */
128         sec_hash_48(temp_hash, input, client_key, server_key, 65);
129         sec_hash_48(session_key, temp_hash, client_key, server_key, 88);
130
131         /* Store first 16 bytes of session key, for generating signatures */
132         memcpy(sec_sign_key, session_key, 16);
133
134         /* Generate RC4 keys */
135         sec_hash_16(sec_decrypt_key, &session_key[16], client_key, server_key);
136         sec_hash_16(sec_encrypt_key, &session_key[32], client_key, server_key);
137
138         if (rc4_key_size == 1)
139         {
140                 DEBUG(("40-bit encryption enabled\n"));
141                 sec_make_40bit(sec_sign_key);
142                 sec_make_40bit(sec_decrypt_key);
143                 sec_make_40bit(sec_encrypt_key);
144                 rc4_key_len = 8;
145         }
146         else
147         {
148                 DEBUG(("rc_4_key_size == %d, 128-bit encryption enabled\n", rc4_key_size));
149                 rc4_key_len = 16;
150         }
151
152         /* Save initial RC4 keys as update keys */
153         memcpy(sec_decrypt_update_key, sec_decrypt_key, 16);
154         memcpy(sec_encrypt_update_key, sec_encrypt_key, 16);
155
156         /* Initialise RC4 state arrays */
157         RC4_set_key(&rc4_decrypt_key, rc4_key_len, sec_decrypt_key);
158         RC4_set_key(&rc4_encrypt_key, rc4_key_len, sec_encrypt_key);
159
160         {
161                 int i;
162                 printf("sec_decrypt_key: ");
163                 for (i = 0; i < 16; ++i)
164                         printf("0x%02x ", sec_decrypt_key[i]);
165                 printf("\n");
166                 
167                 printf("sec_encrypt_key: ");
168                 for (i = 0; i < 16; ++i)
169                         printf("0x%02x ", sec_encrypt_key[i]);
170                 printf("\n");
171         }
172
173         g_encryption = 1;
174 }
175
176 static uint8 pad_54[40] = {
177         54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
178         54, 54, 54,
179         54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
180         54, 54, 54
181 };
182
183 static uint8 pad_92[48] = {
184         92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
185         92, 92, 92, 92, 92, 92, 92,
186         92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
187         92, 92, 92, 92, 92, 92, 92
188 };
189
190 /* Output a uint32 into a buffer (little-endian) */
191 void
192 buf_out_uint32(uint8 * buffer, uint32 value)
193 {
194         buffer[0] = (value) & 0xff;
195         buffer[1] = (value >> 8) & 0xff;
196         buffer[2] = (value >> 16) & 0xff;
197         buffer[3] = (value >> 24) & 0xff;
198 }
199
200 /* Generate a signature hash, using a combination of SHA1 and MD5 */
201 void
202 sec_sign(uint8 * signature, int siglen, uint8 * session_key, int keylen, uint8 * data, int datalen)
203 {
204         uint8 shasig[20];
205         uint8 md5sig[16];
206         uint8 lenhdr[4];
207         SHA_CTX sha;
208         MD5_CTX md5;
209
210         buf_out_uint32(lenhdr, datalen);
211
212         SHA1_Init(&sha);
213         SHA1_Update(&sha, session_key, keylen);
214         SHA1_Update(&sha, pad_54, 40);
215         SHA1_Update(&sha, lenhdr, 4);
216         SHA1_Update(&sha, data, datalen);
217         SHA1_Final(shasig, &sha);
218
219         MD5_Init(&md5);
220         MD5_Update(&md5, session_key, keylen);
221         MD5_Update(&md5, pad_92, 48);
222         MD5_Update(&md5, shasig, 20);
223         MD5_Final(md5sig, &md5);
224
225         memcpy(signature, md5sig, siglen);
226 }
227
228 /* Update an encryption key - similar to the signing process */
229 static void
230 sec_update(uint8 * key, uint8 * update_key)
231 {
232         uint8 shasig[20];
233         SHA_CTX sha;
234         MD5_CTX md5;
235         RC4_KEY update;
236
237         SHA1_Init(&sha);
238         SHA1_Update(&sha, update_key, rc4_key_len);
239         SHA1_Update(&sha, pad_54, 40);
240         SHA1_Update(&sha, key, rc4_key_len);
241         SHA1_Final(shasig, &sha);
242
243         MD5_Init(&md5);
244         MD5_Update(&md5, update_key, rc4_key_len);
245         MD5_Update(&md5, pad_92, 48);
246         MD5_Update(&md5, shasig, 20);
247         MD5_Final(key, &md5);
248
249         RC4_set_key(&update, rc4_key_len, key);
250         RC4(&update, rc4_key_len, key, key);
251
252         if (rc4_key_len == 8)
253                 sec_make_40bit(key);
254 }
255
256 /* Encrypt data using RC4 */
257 static void
258 sec_encrypt(uint8 * data, int length)
259 {
260         static int use_count;
261
262         if (use_count == 4096)
263         {
264                 sec_update(sec_decrypt_key, sec_decrypt_update_key);
265                 RC4_set_key(&rc4_decrypt_key, rc4_key_len, sec_decrypt_key);
266                 use_count = 0;
267         }
268
269         printf("RC4-ing %u bytes with DECRYPT, uc=%u\n", length, use_count);
270
271         RC4(&rc4_decrypt_key, length, data, data);
272         use_count++;
273 }
274
275 /* Decrypt data using RC4 */
276 void
277 sec_decrypt(uint8 * data, int length)
278 {
279         static int use_count;
280
281         if (use_count == 4096)
282         {
283                 sec_update(sec_encrypt_key, sec_encrypt_update_key);
284                 RC4_set_key(&rc4_encrypt_key, rc4_key_len, sec_encrypt_key);
285                 use_count = 0;
286         }
287
288         RC4(&rc4_encrypt_key, length, data, data);
289         use_count++;
290 }
291
292 static void
293 reverse(uint8 * p, int len)
294 {
295         int i, j;
296         uint8 temp;
297
298         for (i = 0, j = len - 1; i < j; i++, j--)
299         {
300                 temp = p[i];
301                 p[i] = p[j];
302                 p[j] = temp;
303         }
304 }
305
306 /* Perform an RSA public key encryption operation */
307 static void
308 sec_rsa_encrypt(uint8 * out, uint8 * in, int len, uint8 * modulus, uint8 * exponent)
309 {
310         BN_CTX *ctx;
311         BIGNUM mod, exp, x, y;
312         uint8 inr[SEC_MODULUS_SIZE];
313         int outlen;
314
315         reverse(modulus, SEC_MODULUS_SIZE);
316         reverse(exponent, SEC_EXPONENT_SIZE);
317         memcpy(inr, in, len);
318         reverse(inr, len);
319
320         ctx = BN_CTX_new();
321         BN_init(&mod);
322         BN_init(&exp);
323         BN_init(&x);
324         BN_init(&y);
325
326         BN_bin2bn(modulus, SEC_MODULUS_SIZE, &mod);
327         BN_bin2bn(exponent, SEC_EXPONENT_SIZE, &exp);
328         BN_bin2bn(inr, len, &x);
329         BN_mod_exp(&y, &x, &exp, &mod, ctx);
330         outlen = BN_bn2bin(&y, out);
331         reverse(out, outlen);
332         if (outlen < SEC_MODULUS_SIZE)
333                 memset(out + outlen, 0, SEC_MODULUS_SIZE - outlen);
334
335         BN_free(&y);
336         BN_clear_free(&x);
337         BN_free(&exp);
338         BN_free(&mod);
339         BN_CTX_free(ctx);
340 }
341
342 /* Initialise secure transport packet */
343 STREAM
344 sec_init(uint32 flags, int maxlen)
345 {
346         int hdrlen;
347         STREAM s;
348
349         if (!g_licence_issued) 
350                 hdrlen = (flags & SEC_ENCRYPT) ? 12 : 4;
351         else
352                 hdrlen = (flags & SEC_ENCRYPT) ? 12 : 0; 
353         printf("HDRLEN is %u\n", hdrlen);
354         s = mcs_init(maxlen + hdrlen);
355         s_push_layer(s, sec_hdr, hdrlen);
356
357         return s;
358 }
359
360 /* Transmit secure transport packet over specified channel */
361 void
362 sec_send_to_channel(STREAM s, uint32 flags, uint16 channel)
363 {
364         int datalen;
365
366 //      DEBUG(("sending packet to channel %u\n", channel));
367         
368         s_pop_layer(s, sec_hdr);
369         if (!g_licence_issued || (flags & SEC_ENCRYPT)) {
370                 out_uint32_le(s, flags);
371         }
372
373         if (flags & SEC_ENCRYPT)
374         {
375                 flags &= ~SEC_ENCRYPT;
376                 datalen = s->end - s->p - 8;
377
378 #if WITH_DEBUG
379                 DEBUG(("Sending encrypted packet:\n"));
380                 hexdump(s->p + 8, datalen);
381 #endif
382
383                 sec_sign(s->p, 8, sec_sign_key, rc4_key_len, s->p + 8, datalen);
384                 printf("First byte of signature is 0x%x, at %p\n", (s->p)[0], s->p);
385                 sec_encrypt(s->p + 8, datalen);
386         }
387
388         mcs_send_to_channel(s, channel);
389 }
390
391 /* Transmit secure transport packet */
392
393 void
394 sec_send(STREAM s, uint32 flags)
395 {
396         sec_send_to_channel(s, flags, MCS_GLOBAL_CHANNEL);
397 }
398
399
400 /* Transfer the client random to the server */
401 static void
402 sec_establish_key(void)
403 {
404         uint32 length = SEC_MODULUS_SIZE + SEC_PADDING_SIZE;
405         uint32 flags = SEC_CLIENT_RANDOM;
406         STREAM s;
407
408         s = sec_init(flags, 76);
409
410         out_uint32_le(s, length);
411         out_uint8p(s, sec_crypted_random, SEC_MODULUS_SIZE);
412         out_uint8s(s, SEC_PADDING_SIZE);
413
414         s_mark_end(s);
415         sec_send(s, flags);
416 }
417
418 /* Parse a public key structure */
419 static BOOL
420 sec_parse_public_key(STREAM s, uint8 ** modulus, uint8 ** exponent)
421 {
422         uint32 magic, modulus_len;
423
424         in_uint32_le(s, magic);
425         if (magic != SEC_RSA_MAGIC)
426         {
427                 error("RSA magic 0x%x\n", magic);
428                 return False;
429         }
430
431         in_uint32_le(s, modulus_len);
432         if (modulus_len != SEC_MODULUS_SIZE + SEC_PADDING_SIZE)
433         {
434                 error("modulus len 0x%x\n", modulus_len);
435                 return False;
436         }
437
438         in_uint8s(s, 8);        /* modulus_bits, unknown */
439         in_uint8p(s, *exponent, SEC_EXPONENT_SIZE);
440         in_uint8p(s, *modulus, SEC_MODULUS_SIZE);
441         in_uint8s(s, SEC_PADDING_SIZE);
442
443         return s_check(s);
444 }
445
446 static BOOL
447 sec_parse_x509_key(X509 * cert)
448 {
449         EVP_PKEY *epk = NULL;
450         /* By some reason, Microsoft sets the OID of the Public RSA key to
451            the oid for "MD5 with RSA Encryption" instead of "RSA Encryption"
452
453            Kudos to Richard Levitte for the following (. intiutive .) 
454            lines of code that resets the OID and let's us extract the key. */
455         if (OBJ_obj2nid(cert->cert_info->key->algor->algorithm) == NID_md5WithRSAEncryption)
456         {
457                 DEBUG_RDP5(("Re-setting algorithm type to RSA in server certificate\n"));
458                 cert->cert_info->key->algor->algorithm = OBJ_nid2obj(NID_rsaEncryption);
459         }
460         epk = X509_get_pubkey(cert);
461         if (NULL == epk)
462         {
463                 error("Failed to extract public key from certificate\n");
464                 return False;
465         }
466
467         server_public_key = (RSA *) epk->pkey.ptr;
468
469         return True;
470 }
471
472
473 /* Parse a crypto information structure */
474 static BOOL
475 sec_parse_crypt_info(STREAM s, uint32 * rc4_key_size,
476                      uint8 ** server_random, uint8 ** modulus, uint8 ** exponent)
477 {
478         uint32 crypt_level, random_len, rsa_info_len;
479         uint32 cacert_len, cert_len, flags;
480         X509 *cacert, *server_cert;
481         uint16 tag, length;
482         uint8 *next_tag, *end;
483
484         in_uint32_le(s, *rc4_key_size); /* 1 = 40-bit, 2 = 128-bit */
485         in_uint32_le(s, crypt_level);   /* 1 = low, 2 = medium, 3 = high */
486         if (crypt_level == 0)   /* no encryption */
487                 return False;
488         in_uint32_le(s, random_len);
489         in_uint32_le(s, rsa_info_len);
490
491         if (random_len != SEC_RANDOM_SIZE)
492         {
493                 error("random len %d, expected %d\n", random_len, SEC_RANDOM_SIZE);
494                 return False;
495         }
496
497         in_uint8p(s, *server_random, random_len);
498
499         /* RSA info */
500         end = s->p + rsa_info_len;
501         if (end > s->end)
502                 return False;
503
504         in_uint32_le(s, flags); /* 1 = RDP4-style, 0x80000002 = X.509 */
505         if (flags & 1)
506         {
507                 DEBUG_RDP5(("We're going for the RDP4-style encryption\n"));
508                 in_uint8s(s, 8);        /* unknown */
509
510                 while (s->p < end)
511                 {
512                         in_uint16_le(s, tag);
513                         in_uint16_le(s, length);
514
515                         next_tag = s->p + length;
516
517                         switch (tag)
518                         {
519                                 case SEC_TAG_PUBKEY:
520                                         if (!sec_parse_public_key(s, modulus, exponent))
521                                                 return False;
522                                         DEBUG_RDP5(("Got Public key, RDP4-style\n"));
523
524                                         break;
525
526                                 case SEC_TAG_KEYSIG:
527                                         /* Is this a Microsoft key that we just got? */
528                                         /* Care factor: zero! */
529                                         /* Actually, it would probably be a good idea to check if the public key is signed with this key, and then store this 
530                                            key as a known key of the hostname. This would prevent some MITM-attacks. */
531                                         break;
532
533                                 default:
534                                         unimpl("crypt tag 0x%x\n", tag);
535                         }
536
537                         s->p = next_tag;
538                 }
539         }
540         else
541         {
542                 uint32 certcount;
543
544                 DEBUG_RDP5(("We're going for the RDP5-style encryption\n"));
545                 in_uint32_le(s, certcount); /* Number of certificates */
546
547                 if(certcount < 2) 
548                 {
549                         error("Server didn't send enough X509 certificates\n");
550                         return False;
551                 }
552
553                 for(; certcount > 2; certcount--)
554                 { /* ignore all the certificates between the root and the signing CA */
555                         uint32 ignorelen;
556                         X509 *ignorecert;
557
558                         DEBUG_RDP5(("Ignored certs left: %d\n", certcount));
559
560                         in_uint32_le(s, ignorelen);
561                         DEBUG_RDP5(("Ignored Certificate length is %d\n", ignorelen));
562                         ignorecert = d2i_X509(NULL, &(s->p), ignorelen);
563
564                         if(ignorecert == NULL)
565                         { /* XXX: error out? */
566                                 DEBUG_RDP5(("got a bad cert: this will probably screw up the rest of the communication\n"));
567                         }
568
569 #ifdef WITH_DEBUG_RDP5
570                         DEBUG_RDP5(("cert #%d (ignored):\n",certcount));
571                         X509_print_fp(stdout, ignorecert);
572 #endif
573                 }
574
575                 /* Do da funky X.509 stuffy 
576
577                    "How did I find out about this?  I looked up and saw a
578                    bright light and when I came to I had a scar on my forehead
579                    and knew about X.500"
580                    - Peter Gutman in a early version of 
581                    http://www.cs.auckland.ac.nz/~pgut001/pubs/x509guide.txt
582                  */
583
584                 in_uint32_le(s, cacert_len);
585                 DEBUG_RDP5(("CA Certificate length is %d\n", cacert_len));
586                 cacert = d2i_X509(NULL, &(s->p), cacert_len);
587                 /* Note: We don't need to move s->p here - d2i_X509 is
588                    "kind" enough to do it for us */
589                 if (NULL == cacert)
590                 {
591                         error("Couldn't load CA Certificate from server\n");
592                         return False;
593                 }
594
595                 /* Currently, we don't use the CA Certificate. 
596                    FIXME: 
597                    *) Verify the server certificate (server_cert) with the 
598                    CA certificate.
599                    *) Store the CA Certificate with the hostname of the 
600                    server we are connecting to as key, and compare it
601                    when we connect the next time, in order to prevent
602                    MITM-attacks.
603                  */
604
605                 in_uint32_le(s, cert_len);
606                 DEBUG_RDP5(("Certificate length is %d\n", cert_len));
607                 server_cert = d2i_X509(NULL, &(s->p), cert_len);
608                 if (NULL == server_cert)
609                 {
610                         error("Couldn't load Certificate from server\n");
611                         return False;
612                 }
613
614                 in_uint8s(s, 16);       /* Padding */
615
616                 /* Note: Verifying the server certificate must be done here, 
617                    before sec_parse_public_key since we'll have to apply
618                    serious violence to the key after this */
619
620                 if (!sec_parse_x509_key(server_cert))
621                 {
622                         DEBUG_RDP5(("Didn't parse X509 correctly\n"));
623                         return False;
624                 }
625                 return True;    /* There's some garbage here we don't care about */
626         }
627         return s_check_end(s);
628 }
629
630 /* Process crypto information blob */
631 static void
632 sec_process_crypt_info(STREAM s)
633 {
634         uint8 *server_random, *modulus, *exponent;
635         uint8 client_random[SEC_RANDOM_SIZE];
636         uint32 rc4_key_size;
637         uint8 inr[SEC_MODULUS_SIZE];
638
639         if (!sec_parse_crypt_info(s, &rc4_key_size, &server_random, &modulus, &exponent))
640         {
641                 DEBUG(("Failed to parse crypt info\n"));
642                 return;
643         }
644
645         DEBUG(("Generating client random\n"));
646         /* Generate a client random, and hence determine encryption keys */
647         /* This is what the MS client do: */
648         memset(inr, 0, SEC_RANDOM_SIZE);
649         /*  *ARIGL!* Plaintext attack, anyone?
650            I tried doing:
651            generate_random(inr);
652            ..but that generates connection errors now and then (yes, 
653            "now and then". Something like 0 to 3 attempts needed before a 
654            successful connection. Nice. Not! 
655          */
656
657         generate_random(client_random);
658         if (NULL != server_public_key)
659         {                       /* Which means we should use 
660                                    RDP5-style encryption */
661
662                 memcpy(inr + SEC_RANDOM_SIZE, client_random, SEC_RANDOM_SIZE);
663                 reverse(inr + SEC_RANDOM_SIZE, SEC_RANDOM_SIZE);
664
665                 RSA_public_encrypt(SEC_MODULUS_SIZE,
666                                    inr, sec_crypted_random, server_public_key, RSA_NO_PADDING);
667
668                 reverse(sec_crypted_random, SEC_MODULUS_SIZE);
669
670         }
671         else
672         {                       /* RDP4-style encryption */
673                 sec_rsa_encrypt(sec_crypted_random,
674                                 client_random, SEC_RANDOM_SIZE, modulus, exponent);
675         }
676         sec_generate_keys(client_random, server_random, rc4_key_size);
677 }
678
679
680 /* Process SRV_INFO, find RDP version supported by server */
681 static void
682 sec_process_srv_info(STREAM s)
683 {
684         in_uint16_le(s, g_server_rdp_version);
685         DEBUG_RDP5(("Server RDP version is %d\n", g_server_rdp_version));
686 /*      if (1 == g_server_rdp_version)
687                 g_use_rdp5 = 0; */
688 }
689
690
691 /* Process connect response data blob */
692 void
693 sec_process_mcs_data(STREAM s)
694 {
695         uint16 tag, length;
696         uint8 *next_tag;
697         uint8 len;
698
699         in_uint8s(s, 21);       /* header (T.124 stuff, probably) */
700         in_uint8(s, len);
701         if (len & 0x80)
702                 in_uint8(s, len);
703
704         while (s->p < s->end)
705         {
706                 in_uint16_le(s, tag);
707                 in_uint16_le(s, length);
708
709                 if (length <= 4)
710                         return;
711
712                 next_tag = s->p + length - 4;
713
714                 switch (tag)
715                 {
716                         case SEC_TAG_SRV_INFO:
717                                 sec_process_srv_info(s);
718                                 break;
719
720                         case SEC_TAG_SRV_CRYPT:
721                                 sec_process_crypt_info(s);
722                                 break;
723
724                         case SEC_TAG_SRV_CHANNELS:
725                                 /* FIXME: We should parse this information and
726                                    use it to map RDP5 channels to MCS 
727                                    channels */
728                                 break;
729
730                         default:
731                                 unimpl("response tag 0x%x\n", tag);
732                 }
733
734                 s->p = next_tag;
735         }
736 }
737
738 extern unsigned char cacert[];
739 extern BOOL g_licence_issued;
740
741 unsigned char demand_license[] = {
742         0x01, 0x03, 0x86, 0x00, 0x9c, 0x6e, 0xef, 0x5a, 0x26, 0x45, 0x88, 0x86, 0x0e, 0xdf, 0xa4, 0x4a,
743         0x45, 0xc7, 0x5a, 0x4c, 0xec, 0x33, 0xff, 0x4c, 0xd8, 0x4b, 0xd2, 0x4e, 0xd2, 0x22, 0x16, 0xde,
744         0x1e, 0x5b, 0x06, 0x6e, 0x00, 0x00, 0x05, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x69, 0x00,
745         0x63, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x74, 0x00, 0x20, 0x00,
746         0x43, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x70, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00,
747         0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x41, 0x00, 0x30, 0x00,
748         0x32, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0xf6, 0x00, 0x00,
749         0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66,
750         0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x00 
751 };
752 unsigned char result_license[] = {
753         0xff, 0x03, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xa0, 0x5f, 0x00, 0x00
754 };
755
756 unsigned char demand_active[] = {
757         0x24, 0x01, 0x11, 0x00, 0xea, 0x03, 0xea, 0x03, 0x01, 0x00, 0x04, 0x00, 0x0e, 0x01, 0x52, 0x44,
758         0x50, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x08, 0x00, 0xea, 0x03, 0x40, 0xe4, 0x01, 0x00,
759         0x18, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x11, 0x04, 0x00, 0x00,
760         0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x0e, 0x00, 0x04, 0x00, 0x02, 0x00, 0x1c, 0x00, 0x08, 0x00,
761         0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x20, 0x03, 0x58, 0x02, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
762         0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
763         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x42, 0x0f, 0x00, 0x01, 0x00,
764         0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,
765         0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
766         0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xa1, 0x06, 0x00, 0x00, 0x40, 0x42,
767         0x0f, 0x00, 0x40, 0x42, 0x0f, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00,
768         0x08, 0x00, 0x06, 0x00, 0x00, 0x00, 0x12, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00,
769         0x0a, 0x00, 0x01, 0x00, 0x19, 0x00, 0x19, 0x00, 0x0d, 0x00, 0x58, 0x00, 0x35, 0x00, 0x00, 0x00,
770         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xed, 0xbf, 0xa5, 0xcd, 0xb1, 0xae, 0xbe,
771         0x88, 0x35, 0x56, 0xe5, 0xc2, 0x01, 0xaf, 0xbe, 0xc8, 0xed, 0xbf, 0xa5, 0x8c, 0x33, 0x40, 0xe4,
772         0x08, 0x30, 0x40, 0xe4, 0x01, 0x00, 0x00, 0x00, 0x08, 0x30, 0x40, 0xe4, 0x00, 0x00, 0x00, 0x00,
773         0xc0, 0xed, 0xbf, 0xa5, 0x34, 0xf5, 0xae, 0xbe, 0x08, 0x30, 0x40, 0xe4, 0xb4, 0xed, 0xbf, 0xa5,
774         0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x19, 0x00, 0x19, 0x00, 0x00, 0x00,
775         0x00, 0x00, 0x00, 0x00
776 };
777
778 #define EXPECT8(value) { in_uint8(s, unknown); if (unknown != (value)) printf("Unknown value on code line %u; expected 0x%x, got 0x%x\n", __LINE__, (value), unknown); }
779 #define EXPECT16(value) { in_uint16_le(s, unknown); if (unknown != (value)) printf("Unknown value on code line %u; expected 0x%x, got 0x%x\n", __LINE__, (value), unknown); }
780 #define EXPECT32(value) { in_uint32_le(s, unknown); if (unknown != (value)) printf("Unknown value on code line %u; expected 0x%x, got 0x%x\n", __LINE__, (value), unknown); }
781
782 void
783 process_presented_license(STREAM s)
784 {
785         unsigned char client_license_random[SEC_RANDOM_SIZE];
786         unsigned char client_license_rsa_data[SEC_MODULUS_SIZE];
787
788         uint16 length, license_size;
789         uint32 unknown;
790         uint8 *license, hwid[LICENCE_HWID_SIZE], signature[LICENCE_SIGNATURE_SIZE];
791         int i;
792         
793         EXPECT8(2);                   // version
794         in_uint16_le(s, length);
795
796         EXPECT32(1);                  // unknown
797         EXPECT16(0);
798         EXPECT16(0x0201);
799
800         in_uint8a(s, client_license_random, SEC_RANDOM_SIZE);
801         EXPECT16(0);
802         EXPECT16(SEC_MODULUS_SIZE + SEC_PADDING_SIZE);
803         in_uint8a(s, client_license_rsa_data, SEC_MODULUS_SIZE);
804         in_uint8s(s, SEC_PADDING_SIZE);
805
806         EXPECT16(1);
807         in_uint16_le(s, license_size);
808
809         license = (uint8 *)xmalloc(license_size);
810         in_uint8a(s, license, license_size);
811
812         printf("Received license:\n");
813         for (i = 0; i < license_size; ++i)
814                 printf(" 0x%02x", license[i]);
815         printf("\n");
816
817         EXPECT16(1);
818         EXPECT16(LICENCE_HWID_SIZE);
819         in_uint8a(s, hwid, LICENCE_HWID_SIZE);
820
821         printf("License hardware ID:\n");
822         for (i = 0; i < LICENCE_HWID_SIZE; ++i)
823                 printf(" 0x%02x", hwid[i]);
824         printf("\n");
825
826         in_uint8a(s, signature, LICENCE_SIGNATURE_SIZE);
827
828         if (!s_check_end(s)) {
829                 printf("Unknown data at the end of presented license!");
830         }
831
832         // now we can generate the keys we need
833         licence_generate_keys(client_license_random, demand_license + 4, client_license_rsa_data);
834 //      send_authreq();
835 }
836
837 /* Receive secure transport packet */
838 STREAM
839 sec_recv(void)
840 {
841         uint32 sec_flags;
842         uint16 channel;
843         STREAM s;
844
845         if ((s = mcs_recv(&channel)) != NULL)
846         {
847                 if (/*g_encryption || !g_licence_issued*/ 1)
848                 {
849                         in_uint32_le(s, sec_flags);
850                         printf("sec_flags=%x\n", sec_flags);
851                         
852                         if (sec_flags & SEC_ENCRYPT)
853                         {
854                                 printf("encrypt\n");
855                                 in_uint8s(s, 8);        /* signature */
856                                 sec_decrypt(s->p, s->end - s->p);
857                         }
858
859                         if (sec_flags & SEC_LICENCE_NEG)
860                         {
861                                 uint8 tag;
862                                 in_uint8(s, tag);
863                                 printf("SEC_LICENSE_NEG tag %x\n", tag);
864                                 
865                                 if (tag == LICENCE_TAG_PRESENT) {
866                                         process_presented_license(s);
867
868                                         {
869                                                 STREAM s;
870                                                 s = sec_init(SEC_LICENCE_NEG, sizeof(result_license));
871                                                 out_uint8p(s, result_license, sizeof(result_license));
872                                                 s_mark_end(s);
873                                                 sec_send(s, SEC_LICENCE_NEG);
874                                         }
875                                         
876                                         {
877                                                 STREAM s;
878                                                 printf("Sending DEMAND_ACTIVE (0x%x bytes)\n", sizeof(demand_active));
879                                                 s = sec_init(SEC_ENCRYPT, sizeof(demand_active));
880                                                 out_uint8p(s, demand_active, sizeof(demand_active));
881                                                 s_mark_end(s);
882                                                 sec_send(s, SEC_ENCRYPT);
883                                         }
884                                 }
885                                 
886                                 return NULL;
887                         }
888
889                         if (sec_flags & SEC_LOGON_INFO) 
890                         {
891                                 printf("Received logon packet!\n");
892                                 rdp_get_logon_info(s);
893                         
894                                 // demand a license
895                                 {
896                                         STREAM s;
897
898                                         s = sec_init(SEC_LICENCE_NEG, sizeof(demand_license));
899                                         out_uint8p(s, demand_license, sizeof(demand_license));
900                                         s_mark_end(s);
901                                         sec_send(s, SEC_LICENCE_NEG);
902                                 }
903                                 
904                                 return NULL;
905                         }
906
907                         if (sec_flags & SEC_CLIENT_RANDOM) {
908                                 uint32 length;
909                                 uint8 inr[SEC_MODULUS_SIZE];
910                                 int i;
911                                 
912                                 printf("Receiving the client random!\n");
913                                 in_uint32_le(s, length);
914                                 if (length != SEC_MODULUS_SIZE + SEC_PADDING_SIZE) {
915                                         error("Client random was wrong size, %u bytes\n", length);
916                                 }
917                                 in_uint8a(s, sec_crypted_random, SEC_MODULUS_SIZE);
918                                 in_uint8s(s, SEC_PADDING_SIZE);
919                                 if (!s_check_end(s)) {
920                                         error("Junk after client random\n");
921                                 }
922                                 
923                                 reverse(sec_crypted_random, SEC_MODULUS_SIZE);
924
925                                 RSA_private_decrypt(SEC_MODULUS_SIZE, sec_crypted_random, inr, privkey, RSA_NO_PADDING);
926                         
927                                 reverse(inr + SEC_RANDOM_SIZE, SEC_RANDOM_SIZE);
928                                 
929                                 printf("Unencrypted client random: ");
930                                 for (i = 0; i < SEC_RANDOM_SIZE; ++i) {
931                                         printf("0x%x ", inr[i + SEC_RANDOM_SIZE]);
932                                 }
933                                 printf("\n");
934
935                                 // now we can generate the keys
936                                 sec_generate_keys(inr + SEC_RANDOM_SIZE, cacert, 1);
937                                 return NULL;
938                         }
939                 }
940
941                 printf("Received MCS data on ch %u\n", channel);
942                 if (channel != MCS_GLOBAL_CHANNEL)
943                 {
944                         channel_process(s, channel);
945                         return NULL;
946                 }
947
948                 return s;
949         }
950
951         return NULL;
952 }
953
954 /* Disconnect a connection */
955 void
956 sec_disconnect(void)
957 {
958         mcs_disconnect();
959 }