/[rdesktop]/sourceforge.net/trunk/rdesktop/secure.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/secure.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 419 by forsberg, Wed Jun 11 07:12:18 2003 UTC revision 638 by astrand, Wed Mar 17 14:11:08 2004 UTC
# Line 34  Line 34 
34  #endif  #endif
35    
36  extern char hostname[16];  extern char hostname[16];
37  extern int width;  extern int g_width;
38  extern int height;  extern int g_height;
39  extern int keylayout;  extern int keylayout;
40  extern BOOL encryption;  extern BOOL g_encryption;
41  extern BOOL g_licence_issued;  extern BOOL g_licence_issued;
42  extern BOOL use_rdp5;  extern BOOL g_use_rdp5;
43  extern int server_bpp;  extern BOOL g_console_session;
44    extern int g_server_bpp;
45  extern uint16 mcs_userid;  extern uint16 mcs_userid;
46    extern VCHANNEL g_channels[];
47    extern unsigned int g_num_channels;
48    
49  static int rc4_key_len;  static int rc4_key_len;
50  static RC4_KEY rc4_decrypt_key;  static RC4_KEY rc4_decrypt_key;
# Line 55  static uint8 sec_decrypt_update_key[16]; Line 58  static uint8 sec_decrypt_update_key[16];
58  static uint8 sec_encrypt_update_key[16];  static uint8 sec_encrypt_update_key[16];
59  static uint8 sec_crypted_random[SEC_MODULUS_SIZE];  static uint8 sec_crypted_random[SEC_MODULUS_SIZE];
60    
61  uint16 server_rdp_version = 0;  uint16 g_server_rdp_version = 0;
62    
63  /*  /*
64   * General purpose 48-byte transformation, using two 32-byte salts (generally,   * General purpose 48-byte transformation, using two 32-byte salts (generally,
# Line 399  sec_establish_key(void) Line 402  sec_establish_key(void)
402  static void  static void
403  sec_out_mcs_data(STREAM s)  sec_out_mcs_data(STREAM s)
404  {  {
         uint16 num_channels = get_num_channels();  
405          int hostlen = 2 * strlen(hostname);          int hostlen = 2 * strlen(hostname);
406          int length = 158 + 76 + 12 + 4 + (CHANNEL_TAGDATA_SIZE * num_channels);          int length = 158 + 76 + 12 + 4;
407          uint16 i;          unsigned int i;
         rdp5_channel *channel;  
408    
409          if (0 < num_channels)          if (g_num_channels > 0)
410          {                  length += g_num_channels * 12 + 8;
                 length += +4 + 4;  
         }  
411    
412          if (hostlen > 30)          if (hostlen > 30)
413                  hostlen = 30;                  hostlen = 30;
# Line 426  sec_out_mcs_data(STREAM s) Line 425  sec_out_mcs_data(STREAM s)
425          out_uint16_le(s, 0xc001);          out_uint16_le(s, 0xc001);
426          out_uint8(s, 0);          out_uint8(s, 0);
427    
428          out_uint32_le(s, 0x61637544);   /* "Duca" ?! */          out_uint32_le(s, 0x61637544);   /* "Duca", as in Ducati. */
429          out_uint16_be(s, ((length - 14) | 0x8000));     /* remaining length */          out_uint16_be(s, ((length - 14) | 0x8000));     /* remaining length */
430    
431          /* Client information */          /* Client information */
432          out_uint16_le(s, SEC_TAG_CLI_INFO);          out_uint16_le(s, SEC_TAG_CLI_INFO);
433          out_uint16_le(s, 212);  /* length */          out_uint16_le(s, 212);  /* length */
434          out_uint16_le(s, use_rdp5 ? 4 : 1);     /* RDP version. 1 == RDP4, 4 == RDP5. */          out_uint16_le(s, g_use_rdp5 ? 4 : 1);   /* RDP version. 1 == RDP4, 4 == RDP5. */
435          out_uint16_le(s, 8);          out_uint16_le(s, 8);
436          out_uint16_le(s, width);          out_uint16_le(s, g_width);
437          out_uint16_le(s, height);          out_uint16_le(s, g_height);
438          out_uint16_le(s, 0xca01);          out_uint16_le(s, 0xca01);
439          out_uint16_le(s, 0xaa03);          out_uint16_le(s, 0xaa03);
440          out_uint32_le(s, keylayout);          out_uint32_le(s, keylayout);
# Line 450  sec_out_mcs_data(STREAM s) Line 449  sec_out_mcs_data(STREAM s)
449          out_uint32_le(s, 12);          out_uint32_le(s, 12);
450          out_uint8s(s, 64);      /* reserved? 4 + 12 doublewords */          out_uint8s(s, 64);      /* reserved? 4 + 12 doublewords */
451    
452          switch (server_bpp)          switch (g_server_bpp)
453          {          {
454                  case 8:                  case 8:
455                          out_uint16_le(s, 0xca01);                          out_uint16_le(s, 0xca01);
# Line 468  sec_out_mcs_data(STREAM s) Line 467  sec_out_mcs_data(STREAM s)
467          out_uint16_le(s, 1);          out_uint16_le(s, 1);
468    
469          out_uint32(s, 0);          out_uint32(s, 0);
470          out_uint8(s, server_bpp);          out_uint8(s, g_server_bpp);
471          out_uint16_le(s, 0x0700);          out_uint16_le(s, 0x0700);
472          out_uint8(s, 0);          out_uint8(s, 0);
473          out_uint32_le(s, 1);          out_uint32_le(s, 1);
# Line 476  sec_out_mcs_data(STREAM s) Line 475  sec_out_mcs_data(STREAM s)
475    
476          out_uint16_le(s, SEC_TAG_CLI_4);          out_uint16_le(s, SEC_TAG_CLI_4);
477          out_uint16_le(s, 12);          out_uint16_le(s, 12);
478          out_uint32_le(s, 9);          out_uint32_le(s, g_console_session ? 0xb : 9);
479          out_uint32(s, 0);          out_uint32(s, 0);
480    
481          /* Client encryption settings */          /* Client encryption settings */
482          out_uint16_le(s, SEC_TAG_CLI_CRYPT);          out_uint16_le(s, SEC_TAG_CLI_CRYPT);
483          out_uint16_le(s, 12);   /* length */          out_uint16_le(s, 12);   /* length */
484          out_uint32_le(s, encryption ? 0x3 : 0); /* encryption supported, 128-bit supported */          out_uint32_le(s, g_encryption ? 0x3 : 0);       /* encryption supported, 128-bit supported */
485          out_uint32(s, 0);       /* Unknown */          out_uint32(s, 0);       /* Unknown */
486    
487          DEBUG_RDP5(("num_channels is %d\n", num_channels));          DEBUG_RDP5(("g_num_channels is %d\n", g_num_channels));
488          if (0 < num_channels)          if (g_num_channels > 0)
489          {          {
490                  out_uint16_le(s, SEC_TAG_CLI_CHANNELS);                  out_uint16_le(s, SEC_TAG_CLI_CHANNELS);
491                  out_uint16_le(s, num_channels * CHANNEL_TAGDATA_SIZE + 4 + 4);  /* length */                  out_uint16_le(s, g_num_channels * 12 + 8);      /* length */
492                  out_uint32_le(s, num_channels); /* number of virtual channels */                  out_uint32_le(s, g_num_channels);       /* number of virtual channels */
493                  for (i = 0; i < num_channels; i++)                  for (i = 0; i < g_num_channels; i++)
494                  {                  {
495                          channel = find_channel_by_num(i);                          DEBUG_RDP5(("Requesting channel %s\n", g_channels[i].name));
496                          DEBUG_RDP5(("Requesting channel %s\n", channel->name));                          out_uint8a(s, g_channels[i].name, 8);
497                          out_uint8p(s, channel->name, 8);                          out_uint32_be(s, g_channels[i].flags);
                         out_uint32_be(s, channel->channelflags);  
498                  }                  }
499          }          }
500    
# Line 627  sec_parse_crypt_info(STREAM s, uint32 * Line 625  sec_parse_crypt_info(STREAM s, uint32 *
625          }          }
626          else          else
627          {          {
628                    uint32 certcount;
629    
630                  DEBUG_RDP5(("We're going for the RDP5-style encryption\n"));                  DEBUG_RDP5(("We're going for the RDP5-style encryption\n"));
631                  in_uint8s(s, 4);        /* Number of certificates */                  in_uint32_le(s, certcount);     /* Number of certificates */
632    
633                    if (certcount < 2)
634                    {
635                            error("Server didn't send enough X509 certificates\n");
636                            return False;
637                    }
638    
639                    for (; certcount > 2; certcount--)
640                    {               /* ignore all the certificates between the root and the signing CA */
641                            uint32 ignorelen;
642                            X509 *ignorecert;
643    
644                            DEBUG_RDP5(("Ignored certs left: %d\n", certcount));
645    
646                            in_uint32_le(s, ignorelen);
647                            DEBUG_RDP5(("Ignored Certificate length is %d\n", ignorelen));
648                            ignorecert = d2i_X509(NULL, &(s->p), ignorelen);
649    
650                            if (ignorecert == NULL)
651                            {       /* XXX: error out? */
652                                    DEBUG_RDP5(("got a bad cert: this will probably screw up the rest of the communication\n"));
653                            }
654    
655    #ifdef WITH_DEBUG_RDP5
656                            DEBUG_RDP5(("cert #%d (ignored):\n", certcount));
657                            X509_print_fp(stdout, ignorecert);
658    #endif
659                    }
660    
661                  /* Do da funky X.509 stuffy                  /* Do da funky X.509 stuffy
662    
# Line 702  sec_process_crypt_info(STREAM s) Line 730  sec_process_crypt_info(STREAM s)
730    
731          DEBUG(("Generating client random\n"));          DEBUG(("Generating client random\n"));
732          /* Generate a client random, and hence determine encryption keys */          /* Generate a client random, and hence determine encryption keys */
733          // This is what the MS client do:          /* This is what the MS client do: */
734          memset(inr, 0, SEC_RANDOM_SIZE);          memset(inr, 0, SEC_RANDOM_SIZE);
735          /*  *ARIGL!* Plaintext attack, anyone?          /*  *ARIGL!* Plaintext attack, anyone?
736             I tried doing:             I tried doing:
# Line 739  sec_process_crypt_info(STREAM s) Line 767  sec_process_crypt_info(STREAM s)
767  static void  static void
768  sec_process_srv_info(STREAM s)  sec_process_srv_info(STREAM s)
769  {  {
770          in_uint16_le(s, server_rdp_version);          in_uint16_le(s, g_server_rdp_version);
771          DEBUG_RDP5(("Server RDP version is %d\n", server_rdp_version));          DEBUG_RDP5(("Server RDP version is %d\n", g_server_rdp_version));
772            if (1 == g_server_rdp_version)
773                    g_use_rdp5 = 0;
774  }  }
775    
776    
# Line 773  sec_process_mcs_data(STREAM s) Line 803  sec_process_mcs_data(STREAM s)
803                                  sec_process_srv_info(s);                                  sec_process_srv_info(s);
804                                  break;                                  break;
805    
                         case SEC_TAG_SRV_3:  
                                 /* FIXME: We should parse this information and  
                                    use it to map RDP5 channels to MCS  
                                    channels */  
                                 break;  
   
806                          case SEC_TAG_SRV_CRYPT:                          case SEC_TAG_SRV_CRYPT:
807                                  sec_process_crypt_info(s);                                  sec_process_crypt_info(s);
808                                  break;                                  break;
809    
810                            case SEC_TAG_SRV_CHANNELS:
811                                    /* FIXME: We should parse this information and
812                                       use it to map RDP5 channels to MCS
813                                       channels */
814                                    break;
815    
816                          default:                          default:
817                                  unimpl("response tag 0x%x\n", tag);                                  unimpl("response tag 0x%x\n", tag);
818                  }                  }
# Line 801  sec_recv(void) Line 831  sec_recv(void)
831    
832          while ((s = mcs_recv(&channel)) != NULL)          while ((s = mcs_recv(&channel)) != NULL)
833          {          {
834                  if (encryption || !g_licence_issued)                  if (g_encryption || !g_licence_issued)
835                  {                  {
836                          in_uint32_le(s, sec_flags);                          in_uint32_le(s, sec_flags);
837    
                         if (sec_flags & SEC_LICENCE_NEG)  
                         {  
                                 if (sec_flags & SEC_ENCRYPT)  
                                 {  
                                         DEBUG_RDP5(("Encrypted license detected\n"));  
                                 }  
                                 licence_process(s);  
                                 continue;  
                         }  
   
838                          if (sec_flags & SEC_ENCRYPT)                          if (sec_flags & SEC_ENCRYPT)
839                          {                          {
840                                  in_uint8s(s, 8);        /* signature */                                  in_uint8s(s, 8);        /* signature */
841                                  sec_decrypt(s->p, s->end - s->p);                                  sec_decrypt(s->p, s->end - s->p);
842                          }                          }
843    
844                            if (sec_flags & SEC_LICENCE_NEG)
845                            {
846                                    licence_process(s);
847                                    continue;
848                            }
849                  }                  }
850    
851                  if (MCS_GLOBAL_CHANNEL == channel)                  if (channel != MCS_GLOBAL_CHANNEL)
852                  {                  {
853                          return s;                          channel_process(s, channel);
854                            continue;
855                  }                  }
                 else  
                         rdp5_process_channel(s, channel);  
856    
857                    return s;
858          }          }
859    
860          return NULL;          return NULL;
# Line 848  sec_connect(char *server, char *username Line 874  sec_connect(char *server, char *username
874          if (!mcs_connect(server, &mcs_data, username))          if (!mcs_connect(server, &mcs_data, username))
875                  return False;                  return False;
876    
877          //      sec_process_mcs_data(&mcs_data);          /*      sec_process_mcs_data(&mcs_data); */
878          if (encryption)          if (g_encryption)
879                  sec_establish_key();                  sec_establish_key();
880          xfree(mcs_data.data);          xfree(mcs_data.data);
881          return True;          return True;
Legend:
Removed from v.419  
changed lines
  Added in v.638
  ViewVC Help
Powered by ViewVC 1.1.26