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

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

revision 1388 by jsorg71, Sat Jan 27 20:38:30 2007 UTC revision 1389 by jsorg71, Sat Feb 10 05:15:58 2007 UTC
# Line 33  extern RD_BOOL g_licence_issued; Line 33  extern RD_BOOL g_licence_issued;
33  extern RD_BOOL g_use_rdp5;  extern RD_BOOL g_use_rdp5;
34  extern RD_BOOL g_console_session;  extern RD_BOOL g_console_session;
35  extern int g_server_depth;  extern int g_server_depth;
 extern uint16 mcs_userid;  
36  extern VCHANNEL g_channels[];  extern VCHANNEL g_channels[];
37  extern unsigned int g_num_channels;  extern unsigned int g_num_channels;
38    
39  static int rc4_key_len;  static int g_rc4_key_len;
40  static SSL_RC4 rc4_decrypt_key;  static SSL_RC4 g_rc4_decrypt_key;
41  static SSL_RC4 rc4_encrypt_key;  static SSL_RC4 g_rc4_encrypt_key;
42  static uint32 server_public_key_len;  static uint32 g_server_public_key_len;
43    
44  static uint8 sec_sign_key[16];  static uint8 g_sec_sign_key[16];
45  static uint8 sec_decrypt_key[16];  static uint8 g_sec_decrypt_key[16];
46  static uint8 sec_encrypt_key[16];  static uint8 g_sec_encrypt_key[16];
47  static uint8 sec_decrypt_update_key[16];  static uint8 g_sec_decrypt_update_key[16];
48  static uint8 sec_encrypt_update_key[16];  static uint8 g_sec_encrypt_update_key[16];
49  static uint8 sec_crypted_random[SEC_MAX_MODULUS_SIZE];  static uint8 g_sec_crypted_random[SEC_MAX_MODULUS_SIZE];
50    
51  uint16 g_server_rdp_version = 0;  uint16 g_server_rdp_version = 0;
52    
53  /* These values must be available to reset state - Session Directory */  /* These values must be available to reset state - Session Directory */
54  static int sec_encrypt_use_count = 0;  static int g_sec_encrypt_use_count = 0;
55  static int sec_decrypt_use_count = 0;  static int g_sec_decrypt_use_count = 0;
56    
57  /*  /*
58   * I believe this is based on SSLv3 with the following differences:   * I believe this is based on SSLv3 with the following differences:
# Line 137  sec_generate_keys(uint8 * client_random, Line 136  sec_generate_keys(uint8 * client_random,
136          sec_hash_48(key_block, master_secret, client_random, server_random, 'X');          sec_hash_48(key_block, master_secret, client_random, server_random, 'X');
137    
138          /* First 16 bytes of key material is MAC secret */          /* First 16 bytes of key material is MAC secret */
139          memcpy(sec_sign_key, key_block, 16);          memcpy(g_sec_sign_key, key_block, 16);
140    
141          /* Generate export keys from next two blocks of 16 bytes */          /* Generate export keys from next two blocks of 16 bytes */
142          sec_hash_16(sec_decrypt_key, &key_block[16], client_random, server_random);          sec_hash_16(g_sec_decrypt_key, &key_block[16], client_random, server_random);
143          sec_hash_16(sec_encrypt_key, &key_block[32], client_random, server_random);          sec_hash_16(g_sec_encrypt_key, &key_block[32], client_random, server_random);
144    
145          if (rc4_key_size == 1)          if (rc4_key_size == 1)
146          {          {
147                  DEBUG(("40-bit encryption enabled\n"));                  DEBUG(("40-bit encryption enabled\n"));
148                  sec_make_40bit(sec_sign_key);                  sec_make_40bit(g_sec_sign_key);
149                  sec_make_40bit(sec_decrypt_key);                  sec_make_40bit(g_sec_decrypt_key);
150                  sec_make_40bit(sec_encrypt_key);                  sec_make_40bit(g_sec_encrypt_key);
151                  rc4_key_len = 8;                  g_rc4_key_len = 8;
152          }          }
153          else          else
154          {          {
155                  DEBUG(("rc_4_key_size == %d, 128-bit encryption enabled\n", rc4_key_size));                  DEBUG(("rc_4_key_size == %d, 128-bit encryption enabled\n", rc4_key_size));
156                  rc4_key_len = 16;                  g_rc4_key_len = 16;
157          }          }
158    
159          /* Save initial RC4 keys as update keys */          /* Save initial RC4 keys as update keys */
160          memcpy(sec_decrypt_update_key, sec_decrypt_key, 16);          memcpy(g_sec_decrypt_update_key, g_sec_decrypt_key, 16);
161          memcpy(sec_encrypt_update_key, sec_encrypt_key, 16);          memcpy(g_sec_encrypt_update_key, g_sec_encrypt_key, 16);
162    
163          /* Initialise RC4 state arrays */          /* Initialise RC4 state arrays */
164          ssl_rc4_set_key(&rc4_decrypt_key, sec_decrypt_key, rc4_key_len);          ssl_rc4_set_key(&g_rc4_decrypt_key, g_sec_decrypt_key, g_rc4_key_len);
165          ssl_rc4_set_key(&rc4_encrypt_key, sec_encrypt_key, rc4_key_len);          ssl_rc4_set_key(&g_rc4_encrypt_key, g_sec_encrypt_key, g_rc4_key_len);
166  }  }
167    
168  static uint8 pad_54[40] = {  static uint8 pad_54[40] = {
# Line 228  sec_update(uint8 * key, uint8 * update_k Line 227  sec_update(uint8 * key, uint8 * update_k
227          SSL_RC4 update;          SSL_RC4 update;
228    
229          ssl_sha1_init(&sha1);          ssl_sha1_init(&sha1);
230          ssl_sha1_update(&sha1, update_key, rc4_key_len);          ssl_sha1_update(&sha1, update_key, g_rc4_key_len);
231          ssl_sha1_update(&sha1, pad_54, 40);          ssl_sha1_update(&sha1, pad_54, 40);
232          ssl_sha1_update(&sha1, key, rc4_key_len);          ssl_sha1_update(&sha1, key, g_rc4_key_len);
233          ssl_sha1_final(&sha1, shasig);          ssl_sha1_final(&sha1, shasig);
234    
235          ssl_md5_init(&md5);          ssl_md5_init(&md5);
236          ssl_md5_update(&md5, update_key, rc4_key_len);          ssl_md5_update(&md5, update_key, g_rc4_key_len);
237          ssl_md5_update(&md5, pad_92, 48);          ssl_md5_update(&md5, pad_92, 48);
238          ssl_md5_update(&md5, shasig, 20);          ssl_md5_update(&md5, shasig, 20);
239          ssl_md5_final(&md5, key);          ssl_md5_final(&md5, key);
240    
241          ssl_rc4_set_key(&update, key, rc4_key_len);          ssl_rc4_set_key(&update, key, g_rc4_key_len);
242          ssl_rc4_crypt(&update, key, key, rc4_key_len);          ssl_rc4_crypt(&update, key, key, g_rc4_key_len);
243    
244          if (rc4_key_len == 8)          if (g_rc4_key_len == 8)
245                  sec_make_40bit(key);                  sec_make_40bit(key);
246  }  }
247    
# Line 250  sec_update(uint8 * key, uint8 * update_k Line 249  sec_update(uint8 * key, uint8 * update_k
249  static void  static void
250  sec_encrypt(uint8 * data, int length)  sec_encrypt(uint8 * data, int length)
251  {  {
252          if (sec_encrypt_use_count == 4096)          if (g_sec_encrypt_use_count == 4096)
253          {          {
254                  sec_update(sec_encrypt_key, sec_encrypt_update_key);                  sec_update(g_sec_encrypt_key, g_sec_encrypt_update_key);
255                  ssl_rc4_set_key(&rc4_encrypt_key, sec_encrypt_key, rc4_key_len);                  ssl_rc4_set_key(&g_rc4_encrypt_key, g_sec_encrypt_key, g_rc4_key_len);
256                  sec_encrypt_use_count = 0;                  g_sec_encrypt_use_count = 0;
257          }          }
258    
259          ssl_rc4_crypt(&rc4_encrypt_key, data, data, length);          ssl_rc4_crypt(&g_rc4_encrypt_key, data, data, length);
260          sec_encrypt_use_count++;          g_sec_encrypt_use_count++;
261  }  }
262    
263  /* Decrypt data using RC4 */  /* Decrypt data using RC4 */
264  void  void
265  sec_decrypt(uint8 * data, int length)  sec_decrypt(uint8 * data, int length)
266  {  {
267          if (sec_decrypt_use_count == 4096)          if (g_sec_decrypt_use_count == 4096)
268          {          {
269                  sec_update(sec_decrypt_key, sec_decrypt_update_key);                  sec_update(g_sec_decrypt_key, g_sec_decrypt_update_key);
270                  ssl_rc4_set_key(&rc4_decrypt_key, sec_decrypt_key, rc4_key_len);                  ssl_rc4_set_key(&g_rc4_decrypt_key, g_sec_decrypt_key, g_rc4_key_len);
271                  sec_decrypt_use_count = 0;                  g_sec_decrypt_use_count = 0;
272          }          }
273    
274          ssl_rc4_crypt(&rc4_decrypt_key, data, data, length);          ssl_rc4_crypt(&g_rc4_decrypt_key, data, data, length);
275          sec_decrypt_use_count++;          g_sec_decrypt_use_count++;
276  }  }
277    
278  /* Perform an RSA public key encryption operation */  /* Perform an RSA public key encryption operation */
# Line 325  sec_send_to_channel(STREAM s, uint32 fla Line 324  sec_send_to_channel(STREAM s, uint32 fla
324                  hexdump(s->p + 8, datalen);                  hexdump(s->p + 8, datalen);
325  #endif  #endif
326    
327                  sec_sign(s->p, 8, sec_sign_key, rc4_key_len, s->p + 8, datalen);                  sec_sign(s->p, 8, g_sec_sign_key, g_rc4_key_len, s->p + 8, datalen);
328                  sec_encrypt(s->p + 8, datalen);                  sec_encrypt(s->p + 8, datalen);
329          }          }
330    
# Line 349  sec_send(STREAM s, uint32 flags) Line 348  sec_send(STREAM s, uint32 flags)
348  static void  static void
349  sec_establish_key(void)  sec_establish_key(void)
350  {  {
351          uint32 length = server_public_key_len + SEC_PADDING_SIZE;          uint32 length = g_server_public_key_len + SEC_PADDING_SIZE;
352          uint32 flags = SEC_CLIENT_RANDOM;          uint32 flags = SEC_CLIENT_RANDOM;
353          STREAM s;          STREAM s;
354    
355          s = sec_init(flags, length + 4);          s = sec_init(flags, length + 4);
356    
357          out_uint32_le(s, length);          out_uint32_le(s, length);
358          out_uint8p(s, sec_crypted_random, server_public_key_len);          out_uint8p(s, g_sec_crypted_random, g_server_public_key_len);
359          out_uint8s(s, SEC_PADDING_SIZE);          out_uint8s(s, SEC_PADDING_SIZE);
360    
361          s_mark_end(s);          s_mark_end(s);
# Line 479  sec_parse_public_key(STREAM s, uint8 * m Line 478  sec_parse_public_key(STREAM s, uint8 * m
478          in_uint8a(s, exponent, SEC_EXPONENT_SIZE);          in_uint8a(s, exponent, SEC_EXPONENT_SIZE);
479          in_uint8a(s, modulus, modulus_len);          in_uint8a(s, modulus, modulus_len);
480          in_uint8s(s, SEC_PADDING_SIZE);          in_uint8s(s, SEC_PADDING_SIZE);
481          server_public_key_len = modulus_len;          g_server_public_key_len = modulus_len;
482    
483          return s_check(s);          return s_check(s);
484  }  }
# Line 498  sec_parse_public_sig(STREAM s, uint32 le Line 497  sec_parse_public_sig(STREAM s, uint32 le
497          memset(signature, 0, sizeof(signature));          memset(signature, 0, sizeof(signature));
498          sig_len = len - 8;          sig_len = len - 8;
499          in_uint8a(s, signature, sig_len);          in_uint8a(s, signature, sig_len);
500          return ssl_sig_ok(exponent, SEC_EXPONENT_SIZE, modulus, server_public_key_len,          return ssl_sig_ok(exponent, SEC_EXPONENT_SIZE, modulus, g_server_public_key_len,
501                            signature, sig_len);                            signature, sig_len);
502  }  }
503    
# Line 635  sec_parse_crypt_info(STREAM s, uint32 * Line 634  sec_parse_crypt_info(STREAM s, uint32 *
634                  }                  }
635                  ssl_cert_free(cacert);                  ssl_cert_free(cacert);
636                  in_uint8s(s, 16);       /* Padding */                  in_uint8s(s, 16);       /* Padding */
637                  server_public_key = ssl_cert_to_rkey(server_cert, &server_public_key_len);                  server_public_key = ssl_cert_to_rkey(server_cert, &g_server_public_key_len);
638                  if (NULL == server_public_key)                  if (NULL == server_public_key)
639                  {                  {
640                          DEBUG_RDP5(("Didn't parse X509 correctly\n"));                          DEBUG_RDP5(("Didn't parse X509 correctly\n"));
# Line 643  sec_parse_crypt_info(STREAM s, uint32 * Line 642  sec_parse_crypt_info(STREAM s, uint32 *
642                          return False;                          return False;
643                  }                  }
644                  ssl_cert_free(server_cert);                  ssl_cert_free(server_cert);
645                  if ((server_public_key_len < SEC_MODULUS_SIZE) ||                  if ((g_server_public_key_len < SEC_MODULUS_SIZE) ||
646                      (server_public_key_len > SEC_MAX_MODULUS_SIZE))                      (g_server_public_key_len > SEC_MAX_MODULUS_SIZE))
647                  {                  {
648                          error("Bad server public key size (%u bits)\n", server_public_key_len * 8);                          error("Bad server public key size (%u bits)\n", g_server_public_key_len * 8);
649                          ssl_rkey_free(server_public_key);                          ssl_rkey_free(server_public_key);
650                          return False;                          return False;
651                  }                  }
# Line 682  sec_process_crypt_info(STREAM s) Line 681  sec_process_crypt_info(STREAM s)
681          }          }
682          DEBUG(("Generating client random\n"));          DEBUG(("Generating client random\n"));
683          generate_random(client_random);          generate_random(client_random);
684          sec_rsa_encrypt(sec_crypted_random, client_random, SEC_RANDOM_SIZE,          sec_rsa_encrypt(g_sec_crypted_random, client_random, SEC_RANDOM_SIZE,
685                          server_public_key_len, modulus, exponent);                          g_server_public_key_len, modulus, exponent);
686          sec_generate_keys(client_random, server_random, rc4_key_size);          sec_generate_keys(client_random, server_random, rc4_key_size);
687  }  }
688    
# Line 890  void Line 889  void
889  sec_reset_state(void)  sec_reset_state(void)
890  {  {
891          g_server_rdp_version = 0;          g_server_rdp_version = 0;
892          sec_encrypt_use_count = 0;          g_sec_encrypt_use_count = 0;
893          sec_decrypt_use_count = 0;          g_sec_decrypt_use_count = 0;
894          mcs_reset_state();          mcs_reset_state();
895  }  }
Legend:
Removed from v.1388  
changed lines
  Added in v.1389
  ViewVC Help
Powered by ViewVC 1.1.26