From d8ce866c928ffd32636811ba77546815f8ada78f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc-Andr=C3=A9=20Moreau?= Date: Thu, 7 Jul 2011 11:27:24 -0400 Subject: [PATCH] libfreerdp-core: fix compilation of crypto, credssp, and ntlmssp --- cunit/test_transport.c | 1 + include/freerdp/utils/stream.h | 20 ++- libfreerdp-core/CMakeLists.txt | 12 +- libfreerdp-core/credssp.c | 15 +- libfreerdp-core/credssp.h | 1 + libfreerdp-core/crypto.c | 55 ++++++- libfreerdp-core/crypto.h | 27 ++-- libfreerdp-core/gcc.c | 6 +- libfreerdp-core/ntlmssp.c | 253 ++++++++++++++++----------------- libfreerdp-gdi/color.c | 1 + libfreerdp-utils/stream.c | 19 ++- 11 files changed, 234 insertions(+), 176 deletions(-) diff --git a/cunit/test_transport.c b/cunit/test_transport.c index 4d3f0a9f9..f20252c67 100644 --- a/cunit/test_transport.c +++ b/cunit/test_transport.c @@ -66,6 +66,7 @@ packet_received(rdpTransport * transport, STREAM * stream, void * extra) CU_ASSERT(length == 19); freerdp_hexdump(stream->data, length); test_finished = 1; + return 0; } void test_transport(void) diff --git a/include/freerdp/utils/stream.h b/include/freerdp/utils/stream.h index fc83556ca..6884e4948 100644 --- a/include/freerdp/utils/stream.h +++ b/include/freerdp/utils/stream.h @@ -32,12 +32,8 @@ struct _STREAM }; typedef struct _STREAM STREAM; -STREAM * -stream_new(int size); -STREAM * -stream_new_empty(); -void -stream_free(STREAM * stream); +STREAM* stream_new(int size); +void stream_free(STREAM * stream); void stream_extend(STREAM * stream); @@ -76,6 +72,10 @@ stream_extend(STREAM * stream); (((uint64)(*(_s->p + 6))) << 48) + \ (((uint64)(*(_s->p + 7))) << 56); \ _s->p += 8; } while (0) +#define stream_read(_s, _b, _n) do { \ + memcpy(_b, (_s->p), (_n)); \ + _s->p += (_n); \ + } while (0) #define stream_write_uint8(_s, _v) do { \ *_s->p++ = (uint8)(_v); } while (0) @@ -100,7 +100,7 @@ stream_extend(STREAM * stream); memcpy(_s->p, (_b), (_n)); \ _s->p += (_n); \ } while (0) -#define stream_write_padding(_s, _n) do { \ +#define stream_write_zero(_s, _n) do { \ memset(_s->p, '\0', (_n)); \ _s->p += (_n); \ } while (0) @@ -131,6 +131,12 @@ stream_extend(STREAM * stream); (((uint16)(*_s->p)) << 8) + \ (uint16)(*(_s->p + 1)); \ _s->p += 2; } while (0) +#define stream_read_uint32_be(_s, _v) do { _v = \ + (((uint32)(*(_s->p))) << 8) + \ + (((uint32)(*(_s->p + 1)))) + \ + (((uint32)(*(_s->p + 2))) << 24) + \ + (((uint32)(*(_s->p + 3))) << 16); \ + _s->p += 4; } while (0) #define stream_write_uint16_be(_s, _v) do { \ *_s->p++ = ((_v) >> 8) & 0xFF; \ diff --git a/libfreerdp-core/CMakeLists.txt b/libfreerdp-core/CMakeLists.txt index 4b40ebff4..7e0cbf7d0 100644 --- a/libfreerdp-core/CMakeLists.txt +++ b/libfreerdp-core/CMakeLists.txt @@ -28,12 +28,12 @@ set(LIBFREERDP_CORE_SRCS mcs.h nego.c nego.h - #crypto.c - #crypto.h - #credssp.c - #credssp.h - #ntlmssp.c - #ntlmssp.h + crypto.c + crypto.h + credssp.c + credssp.h + ntlmssp.c + ntlmssp.h per.c per.h tcp.c diff --git a/libfreerdp-core/credssp.c b/libfreerdp-core/credssp.c index ddb8c29d4..fc536e342 100644 --- a/libfreerdp-core/credssp.c +++ b/libfreerdp-core/credssp.c @@ -104,7 +104,7 @@ int credssp_get_public_key(rdpCredssp *credssp) int credssp_authenticate(rdpCredssp *credssp) { NTLMSSP *ntlmssp = credssp->ntlmssp; - STREAM* s = stream_new_empty(); + STREAM* s = stream_new(0); uint8* negoTokenBuffer = (uint8*) xmalloc(2048); credssp_ntlmssp_init(credssp); @@ -124,7 +124,6 @@ int credssp_authenticate(rdpCredssp *credssp) return -1; s->p = s->data = credssp->negoToken.data; - s->p + credssp->negoToken.length; ntlmssp_recv(ntlmssp, s); datablob_free(&credssp->negoToken); @@ -180,15 +179,15 @@ void credssp_encrypt_public_key(rdpCredssp *credssp, DATABLOB *d) #ifdef WITH_DEBUG_NLA printf("Public Key (length = %d)\n", credssp->public_key.length); - hexdump(credssp->public_key.data, credssp->public_key.length); + freerdp_hexdump(credssp->public_key.data, credssp->public_key.length); printf("\n"); printf("Encrypted Public Key (length = %d)\n", encrypted_public_key.length); - hexdump(encrypted_public_key.data, encrypted_public_key.length); + freerdp_hexdump(encrypted_public_key.data, encrypted_public_key.length); printf("\n"); printf("Signature\n"); - hexdump(signature, 16); + freerdp_hexdump(signature, 16); printf("\n"); #endif @@ -253,15 +252,15 @@ void credssp_encrypt_ts_credentials(rdpCredssp *credssp, DATABLOB *d) #ifdef WITH_DEBUG_NLA printf("TSCredentials (length = %d)\n", credssp->ts_credentials.length); - hexdump(credssp->ts_credentials.data, credssp->ts_credentials.length); + freerdp_hexdump(credssp->ts_credentials.data, credssp->ts_credentials.length); printf("\n"); printf("Encrypted TSCredentials (length = %d)\n", encrypted_ts_credentials.length); - hexdump(encrypted_ts_credentials.data, encrypted_ts_credentials.length); + freerdp_hexdump(encrypted_ts_credentials.data, encrypted_ts_credentials.length); printf("\n"); printf("Signature\n"); - hexdump(signature, 16); + freerdp_hexdump(signature, 16); printf("\n"); #endif diff --git a/libfreerdp-core/credssp.h b/libfreerdp-core/credssp.h index f56adaa92..7afeba6e8 100644 --- a/libfreerdp-core/credssp.h +++ b/libfreerdp-core/credssp.h @@ -26,6 +26,7 @@ #include #include #include +#include #include #include "ntlmssp.h" diff --git a/libfreerdp-core/crypto.c b/libfreerdp-core/crypto.c index 5f2709440..d5a95cf31 100644 --- a/libfreerdp-core/crypto.c +++ b/libfreerdp-core/crypto.c @@ -26,12 +26,12 @@ CryptoSha1 crypto_sha1_init(void) return sha1; } -void crypto_sha1_update(CryptoSha1 sha1, uint8 * data, uint32 length) +void crypto_sha1_update(CryptoSha1 sha1, uint8* data, uint32 length) { SHA1_Update(&sha1->sha_ctx, data, length); } -void crypto_sha1_final(CryptoSha1 sha1, uint8 * out_data) +void crypto_sha1_final(CryptoSha1 sha1, uint8* out_data) { SHA1_Final(out_data, &sha1->sha_ctx); xfree(sha1); @@ -44,25 +44,25 @@ CryptoMd5 crypto_md5_init(void) return md5; } -void crypto_md5_update(CryptoMd5 md5, uint8 * data, uint32 length) +void crypto_md5_update(CryptoMd5 md5, uint8* data, uint32 length) { MD5_Update(&md5->md5_ctx, data, length); } -void crypto_md5_final(CryptoMd5 md5, uint8 * out_data) +void crypto_md5_final(CryptoMd5 md5, uint8* out_data) { MD5_Final(out_data, &md5->md5_ctx); xfree(md5); } -CryptoRc4 crypto_rc4_init(uint8 * key, uint32 length) +CryptoRc4 crypto_rc4_init(uint8* key, uint32 length) { CryptoRc4 rc4 = xmalloc(sizeof(*rc4)); RC4_set_key(&rc4->rc4_key, length, key); return rc4; } -void crypto_rc4(CryptoRc4 rc4, uint32 length, uint8 * in_data, uint8 * out_data) +void crypto_rc4(CryptoRc4 rc4, uint32 length, uint8* in_data, uint8* out_data) { RC4(&rc4->rc4_key, length, in_data, out_data); } @@ -72,7 +72,7 @@ void crypto_rc4_free(CryptoRc4 rc4) xfree(rc4); } -CryptoCert crypto_cert_read(uint8 * data, uint32 length) +CryptoCert crypto_cert_read(uint8* data, uint32 length) { CryptoCert cert = xmalloc(sizeof(*cert)); /* this will move the data pointer but we don't care, we don't use it again */ @@ -90,3 +90,44 @@ boolean crypto_cert_verify(CryptoCert server_cert, CryptoCert cacert) { return True; /* FIXME: do the actual verification */ } + +boolean crypto_cert_get_public_key(CryptoCert cert, DATABLOB* public_key) +{ + uint8* p; + int length; + boolean status = True; + EVP_PKEY* pkey = NULL; + + pkey = X509_get_pubkey(cert->px509); + + if (!pkey) + { + printf("crypto_cert_get_public_key: X509_get_pubkey() failed\n"); + status = False; + goto exit; + } + + length = i2d_PublicKey(pkey, NULL); + + if (length < 1) + { + printf("crypto_cert_get_public_key: i2d_PublicKey() failed\n"); + status = False; + goto exit; + } + + datablob_alloc(public_key, length); + p = (unsigned char*) public_key->data; + i2d_PublicKey(pkey, &p); + +exit: + if (pkey) + EVP_PKEY_free(pkey); + + return status; +} + +void crypto_nonce(uint8* nonce, int size) +{ + RAND_bytes((void*) nonce, size); +} diff --git a/libfreerdp-core/crypto.h b/libfreerdp-core/crypto.h index 734d876fc..fc1e9480a 100644 --- a/libfreerdp-core/crypto.h +++ b/libfreerdp-core/crypto.h @@ -36,6 +36,8 @@ #endif #include +#include +#include struct crypto_sha1_struct { @@ -57,24 +59,27 @@ struct crypto_cert_struct X509 * px509; }; -typedef struct crypto_sha1_struct * CryptoSha1; +typedef struct crypto_sha1_struct* CryptoSha1; CryptoSha1 crypto_sha1_init(void); -void crypto_sha1_update(CryptoSha1 sha1, uint8 * data, uint32 length); -void crypto_sha1_final(CryptoSha1 sha1, uint8 * out_data); +void crypto_sha1_update(CryptoSha1 sha1, uint8* data, uint32 length); +void crypto_sha1_final(CryptoSha1 sha1, uint8* out_data); -typedef struct crypto_md5_struct * CryptoMd5; +typedef struct crypto_md5_struct* CryptoMd5; CryptoMd5 crypto_md5_init(void); -void crypto_md5_update(CryptoMd5 md5, uint8 * data, uint32 length); -void crypto_md5_final(CryptoMd5 md5, uint8 * out_data); +void crypto_md5_update(CryptoMd5 md5, uint8* data, uint32 length); +void crypto_md5_final(CryptoMd5 md5, uint8* out_data); -typedef struct crypto_rc4_struct * CryptoRc4; -CryptoRc4 crypto_rc4_init(uint8 * key, uint32 length); -void crypto_rc4(CryptoRc4 rc4, uint32 length, uint8 * in_data, uint8 * out_data); +typedef struct crypto_rc4_struct* CryptoRc4; +CryptoRc4 crypto_rc4_init(uint8* key, uint32 length); +void crypto_rc4(CryptoRc4 rc4, uint32 length, uint8* in_data, uint8* out_data); void crypto_rc4_free(CryptoRc4 rc4); -typedef struct crypto_cert_struct * CryptoCert; -CryptoCert crypto_cert_read(uint8 * data, uint32 length); +typedef struct crypto_cert_struct* CryptoCert; +CryptoCert crypto_cert_read(uint8* data, uint32 length); void crypto_cert_free(CryptoCert cert); boolean crypto_cert_verify(CryptoCert server_cert, CryptoCert cacert); +boolean crypto_cert_get_public_key(CryptoCert cert, DATABLOB* public_key); + +void crypto_nonce(uint8* nonce, int size); #endif /* __CRYPTO_H */ diff --git a/libfreerdp-core/gcc.c b/libfreerdp-core/gcc.c index 96675aa2d..d71ac843a 100644 --- a/libfreerdp-core/gcc.c +++ b/libfreerdp-core/gcc.c @@ -177,13 +177,13 @@ gcc_write_client_core_data(STREAM* s, rdpSettings *settings) stream_write_uint32(s, settings->kbd_layout); /* keyboardLayout */ stream_write_uint32(s, 2600); /* clientBuild */ - stream_write_padding(s, 32); /* clientName */ + stream_write_zero(s, 32); /* clientName */ stream_write_uint32(s, settings->kbd_type); /* keyboardType */ stream_write_uint32(s, settings->kbd_subtype); /* keyboardSubType */ stream_write_uint32(s, settings->kbd_fn_keys); /* keyboardFunctionKey */ - stream_write_padding(s, 64); /* imeFileName */ + stream_write_zero(s, 64); /* imeFileName */ stream_write_uint16(s, RNS_UD_COLOR_8BPP); /* postBeta2ColorDepth */ stream_write_uint16(s, 1); /* clientProductID */ @@ -208,7 +208,7 @@ gcc_write_client_core_data(STREAM* s, rdpSettings *settings) earlyCapabilityFlags |= RNS_UD_CS_WANT_32BPP_SESSION; stream_write_uint16(s, earlyCapabilityFlags); /* earlyCapabilityFlags */ - stream_write_padding(s, 64); /* clientDigProductId (64 bytes) */ + stream_write_zero(s, 64); /* clientDigProductId (64 bytes) */ stream_write_uint8(s, connectionType); /* connectionType */ stream_write_uint8(s, 0); /* pad1octet */ diff --git a/libfreerdp-core/ntlmssp.c b/libfreerdp-core/ntlmssp.c index f800953cd..307294237 100644 --- a/libfreerdp-core/ntlmssp.c +++ b/libfreerdp-core/ntlmssp.c @@ -535,19 +535,19 @@ void ntlmssp_compute_ntlm_v2_response(NTLMSSP *ntlmssp) #ifdef WITH_DEBUG_NLA printf("Password (length = %d)\n", ntlmssp->password.length); - hexdump(ntlmssp->password.data, ntlmssp->password.length); + freerdp_hexdump(ntlmssp->password.data, ntlmssp->password.length); printf("\n"); printf("Username (length = %d)\n", ntlmssp->username.length); - hexdump(ntlmssp->username.data, ntlmssp->username.length); + freerdp_hexdump(ntlmssp->username.data, ntlmssp->username.length); printf("\n"); printf("Domain (length = %d)\n", ntlmssp->domain.length); - hexdump(ntlmssp->domain.data, ntlmssp->domain.length); + freerdp_hexdump(ntlmssp->domain.data, ntlmssp->domain.length); printf("\n"); printf("NTOWFv2, NTLMv2 Hash\n"); - hexdump(ntlm_v2_hash, 16); + freerdp_hexdump(ntlm_v2_hash, 16); printf("\n"); #endif @@ -563,7 +563,7 @@ void ntlmssp_compute_ntlm_v2_response(NTLMSSP *ntlmssp) #ifdef WITH_DEBUG_NLA printf("NTLMv2 Response Temp Blob\n"); - hexdump(ntlm_v2_temp.data, ntlm_v2_temp.length); + freerdp_hexdump(ntlm_v2_temp.data, ntlm_v2_temp.length); printf("\n"); #endif @@ -607,7 +607,7 @@ void ntlmssp_input_negotiate_flags(STREAM* s, uint32 *flags) * Reverse order and then input in Big Endian */ - in_uint32_be(s, negotiateFlags); + stream_read_uint32_be(s, negotiateFlags); p = (uint8*) &negotiateFlags; tmp = p[0]; @@ -709,7 +709,7 @@ static void ntlmssp_print_negotiate_flags(uint32 flags) static void ntlmssp_output_restriction_encoding(NTLMSSP *ntlmssp) { AV_PAIR *restrictions = &ntlmssp->av_pairs->Restrictions; - STREAM* s = stream_new_empty(); + STREAM* s = stream_new(0); uint8 machineID[32] = "\x3A\x15\x8E\xA6\x75\x82\xD8\xF7\x3E\x06\xFA\x7A\xB4\xDF\xFD\x43" @@ -722,15 +722,15 @@ static void ntlmssp_output_restriction_encoding(NTLMSSP *ntlmssp) s->size = restrictions->length; s->p = s->data; - out_uint32_le(s, 48); /* Size */ - out_uint8s(s, 4); /* Z4 (set to zero) */ + stream_write_uint32(s, 48); /* Size */ + stream_write_zero(s, 4); /* Z4 (set to zero) */ /* IntegrityLevel (bit 31 set to 1) */ - out_uint8(s, 1); - out_uint8s(s, 3); + stream_write_uint8(s, 1); + stream_write_zero(s, 3); - out_uint32_le(s, 0x20000000); /* SubjectIntegrityLevel */ - out_uint8p(s, machineID, 32); /* MachineID */ + stream_write_uint32(s, 0x20000000); /* SubjectIntegrityLevel */ + stream_write(s, machineID, 32); /* MachineID */ xfree(s); } @@ -753,7 +753,7 @@ void ntlmssp_populate_av_pairs(NTLMSSP *ntlmssp) /* Restriction_Encoding */ ntlmssp_output_restriction_encoding(ntlmssp); - s = stream_new_empty(); + s = stream_new(0); s->data = xmalloc(ntlmssp->target_info.length + 512); s->p = s->data; @@ -782,19 +782,19 @@ void ntlmssp_input_av_pairs(NTLMSSP *ntlmssp, STREAM* s) do { value = NULL; - in_uint16_le(s, AvId); - in_uint16_le(s, AvLen); + stream_read_uint16(s, AvId); + stream_read_uint16(s, AvLen); if (AvLen > 0) { if (AvId != MsvAvFlags) { value = xmalloc(AvLen); - in_uint8a(s, value, AvLen); + stream_read(s, value, AvLen); } else { - in_uint32_le(s, av_pairs->Flags); + stream_read_uint32(s, av_pairs->Flags); } } @@ -876,84 +876,82 @@ void ntlmssp_output_av_pairs(NTLMSSP *ntlmssp, STREAM* s) if (av_pairs->NbDomainName.length > 0) { - out_uint16_le(s, MsvAvNbDomainName); /* AvId */ - out_uint16_le(s, av_pairs->NbDomainName.length); /* AvLen */ - out_uint8a(s, av_pairs->NbDomainName.value, av_pairs->NbDomainName.length); /* Value */ + stream_write_uint16(s, MsvAvNbDomainName); /* AvId */ + stream_write_uint16(s, av_pairs->NbDomainName.length); /* AvLen */ + stream_write(s, av_pairs->NbDomainName.value, av_pairs->NbDomainName.length); /* Value */ } if (av_pairs->NbComputerName.length > 0) { - out_uint16_le(s, MsvAvNbComputerName); /* AvId */ - out_uint16_le(s, av_pairs->NbComputerName.length); /* AvLen */ - out_uint8a(s, av_pairs->NbComputerName.value, av_pairs->NbComputerName.length); /* Value */ + stream_write_uint16(s, MsvAvNbComputerName); /* AvId */ + stream_write_uint16(s, av_pairs->NbComputerName.length); /* AvLen */ + stream_write(s, av_pairs->NbComputerName.value, av_pairs->NbComputerName.length); /* Value */ } if (av_pairs->DnsDomainName.length > 0) { - out_uint16_le(s, MsvAvDnsDomainName); /* AvId */ - out_uint16_le(s, av_pairs->DnsDomainName.length); /* AvLen */ - out_uint8a(s, av_pairs->DnsDomainName.value, av_pairs->DnsDomainName.length); /* Value */ + stream_write_uint16(s, MsvAvDnsDomainName); /* AvId */ + stream_write_uint16(s, av_pairs->DnsDomainName.length); /* AvLen */ + stream_write(s, av_pairs->DnsDomainName.value, av_pairs->DnsDomainName.length); /* Value */ } if (av_pairs->DnsComputerName.length > 0) { - out_uint16_le(s, MsvAvDnsComputerName); /* AvId */ - out_uint16_le(s, av_pairs->DnsComputerName.length); /* AvLen */ - out_uint8a(s, av_pairs->DnsComputerName.value, av_pairs->DnsComputerName.length); /* Value */ + stream_write_uint16(s, MsvAvDnsComputerName); /* AvId */ + stream_write_uint16(s, av_pairs->DnsComputerName.length); /* AvLen */ + stream_write(s, av_pairs->DnsComputerName.value, av_pairs->DnsComputerName.length); /* Value */ } if (av_pairs->DnsTreeName.length > 0) { - out_uint16_le(s, MsvAvDnsTreeName); /* AvId */ - out_uint16_le(s, av_pairs->DnsTreeName.length); /* AvLen */ - out_uint8a(s, av_pairs->DnsTreeName.value, av_pairs->DnsTreeName.length); /* Value */ + stream_write_uint16(s, MsvAvDnsTreeName); /* AvId */ + stream_write_uint16(s, av_pairs->DnsTreeName.length); /* AvLen */ + stream_write(s, av_pairs->DnsTreeName.value, av_pairs->DnsTreeName.length); /* Value */ } if (av_pairs->Timestamp.length > 0) { - out_uint16_le(s, MsvAvTimestamp); /* AvId */ - out_uint16_le(s, av_pairs->Timestamp.length); /* AvLen */ - out_uint8a(s, av_pairs->Timestamp.value, av_pairs->Timestamp.length); /* Value */ + stream_write_uint16(s, MsvAvTimestamp); /* AvId */ + stream_write_uint16(s, av_pairs->Timestamp.length); /* AvLen */ + stream_write(s, av_pairs->Timestamp.value, av_pairs->Timestamp.length); /* Value */ } if (av_pairs->Flags > 0) { - out_uint16_le(s, MsvAvFlags); /* AvId */ - out_uint16_le(s, 4); /* AvLen */ - out_uint32_le(s, av_pairs->Flags); /* Value */ + stream_write_uint16(s, MsvAvFlags); /* AvId */ + stream_write_uint16(s, 4); /* AvLen */ + stream_write_uint32(s, av_pairs->Flags); /* Value */ } if (av_pairs->Restrictions.length > 0) { - out_uint16_le(s, MsvAvRestrictions); /* AvId */ - out_uint16_le(s, av_pairs->Restrictions.length); /* AvLen */ - out_uint8a(s, av_pairs->Restrictions.value, av_pairs->Restrictions.length); /* Value */ + stream_write_uint16(s, MsvAvRestrictions); /* AvId */ + stream_write_uint16(s, av_pairs->Restrictions.length); /* AvLen */ + stream_write(s, av_pairs->Restrictions.value, av_pairs->Restrictions.length); /* Value */ } if (av_pairs->ChannelBindings.length > 0) { - out_uint16_le(s, MsvChannelBindings); /* AvId */ - out_uint16_le(s, av_pairs->ChannelBindings.length); /* AvLen */ - out_uint8a(s, av_pairs->ChannelBindings.value, av_pairs->ChannelBindings.length); /* Value */ + stream_write_uint16(s, MsvChannelBindings); /* AvId */ + stream_write_uint16(s, av_pairs->ChannelBindings.length); /* AvLen */ + stream_write(s, av_pairs->ChannelBindings.value, av_pairs->ChannelBindings.length); /* Value */ } if (av_pairs->TargetName.length > 0) { - out_uint16_le(s, MsvAvTargetName); /* AvId */ - out_uint16_le(s, av_pairs->TargetName.length); /* AvLen */ - out_uint8a(s, av_pairs->TargetName.value, av_pairs->TargetName.length); /* Value */ + stream_write_uint16(s, MsvAvTargetName); /* AvId */ + stream_write_uint16(s, av_pairs->TargetName.length); /* AvLen */ + stream_write(s, av_pairs->TargetName.value, av_pairs->TargetName.length); /* Value */ } /* This endicates the end of the AV_PAIR array */ - out_uint16_le(s, MsvAvEOL); /* AvId */ - out_uint16_le(s, 0); /* AvLen */ + stream_write_uint16(s, MsvAvEOL); /* AvId */ + stream_write_uint16(s, 0); /* AvLen */ if (ntlmssp->ntlm_v2) { - out_uint8s(s, 8); + stream_write_zero(s, 8); } - - s_mark_end(s); } /** @@ -1003,11 +1001,11 @@ static void ntlmssp_output_version(STREAM* s) { /* The following version information was observed with Windows 7 */ - out_uint8(s, WINDOWS_MAJOR_VERSION_6); /* ProductMajorVersion (1 byte) */ - out_uint8(s, WINDOWS_MINOR_VERSION_1); /* ProductMinorVersion (1 byte) */ - out_uint16_le(s, 7600); /* ProductBuild (2 bytes) */ - out_uint8s(s, 3); /* Reserved (3 bytes) */ - out_uint8(s, NTLMSSP_REVISION_W2K3); /* NTLMRevisionCurrent (1 byte) */ + stream_write_uint8(s, WINDOWS_MAJOR_VERSION_6); /* ProductMajorVersion (1 byte) */ + stream_write_uint8(s, WINDOWS_MINOR_VERSION_1); /* ProductMinorVersion (1 byte) */ + stream_write_uint16(s, 7600); /* ProductBuild (2 bytes) */ + stream_write_zero(s, 3); /* Reserved (3 bytes) */ + stream_write_uint8(s, NTLMSSP_REVISION_W2K3); /* NTLMRevisionCurrent (1 byte) */ } void ntlmssp_compute_message_integrity_check(NTLMSSP *ntlmssp) @@ -1135,8 +1133,8 @@ void ntlmssp_send_negotiate_message(NTLMSSP *ntlmssp, STREAM* s) int length; uint32 negotiateFlags = 0; - out_uint8a(s, ntlm_signature, 8); /* Signature (8 bytes) */ - out_uint32_le(s, 1); /* MessageType */ + stream_write(s, ntlm_signature, 8); /* Signature (8 bytes) */ + stream_write_uint32(s, 1); /* MessageType */ if (ntlmssp->ntlm_v2) { @@ -1174,16 +1172,16 @@ void ntlmssp_send_negotiate_message(NTLMSSP *ntlmssp, STREAM* s) /* only set if NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED is set */ /* DomainNameFields (8 bytes) */ - out_uint16_le(s, 0); /* DomainNameLen */ - out_uint16_le(s, 0); /* DomainNameMaxLen */ - out_uint32_le(s, 0); /* DomainNameBufferOffset */ + stream_write_uint16(s, 0); /* DomainNameLen */ + stream_write_uint16(s, 0); /* DomainNameMaxLen */ + stream_write_uint32(s, 0); /* DomainNameBufferOffset */ /* only set if NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED is set */ /* WorkstationFields (8 bytes) */ - out_uint16_le(s, 0); /* WorkstationLen */ - out_uint16_le(s, 0); /* WorkstationMaxLen */ - out_uint32_le(s, 0); /* WorkstationBufferOffset */ + stream_write_uint16(s, 0); /* WorkstationLen */ + stream_write_uint16(s, 0); /* WorkstationMaxLen */ + stream_write_uint32(s, 0); /* WorkstationBufferOffset */ if (negotiateFlags & NTLMSSP_NEGOTIATE_VERSION) { @@ -1191,15 +1189,13 @@ void ntlmssp_send_negotiate_message(NTLMSSP *ntlmssp, STREAM* s) ntlmssp_output_version(s); } - s_mark_end(s); - length = s->p - s->data; datablob_alloc(&ntlmssp->negotiate_message, length); memcpy(ntlmssp->negotiate_message.data, s->data, length); #ifdef WITH_DEBUG_NLA printf("NEGOTIATE_MESSAGE (length = %d)\n", length); - hexdump(s->data, length); + freerdp_hexdump(s->data, length); printf("\n"); #endif @@ -1229,9 +1225,9 @@ void ntlmssp_recv_challenge_message(NTLMSSP *ntlmssp, STREAM* s) start_offset = s->p - 12; /* TargetNameFields (8 bytes) */ - in_uint16_le(s, targetNameLen); /* TargetNameLen (2 bytes) */ - in_uint16_le(s, targetNameMaxLen); /* TargetNameMaxLen (2 bytes) */ - in_uint32_le(s, targetNameBufferOffset); /* TargetNameBufferOffset (4 bytes) */ + stream_read_uint16(s, targetNameLen); /* TargetNameLen (2 bytes) */ + stream_read_uint16(s, targetNameMaxLen); /* TargetNameMaxLen (2 bytes) */ + stream_read_uint32(s, targetNameBufferOffset); /* TargetNameBufferOffset (4 bytes) */ ntlmssp_input_negotiate_flags(s, &(ntlmssp->negotiate_flags)); /* NegotiateFlags (4 bytes) */ @@ -1239,19 +1235,19 @@ void ntlmssp_recv_challenge_message(NTLMSSP *ntlmssp, STREAM* s) ntlmssp_print_negotiate_flags(ntlmssp->negotiate_flags); #endif - in_uint8a(s, ntlmssp->server_challenge, 8); /* ServerChallenge (8 bytes) */ - in_uint8s(s, 8); /* Reserved (8 bytes), should be ignored */ + stream_read(s, ntlmssp->server_challenge, 8); /* ServerChallenge (8 bytes) */ + stream_seek(s, 8); /* Reserved (8 bytes), should be ignored */ /* TargetInfoFields (8 bytes) */ - in_uint16_le(s, targetInfoLen); /* TargetInfoLen (2 bytes) */ - in_uint16_le(s, targetInfoMaxLen); /* TargetInfoMaxLen (2 bytes) */ - in_uint32_le(s, targetInfoBufferOffset); /* TargetInfoBufferOffset (4 bytes) */ + stream_read_uint16(s, targetInfoLen); /* TargetInfoLen (2 bytes) */ + stream_read_uint16(s, targetInfoMaxLen); /* TargetInfoMaxLen (2 bytes) */ + stream_read_uint32(s, targetInfoBufferOffset); /* TargetInfoBufferOffset (4 bytes) */ /* only present if NTLMSSP_NEGOTIATE_VERSION is set */ if (ntlmssp->negotiate_flags & NTLMSSP_NEGOTIATE_VERSION) { - in_uint8s(s, 8); /* Version (8 bytes), can be ignored */ + stream_seek(s, 8); /* Version (8 bytes), can be ignored */ } /* Payload (variable) */ @@ -1265,7 +1261,7 @@ void ntlmssp_recv_challenge_message(NTLMSSP *ntlmssp, STREAM* s) #ifdef WITH_DEBUG_NLA printf("targetName (length = %d, offset = %d)\n", targetNameLen, targetNameBufferOffset); - hexdump(ntlmssp->target_name.data, ntlmssp->target_name.length); + freerdp_hexdump(ntlmssp->target_name.data, ntlmssp->target_name.length); printf("\n"); #endif } @@ -1278,7 +1274,7 @@ void ntlmssp_recv_challenge_message(NTLMSSP *ntlmssp, STREAM* s) #ifdef WITH_DEBUG_NLA printf("targetInfo (length = %d, offset = %d)\n", targetInfoLen, targetInfoBufferOffset); - hexdump(ntlmssp->target_info.data, ntlmssp->target_info.length); + freerdp_hexdump(ntlmssp->target_info.data, ntlmssp->target_info.length); printf("\n"); #endif @@ -1296,7 +1292,7 @@ void ntlmssp_recv_challenge_message(NTLMSSP *ntlmssp, STREAM* s) #ifdef WITH_DEBUG_NLA printf("CHALLENGE_MESSAGE (length = %d)\n", length); - hexdump(start_offset, length); + freerdp_hexdump(start_offset, length); printf("\n"); #endif @@ -1306,7 +1302,7 @@ void ntlmssp_recv_challenge_message(NTLMSSP *ntlmssp, STREAM* s) #ifdef WITH_DEBUG_NLA printf("targetInfo (populated) (length = %d)\n", ntlmssp->target_info.length); - hexdump(ntlmssp->target_info.data, ntlmssp->target_info.length); + freerdp_hexdump(ntlmssp->target_info.data, ntlmssp->target_info.length); printf("\n"); #endif @@ -1341,39 +1337,39 @@ void ntlmssp_recv_challenge_message(NTLMSSP *ntlmssp, STREAM* s) #ifdef WITH_DEBUG_NLA printf("ClientChallenge\n"); - hexdump(ntlmssp->client_challenge, 8); + freerdp_hexdump(ntlmssp->client_challenge, 8); printf("\n"); printf("ServerChallenge\n"); - hexdump(ntlmssp->server_challenge, 8); + freerdp_hexdump(ntlmssp->server_challenge, 8); printf("\n"); printf("SessionBaseKey\n"); - hexdump(ntlmssp->session_base_key, 16); + freerdp_hexdump(ntlmssp->session_base_key, 16); printf("\n"); printf("KeyExchangeKey\n"); - hexdump(ntlmssp->key_exchange_key, 16); + freerdp_hexdump(ntlmssp->key_exchange_key, 16); printf("\n"); printf("ExportedSessionKey\n"); - hexdump(ntlmssp->exported_session_key, 16); + freerdp_hexdump(ntlmssp->exported_session_key, 16); printf("\n"); printf("RandomSessionKey\n"); - hexdump(ntlmssp->random_session_key, 16); + freerdp_hexdump(ntlmssp->random_session_key, 16); printf("\n"); printf("ClientSignKey\n"); - hexdump(ntlmssp->client_signing_key, 16); + freerdp_hexdump(ntlmssp->client_signing_key, 16); printf("\n"); printf("ClientSealingKey\n"); - hexdump(ntlmssp->client_sealing_key, 16); + freerdp_hexdump(ntlmssp->client_sealing_key, 16); printf("\n"); printf("Timestamp\n"); - hexdump(ntlmssp->timestamp, 8); + freerdp_hexdump(ntlmssp->timestamp, 8); printf("\n"); #endif @@ -1471,42 +1467,42 @@ void ntlmssp_send_authenticate_message(NTLMSSP *ntlmssp, STREAM* s) NtChallengeResponseBufferOffset = LmChallengeResponseBufferOffset + LmChallengeResponseLen; EncryptedRandomSessionKeyBufferOffset = NtChallengeResponseBufferOffset + NtChallengeResponseLen; - out_uint8a(s, ntlm_signature, 8); /* Signature (8 bytes) */ - out_uint32_le(s, 3); /* MessageType */ + stream_write(s, ntlm_signature, 8); /* Signature (8 bytes) */ + stream_write_uint32(s, 3); /* MessageType */ /* LmChallengeResponseFields (8 bytes) */ - out_uint16_le(s, LmChallengeResponseLen); /* LmChallengeResponseLen */ - out_uint16_le(s, LmChallengeResponseLen); /* LmChallengeResponseMaxLen */ - out_uint32_le(s, LmChallengeResponseBufferOffset); /* LmChallengeResponseBufferOffset */ + stream_write_uint16(s, LmChallengeResponseLen); /* LmChallengeResponseLen */ + stream_write_uint16(s, LmChallengeResponseLen); /* LmChallengeResponseMaxLen */ + stream_write_uint32(s, LmChallengeResponseBufferOffset); /* LmChallengeResponseBufferOffset */ /* NtChallengeResponseFields (8 bytes) */ - out_uint16_le(s, NtChallengeResponseLen); /* NtChallengeResponseLen */ - out_uint16_le(s, NtChallengeResponseLen); /* NtChallengeResponseMaxLen */ - out_uint32_le(s, NtChallengeResponseBufferOffset); /* NtChallengeResponseBufferOffset */ + stream_write_uint16(s, NtChallengeResponseLen); /* NtChallengeResponseLen */ + stream_write_uint16(s, NtChallengeResponseLen); /* NtChallengeResponseMaxLen */ + stream_write_uint32(s, NtChallengeResponseBufferOffset); /* NtChallengeResponseBufferOffset */ /* only set if NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED is set */ /* DomainNameFields (8 bytes) */ - out_uint16_le(s, DomainNameLen); /* DomainNameLen */ - out_uint16_le(s, DomainNameLen); /* DomainNameMaxLen */ - out_uint32_le(s, DomainNameBufferOffset); /* DomainNameBufferOffset */ + stream_write_uint16(s, DomainNameLen); /* DomainNameLen */ + stream_write_uint16(s, DomainNameLen); /* DomainNameMaxLen */ + stream_write_uint32(s, DomainNameBufferOffset); /* DomainNameBufferOffset */ /* UserNameFields (8 bytes) */ - out_uint16_le(s, UserNameLen); /* UserNameLen */ - out_uint16_le(s, UserNameLen); /* UserNameMaxLen */ - out_uint32_le(s, UserNameBufferOffset); /* UserNameBufferOffset */ + stream_write_uint16(s, UserNameLen); /* UserNameLen */ + stream_write_uint16(s, UserNameLen); /* UserNameMaxLen */ + stream_write_uint32(s, UserNameBufferOffset); /* UserNameBufferOffset */ /* only set if NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED is set */ /* WorkstationFields (8 bytes) */ - out_uint16_le(s, WorkstationLen); /* WorkstationLen */ - out_uint16_le(s, WorkstationLen); /* WorkstationMaxLen */ - out_uint32_le(s, WorkstationBufferOffset); /* WorkstationBufferOffset */ + stream_write_uint16(s, WorkstationLen); /* WorkstationLen */ + stream_write_uint16(s, WorkstationLen); /* WorkstationMaxLen */ + stream_write_uint32(s, WorkstationBufferOffset); /* WorkstationBufferOffset */ /* EncryptedRandomSessionKeyFields (8 bytes) */ - out_uint16_le(s, EncryptedRandomSessionKeyLen); /* EncryptedRandomSessionKeyLen */ - out_uint16_le(s, EncryptedRandomSessionKeyLen); /* EncryptedRandomSessionKeyMaxLen */ - out_uint32_le(s, EncryptedRandomSessionKeyBufferOffset); /* EncryptedRandomSessionKeyBufferOffset */ + stream_write_uint16(s, EncryptedRandomSessionKeyLen); /* EncryptedRandomSessionKeyLen */ + stream_write_uint16(s, EncryptedRandomSessionKeyLen); /* EncryptedRandomSessionKeyMaxLen */ + stream_write_uint32(s, EncryptedRandomSessionKeyBufferOffset); /* EncryptedRandomSessionKeyBufferOffset */ ntlmssp_output_negotiate_flags(s, negotiateFlags); /* NegotiateFlags (4 bytes) */ @@ -1521,65 +1517,64 @@ void ntlmssp_send_authenticate_message(NTLMSSP *ntlmssp, STREAM* s) /* Message Integrity Check */ mic_offset = s->p; - out_uint8s(s, 16); + stream_write_zero(s, 16); } /* DomainName */ if (DomainNameLen > 0) { - out_uint8p(s, DomainNameBuffer, DomainNameLen); + stream_write(s, DomainNameBuffer, DomainNameLen); #ifdef WITH_DEBUG_NLA printf("DomainName (length = %d, offset = %d)\n", DomainNameLen, DomainNameBufferOffset); - hexdump(DomainNameBuffer, DomainNameLen); + freerdp_hexdump(DomainNameBuffer, DomainNameLen); printf("\n"); #endif } /* UserName */ - out_uint8p(s, UserNameBuffer, UserNameLen); + stream_write(s, UserNameBuffer, UserNameLen); #ifdef WITH_DEBUG_NLA printf("UserName (length = %d, offset = %d)\n", UserNameLen, UserNameBufferOffset); - hexdump(UserNameBuffer, UserNameLen); + freerdp_hexdump(UserNameBuffer, UserNameLen); printf("\n"); #endif /* Workstation */ if (WorkstationLen > 0) { - out_uint8p(s, WorkstationBuffer, WorkstationLen); + stream_write(s, WorkstationBuffer, WorkstationLen); #ifdef WITH_DEBUG_NLA printf("Workstation (length = %d, offset = %d)\n", WorkstationLen, WorkstationBufferOffset); - hexdump(WorkstationBuffer, WorkstationLen); + freerdp_hexdump(WorkstationBuffer, WorkstationLen); printf("\n"); #endif } /* LmChallengeResponse */ - out_uint8p(s, ntlmssp->lm_challenge_response.data, LmChallengeResponseLen); + stream_write(s, ntlmssp->lm_challenge_response.data, LmChallengeResponseLen); #ifdef WITH_DEBUG_NLA printf("LmChallengeResponse (length = %d, offset = %d)\n", LmChallengeResponseLen, LmChallengeResponseBufferOffset); - hexdump(ntlmssp->lm_challenge_response.data, LmChallengeResponseLen); + freerdp_hexdump(ntlmssp->lm_challenge_response.data, LmChallengeResponseLen); printf("\n"); #endif /* NtChallengeResponse */ - out_uint8p(s, ntlmssp->nt_challenge_response.data, NtChallengeResponseLen); + stream_write(s, ntlmssp->nt_challenge_response.data, NtChallengeResponseLen); #ifdef WITH_DEBUG_NLA printf("NtChallengeResponse (length = %d, offset = %d)\n", NtChallengeResponseLen, NtChallengeResponseBufferOffset); - hexdump(ntlmssp->nt_challenge_response.data, NtChallengeResponseLen); + freerdp_hexdump(ntlmssp->nt_challenge_response.data, NtChallengeResponseLen); printf("\n"); #endif /* EncryptedRandomSessionKey */ - out_uint8p(s, EncryptedRandomSessionKeyBuffer, EncryptedRandomSessionKeyLen); - s_mark_end(s); + stream_write(s, EncryptedRandomSessionKeyBuffer, EncryptedRandomSessionKeyLen); #ifdef WITH_DEBUG_NLA printf("EncryptedRandomSessionKey (length = %d, offset = %d)\n", EncryptedRandomSessionKeyLen, EncryptedRandomSessionKeyBufferOffset); - hexdump(EncryptedRandomSessionKeyBuffer, EncryptedRandomSessionKeyLen); + freerdp_hexdump(EncryptedRandomSessionKeyBuffer, EncryptedRandomSessionKeyLen); printf("\n"); #endif @@ -1593,12 +1588,12 @@ void ntlmssp_send_authenticate_message(NTLMSSP *ntlmssp, STREAM* s) ntlmssp_compute_message_integrity_check(ntlmssp); s->p = mic_offset; - out_uint8p(s, ntlmssp->message_integrity_check, 16); + stream_write(s, ntlmssp->message_integrity_check, 16); } #ifdef WITH_DEBUG_NLA printf("AUTHENTICATE_MESSAGE (length = %d)\n", length); - hexdump(s->data, length); + freerdp_hexdump(s->data, length); printf("\n"); #endif @@ -1637,8 +1632,8 @@ int ntlmssp_recv(NTLMSSP *ntlmssp, STREAM* s) char signature[8]; /* Signature, "NTLMSSP" */ uint32 messageType; /* MessageType */ - in_uint8a(s, signature, 8); - in_uint32_le(s, messageType); + stream_read(s, signature, 8); + stream_read_uint32(s, messageType); if (messageType == 2 && ntlmssp->state == NTLMSSP_STATE_CHALLENGE) ntlmssp_recv_challenge_message(ntlmssp, s); diff --git a/libfreerdp-gdi/color.c b/libfreerdp-gdi/color.c index 23d098af2..310490ed6 100644 --- a/libfreerdp-gdi/color.c +++ b/libfreerdp-gdi/color.c @@ -649,6 +649,7 @@ uint8* gdi_mono_image_convert(uint8* srcData, int width, int height, int srcBpp, default: GetRGB32(redBg, greenBg, blueBg, bgcolor); GetRGB32(redFg, greenFg, blueFg, fgcolor); + break; } if(dstBpp == 16) diff --git a/libfreerdp-utils/stream.c b/libfreerdp-utils/stream.c index a5bc1736d..a13cad4b2 100644 --- a/libfreerdp-utils/stream.c +++ b/libfreerdp-utils/stream.c @@ -25,17 +25,26 @@ #include STREAM * -stream_new(int capacity) +stream_new(int size) { STREAM * stream; stream = (STREAM *) xmalloc(sizeof(STREAM)); + if (stream != NULL) { - capacity = capacity > 0 ? capacity : 0x400; - stream->data = (uint8 *) xmalloc(capacity); - stream->p = stream->data; - stream->size = capacity; + if (size != 0) + { + size = size > 0 ? size : 0x400; + stream->data = (uint8 *) xmalloc(size); + stream->p = stream->data; + stream->size = size; + } + else + { + /* empty stream */ + memset(stream, 0, sizeof(STREAM)); + } } return stream;