--- sourceforge.net/trunk/rdesktop/secure.c 2001/06/20 13:54:48 28 +++ sourceforge.net/trunk/rdesktop/secure.c 2002/08/04 02:48:08 88 @@ -1,7 +1,7 @@ /* rdesktop: A Remote Desktop Protocol client. Protocol services - RDP encryption and licensing - Copyright (C) Matthew Chapman 1999-2000 + Copyright (C) Matthew Chapman 1999-2001 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -19,28 +19,36 @@ */ #include "rdesktop.h" + +#ifdef WITH_OPENSSL +#include +#include +#include +#include +#else #include "crypto/rc4.h" #include "crypto/md5.h" #include "crypto/sha.h" -#include "crypto/arith.h" +#include "crypto/bn.h" +#endif extern char hostname[16]; extern int width; extern int height; extern int keylayout; -extern BOOL use_encryption; +extern BOOL encryption; extern BOOL licence_issued; static int rc4_key_len; static RC4_KEY rc4_decrypt_key; static RC4_KEY rc4_encrypt_key; -static uint8 sec_sign_key[8]; +static uint8 sec_sign_key[16]; static uint8 sec_decrypt_key[16]; static uint8 sec_encrypt_key[16]; -static uint8 sec_decrypt_update_key[8]; -static uint8 sec_encrypt_update_key[8]; -static uint8 sec_crypted_random[64]; +static uint8 sec_decrypt_update_key[16]; +static uint8 sec_encrypt_update_key[16]; +static uint8 sec_crypted_random[SEC_MODULUS_SIZE]; /* * General purpose 48-byte transformation, using two 32-byte salts (generally, @@ -48,7 +56,7 @@ * Both SHA1 and MD5 algorithms are used. */ void -sec_hash_48(uint8 *out, uint8 *in, uint8 *salt1, uint8 *salt2, uint8 salt) +sec_hash_48(uint8 * out, uint8 * in, uint8 * salt1, uint8 * salt2, uint8 salt) { uint8 shasig[20]; uint8 pad[4]; @@ -79,7 +87,7 @@ * only using a single round of MD5. */ void -sec_hash_16(uint8 *out, uint8 *in, uint8 *salt1, uint8 *salt2) +sec_hash_16(uint8 * out, uint8 * in, uint8 * salt1, uint8 * salt2) { MD5_CTX md5; @@ -92,7 +100,7 @@ /* Reduce key entropy from 64 to 40 bits */ static void -sec_make_40bit(uint8 *key) +sec_make_40bit(uint8 * key) { key[0] = 0xd1; key[1] = 0x26; @@ -101,7 +109,7 @@ /* Generate a session key and RC4 keys, given client and server randoms */ static void -sec_generate_keys(uint8 *client_key, uint8 *server_key, int rc4_key_size) +sec_generate_keys(uint8 * client_key, uint8 * server_key, int rc4_key_size) { uint8 session_key[48]; uint8 temp_hash[48]; @@ -115,18 +123,16 @@ sec_hash_48(temp_hash, input, client_key, server_key, 65); sec_hash_48(session_key, temp_hash, client_key, server_key, 88); - /* Store first 8 bytes of session key, for generating signatures */ - memcpy(sec_sign_key, session_key, 8); + /* Store first 16 bytes of session key, for generating signatures */ + memcpy(sec_sign_key, session_key, 16); /* Generate RC4 keys */ - sec_hash_16(sec_decrypt_key, &session_key[16], client_key, - server_key); - sec_hash_16(sec_encrypt_key, &session_key[32], client_key, - server_key); + sec_hash_16(sec_decrypt_key, &session_key[16], client_key, server_key); + sec_hash_16(sec_encrypt_key, &session_key[32], client_key, server_key); if (rc4_key_size == 1) { - DEBUG("40-bit encryption enabled\n"); + DEBUG(("40-bit encryption enabled\n")); sec_make_40bit(sec_sign_key); sec_make_40bit(sec_decrypt_key); sec_make_40bit(sec_encrypt_key); @@ -134,13 +140,13 @@ } else { - DEBUG("128-bit encryption enabled\n"); + DEBUG(("128-bit encryption enabled\n")); rc4_key_len = 16; } - /* Store first 8 bytes of RC4 keys as update keys */ - memcpy(sec_decrypt_update_key, sec_decrypt_key, 8); - memcpy(sec_encrypt_update_key, sec_encrypt_key, 8); + /* Save initial RC4 keys as update keys */ + memcpy(sec_decrypt_update_key, sec_decrypt_key, 16); + memcpy(sec_encrypt_update_key, sec_encrypt_key, 16); /* Initialise RC4 state arrays */ RC4_set_key(&rc4_decrypt_key, rc4_key_len, sec_decrypt_key); @@ -163,7 +169,7 @@ /* Output a uint32 into a buffer (little-endian) */ void -buf_out_uint32(uint8 *buffer, uint32 value) +buf_out_uint32(uint8 * buffer, uint32 value) { buffer[0] = (value) & 0xff; buffer[1] = (value >> 8) & 0xff; @@ -173,8 +179,7 @@ /* Generate a signature hash, using a combination of SHA1 and MD5 */ void -sec_sign(uint8 *signature, uint8 *session_key, int length, - uint8 *data, int datalen) +sec_sign(uint8 * signature, int siglen, uint8 * session_key, int keylen, uint8 * data, int datalen) { uint8 shasig[20]; uint8 md5sig[16]; @@ -185,24 +190,24 @@ buf_out_uint32(lenhdr, datalen); SHA1_Init(&sha); - SHA1_Update(&sha, session_key, length); + SHA1_Update(&sha, session_key, keylen); SHA1_Update(&sha, pad_54, 40); SHA1_Update(&sha, lenhdr, 4); SHA1_Update(&sha, data, datalen); SHA1_Final(shasig, &sha); MD5_Init(&md5); - MD5_Update(&md5, session_key, length); + MD5_Update(&md5, session_key, keylen); MD5_Update(&md5, pad_92, 48); MD5_Update(&md5, shasig, 20); MD5_Final(md5sig, &md5); - memcpy(signature, md5sig, length); + memcpy(signature, md5sig, siglen); } /* Update an encryption key - similar to the signing process */ static void -sec_update(uint8 *key, uint8 *update_key) +sec_update(uint8 * key, uint8 * update_key) { uint8 shasig[20]; SHA_CTX sha; @@ -210,13 +215,13 @@ RC4_KEY update; SHA1_Init(&sha); - SHA1_Update(&sha, update_key, 8); + SHA1_Update(&sha, update_key, rc4_key_len); SHA1_Update(&sha, pad_54, 40); - SHA1_Update(&sha, key, 8); + SHA1_Update(&sha, key, rc4_key_len); SHA1_Final(shasig, &sha); MD5_Init(&md5); - MD5_Update(&md5, update_key, 8); + MD5_Update(&md5, update_key, rc4_key_len); MD5_Update(&md5, pad_92, 48); MD5_Update(&md5, shasig, 20); MD5_Final(key, &md5); @@ -230,7 +235,7 @@ /* Encrypt data using RC4 */ static void -sec_encrypt(uint8 *data, int length) +sec_encrypt(uint8 * data, int length) { static int use_count; @@ -247,7 +252,7 @@ /* Decrypt data using RC4 */ static void -sec_decrypt(uint8 *data, int length) +sec_decrypt(uint8 * data, int length) { static int use_count; @@ -262,49 +267,54 @@ use_count++; } -/* Read in a NUMBER from a buffer */ -static void -sec_read_number(NUMBER * num, uint8 *buffer, int len) -{ - INT *data = num->n_part; - int i, j; - - for (i = 0, j = 0; j < len; i++, j += 2) - data[i] = buffer[j] | (buffer[j + 1] << 8); - - num->n_len = i; -} - -/* Write a NUMBER to a buffer */ static void -sec_write_number(NUMBER * num, uint8 *buffer, int len) +reverse(uint8 * p, int len) { - INT *data = num->n_part; int i, j; + uint8 temp; - for (i = 0, j = 0; j < len; i++, j += 2) + for (i = 0, j = len - 1; i < j; i++, j--) { - buffer[j] = data[i] & 0xff; - buffer[j + 1] = data[i] >> 8; + temp = p[i]; + p[i] = p[j]; + p[j] = temp; } } /* Perform an RSA public key encryption operation */ static void -sec_rsa_encrypt(uint8 *out, uint8 *in, int len, - uint8 *modulus, uint8 *exponent) +sec_rsa_encrypt(uint8 * out, uint8 * in, int len, uint8 * modulus, uint8 * exponent) { - NUMBER data, key; - - /* Set modulus for arithmetic */ - sec_read_number(&key, modulus, SEC_MODULUS_SIZE); - m_init(&key, NULL); - - /* Exponentiate */ - sec_read_number(&data, in, len); - sec_read_number(&key, exponent, SEC_EXPONENT_SIZE); - m_exp(&data, &key, &data); - sec_write_number(&data, out, SEC_MODULUS_SIZE); + BN_CTX ctx; + BIGNUM mod, exp, x, y; + uint8 inr[SEC_MODULUS_SIZE]; + int outlen; + + reverse(modulus, SEC_MODULUS_SIZE); + reverse(exponent, SEC_EXPONENT_SIZE); + memcpy(inr, in, len); + reverse(inr, len); + + BN_CTX_init(&ctx); + BN_init(&mod); + BN_init(&exp); + BN_init(&x); + BN_init(&y); + + BN_bin2bn(modulus, SEC_MODULUS_SIZE, &mod); + BN_bin2bn(exponent, SEC_EXPONENT_SIZE, &exp); + BN_bin2bn(inr, len, &x); + BN_mod_exp(&y, &x, &exp, &mod, &ctx); + outlen = BN_bn2bin(&y, out); + reverse(out, outlen); + if (outlen < SEC_MODULUS_SIZE) + memset(out + outlen, 0, SEC_MODULUS_SIZE - outlen); + + BN_free(&y); + BN_clear_free(&x); + BN_free(&exp); + BN_free(&mod); + BN_CTX_free(&ctx); } /* Initialise secure transport packet */ @@ -339,12 +349,12 @@ flags &= ~SEC_ENCRYPT; datalen = s->end - s->p - 8; -#if RDP_DEBUG - DEBUG("Sending encrypted packet:\n"); +#if WITH_DEBUG + DEBUG(("Sending encrypted packet:\n")); hexdump(s->p + 8, datalen); #endif - sec_sign(s->p, sec_sign_key, 8, s->p + 8, datalen); + sec_sign(s->p, 8, sec_sign_key, rc4_key_len, s->p + 8, datalen); sec_encrypt(s->p + 8, datalen); } @@ -374,6 +384,9 @@ sec_out_mcs_data(STREAM s) { int hostlen = 2 * strlen(hostname); + + if (hostlen > 30) + hostlen = 30; out_uint16_be(s, 5); /* unknown */ out_uint16_be(s, 0x14); @@ -418,27 +431,27 @@ /* Client encryption settings */ out_uint16_le(s, SEC_TAG_CLI_CRYPT); out_uint16(s, 8); /* length */ - out_uint32_le(s, use_encryption ? 1 : 0); /* encryption enabled */ + out_uint32_le(s, encryption ? 0x3 : 0); /* encryption supported, 128-bit supported */ s_mark_end(s); } /* Parse a public key structure */ static BOOL -sec_parse_public_key(STREAM s, uint8 **modulus, uint8 **exponent) +sec_parse_public_key(STREAM s, uint8 ** modulus, uint8 ** exponent) { uint32 magic, modulus_len; in_uint32_le(s, magic); if (magic != SEC_RSA_MAGIC) { - ERROR("RSA magic 0x%x\n", magic); + error("RSA magic 0x%x\n", magic); return False; } in_uint32_le(s, modulus_len); if (modulus_len != SEC_MODULUS_SIZE + SEC_PADDING_SIZE) { - ERROR("modulus len 0x%x\n", modulus_len); + error("modulus len 0x%x\n", modulus_len); return False; } @@ -452,8 +465,8 @@ /* Parse a crypto information structure */ static BOOL -sec_parse_crypt_info(STREAM s, uint32 *rc4_key_size, - uint8 **server_random, uint8 **modulus, uint8 **exponent) +sec_parse_crypt_info(STREAM s, uint32 * rc4_key_size, + uint8 ** server_random, uint8 ** modulus, uint8 ** exponent) { uint32 crypt_level, random_len, rsa_info_len; uint16 tag, length; @@ -466,7 +479,7 @@ if (random_len != SEC_RANDOM_SIZE) { - ERROR("random len %d\n", random_len); + error("random len %d\n", random_len); return False; } @@ -489,8 +502,7 @@ switch (tag) { case SEC_TAG_PUBKEY: - if (!sec_parse_public_key - (s, modulus, exponent)) + if (!sec_parse_public_key(s, modulus, exponent)) return False; break; @@ -501,7 +513,7 @@ break; default: - NOTIMP("crypt tag 0x%x\n", tag); + unimpl("crypt tag 0x%x\n", tag); } s->p = next_tag; @@ -518,14 +530,12 @@ uint8 client_random[SEC_RANDOM_SIZE]; uint32 rc4_key_size; - if (!sec_parse_crypt_info(s, &rc4_key_size, &server_random, - &modulus, &exponent)) + if (!sec_parse_crypt_info(s, &rc4_key_size, &server_random, &modulus, &exponent)) return; /* Generate a client random, and hence determine encryption keys */ generate_random(client_random); - sec_rsa_encrypt(sec_crypted_random, client_random, - SEC_RANDOM_SIZE, modulus, exponent); + sec_rsa_encrypt(sec_crypted_random, client_random, SEC_RANDOM_SIZE, modulus, exponent); sec_generate_keys(client_random, server_random, rc4_key_size); } @@ -559,7 +569,7 @@ break; default: - NOTIMP("response tag 0x%x\n", tag); + unimpl("response tag 0x%x\n", tag); } s->p = next_tag; @@ -575,7 +585,7 @@ while ((s = mcs_recv()) != NULL) { - if (use_encryption || !licence_issued) + if (encryption || !licence_issued) { in_uint32_le(s, sec_flags); @@ -613,7 +623,7 @@ return False; sec_process_mcs_data(&mcs_data); - if (use_encryption) + if (encryption) sec_establish_key(); return True; }