Even more imports. Link to OpenSSL.
[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 uint16 g_server_rdp_version = 0;
55
56 /*
57  * General purpose 48-byte transformation, using two 32-byte salts (generally,
58  * a client and server salt) and a global salt value used for padding.
59  * Both SHA1 and MD5 algorithms are used.
60  */
61 void
62 sec_hash_48(uint8 * out, uint8 * in, uint8 * salt1, uint8 * salt2, uint8 salt)
63 {
64         uint8 shasig[20];
65         uint8 pad[4];
66         SHA_CTX sha;
67         MD5_CTX md5;
68         int i;
69
70         for (i = 0; i < 3; i++)
71         {
72                 memset(pad, salt + i, i + 1);
73
74                 SHA1_Init(&sha);
75                 SHA1_Update(&sha, pad, i + 1);
76                 SHA1_Update(&sha, in, 48);
77                 SHA1_Update(&sha, salt1, 32);
78                 SHA1_Update(&sha, salt2, 32);
79                 SHA1_Final(shasig, &sha);
80
81                 MD5_Init(&md5);
82                 MD5_Update(&md5, in, 48);
83                 MD5_Update(&md5, shasig, 20);
84                 MD5_Final(&out[i * 16], &md5);
85         }
86 }
87
88 /*
89  * Weaker 16-byte transformation, also using two 32-byte salts, but
90  * only using a single round of MD5.
91  */
92 void
93 sec_hash_16(uint8 * out, uint8 * in, uint8 * salt1, uint8 * salt2)
94 {
95         MD5_CTX md5;
96
97         MD5_Init(&md5);
98         MD5_Update(&md5, in, 16);
99         MD5_Update(&md5, salt1, 32);
100         MD5_Update(&md5, salt2, 32);
101         MD5_Final(out, &md5);
102 }
103
104 /* Reduce key entropy from 64 to 40 bits */
105 static void
106 sec_make_40bit(uint8 * key)
107 {
108         key[0] = 0xd1;
109         key[1] = 0x26;
110         key[2] = 0x9e;
111 }
112
113 /* Generate a session key and RC4 keys, given client and server randoms */
114 static void
115 sec_generate_keys(uint8 * client_key, uint8 * server_key, int rc4_key_size)
116 {
117         uint8 session_key[48];
118         uint8 temp_hash[48];
119         uint8 input[48];
120
121         /* Construct input data to hash */
122         memcpy(input, client_key, 24);
123         memcpy(input + 24, server_key, 24);
124
125         /* Generate session key - two rounds of sec_hash_48 */
126         sec_hash_48(temp_hash, input, client_key, server_key, 65);
127         sec_hash_48(session_key, temp_hash, client_key, server_key, 88);
128
129         /* Store first 16 bytes of session key, for generating signatures */
130         memcpy(sec_sign_key, session_key, 16);
131
132         /* Generate RC4 keys */
133         sec_hash_16(sec_decrypt_key, &session_key[16], client_key, server_key);
134         sec_hash_16(sec_encrypt_key, &session_key[32], client_key, server_key);
135
136         if (rc4_key_size == 1)
137         {
138                 DEBUG(("40-bit encryption enabled\n"));
139                 sec_make_40bit(sec_sign_key);
140                 sec_make_40bit(sec_decrypt_key);
141                 sec_make_40bit(sec_encrypt_key);
142                 rc4_key_len = 8;
143         }
144         else
145         {
146                 DEBUG(("rc_4_key_size == %d, 128-bit encryption enabled\n", rc4_key_size));
147                 rc4_key_len = 16;
148         }
149
150         /* Save initial RC4 keys as update keys */
151         memcpy(sec_decrypt_update_key, sec_decrypt_key, 16);
152         memcpy(sec_encrypt_update_key, sec_encrypt_key, 16);
153
154         /* Initialise RC4 state arrays */
155         RC4_set_key(&rc4_decrypt_key, rc4_key_len, sec_decrypt_key);
156         RC4_set_key(&rc4_encrypt_key, rc4_key_len, sec_encrypt_key);
157 }
158
159 static uint8 pad_54[40] = {
160         54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
161         54, 54, 54,
162         54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
163         54, 54, 54
164 };
165
166 static uint8 pad_92[48] = {
167         92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
168         92, 92, 92, 92, 92, 92, 92,
169         92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
170         92, 92, 92, 92, 92, 92, 92
171 };
172
173 /* Output a uint32 into a buffer (little-endian) */
174 void
175 buf_out_uint32(uint8 * buffer, uint32 value)
176 {
177         buffer[0] = (value) & 0xff;
178         buffer[1] = (value >> 8) & 0xff;
179         buffer[2] = (value >> 16) & 0xff;
180         buffer[3] = (value >> 24) & 0xff;
181 }
182
183 /* Generate a signature hash, using a combination of SHA1 and MD5 */
184 void
185 sec_sign(uint8 * signature, int siglen, uint8 * session_key, int keylen, uint8 * data, int datalen)
186 {
187         uint8 shasig[20];
188         uint8 md5sig[16];
189         uint8 lenhdr[4];
190         SHA_CTX sha;
191         MD5_CTX md5;
192
193         buf_out_uint32(lenhdr, datalen);
194
195         SHA1_Init(&sha);
196         SHA1_Update(&sha, session_key, keylen);
197         SHA1_Update(&sha, pad_54, 40);
198         SHA1_Update(&sha, lenhdr, 4);
199         SHA1_Update(&sha, data, datalen);
200         SHA1_Final(shasig, &sha);
201
202         MD5_Init(&md5);
203         MD5_Update(&md5, session_key, keylen);
204         MD5_Update(&md5, pad_92, 48);
205         MD5_Update(&md5, shasig, 20);
206         MD5_Final(md5sig, &md5);
207
208         memcpy(signature, md5sig, siglen);
209 }
210
211 /* Update an encryption key - similar to the signing process */
212 static void
213 sec_update(uint8 * key, uint8 * update_key)
214 {
215         uint8 shasig[20];
216         SHA_CTX sha;
217         MD5_CTX md5;
218         RC4_KEY update;
219
220         SHA1_Init(&sha);
221         SHA1_Update(&sha, update_key, rc4_key_len);
222         SHA1_Update(&sha, pad_54, 40);
223         SHA1_Update(&sha, key, rc4_key_len);
224         SHA1_Final(shasig, &sha);
225
226         MD5_Init(&md5);
227         MD5_Update(&md5, update_key, rc4_key_len);
228         MD5_Update(&md5, pad_92, 48);
229         MD5_Update(&md5, shasig, 20);
230         MD5_Final(key, &md5);
231
232         RC4_set_key(&update, rc4_key_len, key);
233         RC4(&update, rc4_key_len, key, key);
234
235         if (rc4_key_len == 8)
236                 sec_make_40bit(key);
237 }
238
239 /* Encrypt data using RC4 */
240 static void
241 sec_encrypt(uint8 * data, int length)
242 {
243         static int use_count;
244
245         if (use_count == 4096)
246         {
247                 sec_update(sec_encrypt_key, sec_encrypt_update_key);
248                 RC4_set_key(&rc4_encrypt_key, rc4_key_len, sec_encrypt_key);
249                 use_count = 0;
250         }
251
252         RC4(&rc4_encrypt_key, length, data, data);
253         use_count++;
254 }
255
256 /* Decrypt data using RC4 */
257 void
258 sec_decrypt(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         RC4(&rc4_decrypt_key, length, data, data);
270         use_count++;
271 }
272
273 static void
274 reverse(uint8 * p, int len)
275 {
276         int i, j;
277         uint8 temp;
278
279         for (i = 0, j = len - 1; i < j; i++, j--)
280         {
281                 temp = p[i];
282                 p[i] = p[j];
283                 p[j] = temp;
284         }
285 }
286
287 /* Perform an RSA public key encryption operation */
288 static void
289 sec_rsa_encrypt(uint8 * out, uint8 * in, int len, uint8 * modulus, uint8 * exponent)
290 {
291         BN_CTX *ctx;
292         BIGNUM mod, exp, x, y;
293         uint8 inr[SEC_MODULUS_SIZE];
294         int outlen;
295
296         reverse(modulus, SEC_MODULUS_SIZE);
297         reverse(exponent, SEC_EXPONENT_SIZE);
298         memcpy(inr, in, len);
299         reverse(inr, len);
300
301         ctx = BN_CTX_new();
302         BN_init(&mod);
303         BN_init(&exp);
304         BN_init(&x);
305         BN_init(&y);
306
307         BN_bin2bn(modulus, SEC_MODULUS_SIZE, &mod);
308         BN_bin2bn(exponent, SEC_EXPONENT_SIZE, &exp);
309         BN_bin2bn(inr, len, &x);
310         BN_mod_exp(&y, &x, &exp, &mod, ctx);
311         outlen = BN_bn2bin(&y, out);
312         reverse(out, outlen);
313         if (outlen < SEC_MODULUS_SIZE)
314                 memset(out + outlen, 0, SEC_MODULUS_SIZE - outlen);
315
316         BN_free(&y);
317         BN_clear_free(&x);
318         BN_free(&exp);
319         BN_free(&mod);
320         BN_CTX_free(ctx);
321 }
322
323 /* Initialise secure transport packet */
324 STREAM
325 sec_init(uint32 flags, int maxlen)
326 {
327         int hdrlen;
328         STREAM s;
329
330         /*if (!g_licence_issued) */
331                 hdrlen = (flags & SEC_ENCRYPT) ? 12 : 4;
332 /*      else
333                 hdrlen = (flags & SEC_ENCRYPT) ? 12 : 0; */
334         s = mcs_init(maxlen + hdrlen);
335         s_push_layer(s, sec_hdr, hdrlen);
336
337         return s;
338 }
339
340 /* Transmit secure transport packet over specified channel */
341 void
342 sec_send_to_channel(STREAM s, uint32 flags, uint16 channel)
343 {
344         int datalen;
345
346         s_pop_layer(s, sec_hdr);
347         //if (!g_licence_issued || (flags & SEC_ENCRYPT))
348                 out_uint32_le(s, flags);
349
350         if (flags & SEC_ENCRYPT)
351         {
352                 flags &= ~SEC_ENCRYPT;
353                 datalen = s->end - s->p - 8;
354
355 #if WITH_DEBUG
356                 DEBUG(("Sending encrypted packet:\n"));
357                 hexdump(s->p + 8, datalen);
358 #endif
359
360                 sec_sign(s->p, 8, sec_sign_key, rc4_key_len, s->p + 8, datalen);
361                 sec_encrypt(s->p + 8, datalen);
362         }
363
364         mcs_send_to_channel(s, channel);
365 }
366
367 /* Transmit secure transport packet */
368
369 void
370 sec_send(STREAM s, uint32 flags)
371 {
372         sec_send_to_channel(s, flags, MCS_GLOBAL_CHANNEL);
373 }
374
375
376 /* Transfer the client random to the server */
377 static void
378 sec_establish_key(void)
379 {
380         uint32 length = SEC_MODULUS_SIZE + SEC_PADDING_SIZE;
381         uint32 flags = SEC_CLIENT_RANDOM;
382         STREAM s;
383
384         s = sec_init(flags, 76);
385
386         out_uint32_le(s, length);
387         out_uint8p(s, sec_crypted_random, SEC_MODULUS_SIZE);
388         out_uint8s(s, SEC_PADDING_SIZE);
389
390         s_mark_end(s);
391         sec_send(s, flags);
392 }
393
394 /* Parse a public key structure */
395 static BOOL
396 sec_parse_public_key(STREAM s, uint8 ** modulus, uint8 ** exponent)
397 {
398         uint32 magic, modulus_len;
399
400         in_uint32_le(s, magic);
401         if (magic != SEC_RSA_MAGIC)
402         {
403                 error("RSA magic 0x%x\n", magic);
404                 return False;
405         }
406
407         in_uint32_le(s, modulus_len);
408         if (modulus_len != SEC_MODULUS_SIZE + SEC_PADDING_SIZE)
409         {
410                 error("modulus len 0x%x\n", modulus_len);
411                 return False;
412         }
413
414         in_uint8s(s, 8);        /* modulus_bits, unknown */
415         in_uint8p(s, *exponent, SEC_EXPONENT_SIZE);
416         in_uint8p(s, *modulus, SEC_MODULUS_SIZE);
417         in_uint8s(s, SEC_PADDING_SIZE);
418
419         return s_check(s);
420 }
421
422 static BOOL
423 sec_parse_x509_key(X509 * cert)
424 {
425         EVP_PKEY *epk = NULL;
426         /* By some reason, Microsoft sets the OID of the Public RSA key to
427            the oid for "MD5 with RSA Encryption" instead of "RSA Encryption"
428
429            Kudos to Richard Levitte for the following (. intiutive .) 
430            lines of code that resets the OID and let's us extract the key. */
431         if (OBJ_obj2nid(cert->cert_info->key->algor->algorithm) == NID_md5WithRSAEncryption)
432         {
433                 DEBUG_RDP5(("Re-setting algorithm type to RSA in server certificate\n"));
434                 cert->cert_info->key->algor->algorithm = OBJ_nid2obj(NID_rsaEncryption);
435         }
436         epk = X509_get_pubkey(cert);
437         if (NULL == epk)
438         {
439                 error("Failed to extract public key from certificate\n");
440                 return False;
441         }
442
443         server_public_key = (RSA *) epk->pkey.ptr;
444
445         return True;
446 }
447
448
449 /* Parse a crypto information structure */
450 static BOOL
451 sec_parse_crypt_info(STREAM s, uint32 * rc4_key_size,
452                      uint8 ** server_random, uint8 ** modulus, uint8 ** exponent)
453 {
454         uint32 crypt_level, random_len, rsa_info_len;
455         uint32 cacert_len, cert_len, flags;
456         X509 *cacert, *server_cert;
457         uint16 tag, length;
458         uint8 *next_tag, *end;
459
460         in_uint32_le(s, *rc4_key_size); /* 1 = 40-bit, 2 = 128-bit */
461         in_uint32_le(s, crypt_level);   /* 1 = low, 2 = medium, 3 = high */
462         if (crypt_level == 0)   /* no encryption */
463                 return False;
464         in_uint32_le(s, random_len);
465         in_uint32_le(s, rsa_info_len);
466
467         if (random_len != SEC_RANDOM_SIZE)
468         {
469                 error("random len %d, expected %d\n", random_len, SEC_RANDOM_SIZE);
470                 return False;
471         }
472
473         in_uint8p(s, *server_random, random_len);
474
475         /* RSA info */
476         end = s->p + rsa_info_len;
477         if (end > s->end)
478                 return False;
479
480         in_uint32_le(s, flags); /* 1 = RDP4-style, 0x80000002 = X.509 */
481         if (flags & 1)
482         {
483                 DEBUG_RDP5(("We're going for the RDP4-style encryption\n"));
484                 in_uint8s(s, 8);        /* unknown */
485
486                 while (s->p < end)
487                 {
488                         in_uint16_le(s, tag);
489                         in_uint16_le(s, length);
490
491                         next_tag = s->p + length;
492
493                         switch (tag)
494                         {
495                                 case SEC_TAG_PUBKEY:
496                                         if (!sec_parse_public_key(s, modulus, exponent))
497                                                 return False;
498                                         DEBUG_RDP5(("Got Public key, RDP4-style\n"));
499
500                                         break;
501
502                                 case SEC_TAG_KEYSIG:
503                                         /* Is this a Microsoft key that we just got? */
504                                         /* Care factor: zero! */
505                                         /* Actually, it would probably be a good idea to check if the public key is signed with this key, and then store this 
506                                            key as a known key of the hostname. This would prevent some MITM-attacks. */
507                                         break;
508
509                                 default:
510                                         unimpl("crypt tag 0x%x\n", tag);
511                         }
512
513                         s->p = next_tag;
514                 }
515         }
516         else
517         {
518                 uint32 certcount;
519
520                 DEBUG_RDP5(("We're going for the RDP5-style encryption\n"));
521                 in_uint32_le(s, certcount); /* Number of certificates */
522
523                 if(certcount < 2) 
524                 {
525                         error("Server didn't send enough X509 certificates\n");
526                         return False;
527                 }
528
529                 for(; certcount > 2; certcount--)
530                 { /* ignore all the certificates between the root and the signing CA */
531                         uint32 ignorelen;
532                         X509 *ignorecert;
533
534                         DEBUG_RDP5(("Ignored certs left: %d\n", certcount));
535
536                         in_uint32_le(s, ignorelen);
537                         DEBUG_RDP5(("Ignored Certificate length is %d\n", ignorelen));
538                         ignorecert = d2i_X509(NULL, &(s->p), ignorelen);
539
540                         if(ignorecert == NULL)
541                         { /* XXX: error out? */
542                                 DEBUG_RDP5(("got a bad cert: this will probably screw up the rest of the communication\n"));
543                         }
544
545 #ifdef WITH_DEBUG_RDP5
546                         DEBUG_RDP5(("cert #%d (ignored):\n",certcount));
547                         X509_print_fp(stdout, ignorecert);
548 #endif
549                 }
550
551                 /* Do da funky X.509 stuffy 
552
553                    "How did I find out about this?  I looked up and saw a
554                    bright light and when I came to I had a scar on my forehead
555                    and knew about X.500"
556                    - Peter Gutman in a early version of 
557                    http://www.cs.auckland.ac.nz/~pgut001/pubs/x509guide.txt
558                  */
559
560                 in_uint32_le(s, cacert_len);
561                 DEBUG_RDP5(("CA Certificate length is %d\n", cacert_len));
562                 cacert = d2i_X509(NULL, &(s->p), cacert_len);
563                 /* Note: We don't need to move s->p here - d2i_X509 is
564                    "kind" enough to do it for us */
565                 if (NULL == cacert)
566                 {
567                         error("Couldn't load CA Certificate from server\n");
568                         return False;
569                 }
570
571                 /* Currently, we don't use the CA Certificate. 
572                    FIXME: 
573                    *) Verify the server certificate (server_cert) with the 
574                    CA certificate.
575                    *) Store the CA Certificate with the hostname of the 
576                    server we are connecting to as key, and compare it
577                    when we connect the next time, in order to prevent
578                    MITM-attacks.
579                  */
580
581                 in_uint32_le(s, cert_len);
582                 DEBUG_RDP5(("Certificate length is %d\n", cert_len));
583                 server_cert = d2i_X509(NULL, &(s->p), cert_len);
584                 if (NULL == server_cert)
585                 {
586                         error("Couldn't load Certificate from server\n");
587                         return False;
588                 }
589
590                 in_uint8s(s, 16);       /* Padding */
591
592                 /* Note: Verifying the server certificate must be done here, 
593                    before sec_parse_public_key since we'll have to apply
594                    serious violence to the key after this */
595
596                 if (!sec_parse_x509_key(server_cert))
597                 {
598                         DEBUG_RDP5(("Didn't parse X509 correctly\n"));
599                         return False;
600                 }
601                 return True;    /* There's some garbage here we don't care about */
602         }
603         return s_check_end(s);
604 }
605
606 /* Process crypto information blob */
607 static void
608 sec_process_crypt_info(STREAM s)
609 {
610         uint8 *server_random, *modulus, *exponent;
611         uint8 client_random[SEC_RANDOM_SIZE];
612         uint32 rc4_key_size;
613         uint8 inr[SEC_MODULUS_SIZE];
614
615         if (!sec_parse_crypt_info(s, &rc4_key_size, &server_random, &modulus, &exponent))
616         {
617                 DEBUG(("Failed to parse crypt info\n"));
618                 return;
619         }
620
621         DEBUG(("Generating client random\n"));
622         /* Generate a client random, and hence determine encryption keys */
623         /* This is what the MS client do: */
624         memset(inr, 0, SEC_RANDOM_SIZE);
625         /*  *ARIGL!* Plaintext attack, anyone?
626            I tried doing:
627            generate_random(inr);
628            ..but that generates connection errors now and then (yes, 
629            "now and then". Something like 0 to 3 attempts needed before a 
630            successful connection. Nice. Not! 
631          */
632
633         generate_random(client_random);
634         if (NULL != server_public_key)
635         {                       /* Which means we should use 
636                                    RDP5-style encryption */
637
638                 memcpy(inr + SEC_RANDOM_SIZE, client_random, SEC_RANDOM_SIZE);
639                 reverse(inr + SEC_RANDOM_SIZE, SEC_RANDOM_SIZE);
640
641                 RSA_public_encrypt(SEC_MODULUS_SIZE,
642                                    inr, sec_crypted_random, server_public_key, RSA_NO_PADDING);
643
644                 reverse(sec_crypted_random, SEC_MODULUS_SIZE);
645
646         }
647         else
648         {                       /* RDP4-style encryption */
649                 sec_rsa_encrypt(sec_crypted_random,
650                                 client_random, SEC_RANDOM_SIZE, modulus, exponent);
651         }
652         sec_generate_keys(client_random, server_random, rc4_key_size);
653 }
654
655
656 /* Process SRV_INFO, find RDP version supported by server */
657 static void
658 sec_process_srv_info(STREAM s)
659 {
660         in_uint16_le(s, g_server_rdp_version);
661         DEBUG_RDP5(("Server RDP version is %d\n", g_server_rdp_version));
662 /*      if (1 == g_server_rdp_version)
663                 g_use_rdp5 = 0; */
664 }
665
666
667 /* Process connect response data blob */
668 void
669 sec_process_mcs_data(STREAM s)
670 {
671         uint16 tag, length;
672         uint8 *next_tag;
673         uint8 len;
674
675         in_uint8s(s, 21);       /* header (T.124 stuff, probably) */
676         in_uint8(s, len);
677         if (len & 0x80)
678                 in_uint8(s, len);
679
680         while (s->p < s->end)
681         {
682                 in_uint16_le(s, tag);
683                 in_uint16_le(s, length);
684
685                 if (length <= 4)
686                         return;
687
688                 next_tag = s->p + length - 4;
689
690                 switch (tag)
691                 {
692                         case SEC_TAG_SRV_INFO:
693                                 sec_process_srv_info(s);
694                                 break;
695
696                         case SEC_TAG_SRV_CRYPT:
697                                 sec_process_crypt_info(s);
698                                 break;
699
700                         case SEC_TAG_SRV_CHANNELS:
701                                 /* FIXME: We should parse this information and
702                                    use it to map RDP5 channels to MCS 
703                                    channels */
704                                 break;
705
706                         default:
707                                 unimpl("response tag 0x%x\n", tag);
708                 }
709
710                 s->p = next_tag;
711         }
712 }
713
714 /* Receive secure transport packet */
715 STREAM
716 sec_recv(void)
717 {
718         uint32 sec_flags;
719         uint16 channel;
720         STREAM s;
721
722         while ((s = mcs_recv(&channel)) != NULL)
723         {
724                 if (/*g_encryption || !g_licence_issued*/ 0)
725                 {
726                         in_uint32_le(s, sec_flags);
727
728                         if (sec_flags & SEC_ENCRYPT)
729                         {
730                                 in_uint8s(s, 8);        /* signature */
731                                 sec_decrypt(s->p, s->end - s->p);
732                         }
733
734                         if (sec_flags & SEC_LICENCE_NEG)
735                         {
736                                 licence_process(s);
737                                 continue;
738                         }
739                 }
740
741                 if (channel != MCS_GLOBAL_CHANNEL)
742                 {
743                         channel_process(s, channel);
744                         continue;
745                 }
746
747                 return s;
748         }
749
750         return NULL;
751 }
752
753 /* Disconnect a connection */
754 void
755 sec_disconnect(void)
756 {
757         mcs_disconnect();
758 }