void test_license_generate_keys(void)
{
STREAM _s, *s;
s = &_s;
memcpy(license->client_random, client_random, sizeof(client_random));
memcpy(license->server_random, test_server_random, sizeof(test_server_random));
memcpy(license->premaster_secret, premaster_secret, sizeof(premaster_secret));
memcpy(license->certificate->cert_info.exponent, test_exponent, sizeof(test_exponent));
memcpy(license->certificate->cert_info.modulus.data, test_modulus, sizeof(test_modulus));
license->certificate->cert_info.modulus.length = sizeof(test_modulus);
license_generate_keys(license);
license_encrypt_premaster_secret(license);
s->data = license->master_secret;
s->p = s->data + sizeof(test_master_secret);
ASSERT_STREAM(s, test_master_secret, sizeof(test_master_secret));
s->data = license->session_key_blob;
s->p = s->data + sizeof(test_session_key_blob);
ASSERT_STREAM(s, test_session_key_blob, sizeof(test_session_key_blob));
s->data = license->mac_salt_key;
s->p = s->data + sizeof(test_mac_salt_key);
ASSERT_STREAM(s, test_mac_salt_key, sizeof(test_mac_salt_key));
s->data = license->licensing_encryption_key;
s->p = s->data + sizeof(test_licensing_encryption_key);
ASSERT_STREAM(s, test_licensing_encryption_key, sizeof(test_licensing_encryption_key));
s->data = license->encrypted_premaster_secret->data;
s->p = s->data + sizeof(test_encrypted_premaster_secret);
ASSERT_STREAM(s, test_encrypted_premaster_secret, sizeof(test_encrypted_premaster_secret));
}
void test_ber_write_length(void)
{
STREAM *s1, *s2;
s1 = stream_new(sizeof(ber_length_expected_1));
s2 = stream_new(sizeof(ber_length_expected_2));
ber_write_length(s1, 64);
ASSERT_STREAM(s1, (uint8*) ber_length_expected_1, sizeof(ber_length_expected_1));
ber_write_length(s2, 404);
ASSERT_STREAM(s2, (uint8*) ber_length_expected_2, sizeof(ber_length_expected_2));
stream_free(s1);
stream_free(s2);
}
void test_ber_write_universal_tag(void)
{
STREAM* s;
s = stream_new(sizeof(ber_universal_tag_expected));
ber_write_universal_tag(s, 1, false);
ASSERT_STREAM(s, (uint8*) ber_universal_tag_expected, sizeof(ber_universal_tag_expected));
stream_free(s);
}
void test_ber_write_application_tag(void)
{
STREAM* s;
s = stream_new(sizeof(ber_application_tag_expected));
ber_write_application_tag(s, 101, 404);
ASSERT_STREAM(s, (uint8*) ber_application_tag_expected, sizeof(ber_application_tag_expected));
stream_free(s);
}
void test_gcc_write_client_cluster_data(void)
{
wStream* s;
rdpSettings* settings;
s = stream_new(12);
settings = freerdp_settings_new(NULL);
gcc_write_client_cluster_data(s, settings);
ASSERT_STREAM(s, (BYTE*) gcc_client_cluster_data_expected, sizeof(gcc_client_cluster_data_expected));
}
void test_gcc_write_client_cluster_data(void)
{
STREAM* s;
rdpSettings* settings;
s = stream_new(12);
settings = settings_new();
gcc_write_client_cluster_data(s, settings);
ASSERT_STREAM(s, (uint8*) gcc_client_cluster_data_expected, sizeof(gcc_client_cluster_data_expected));
}
void test_gcc_write_conference_create_request(void)
{
STREAM* s;
STREAM user_data;
user_data.data = gcc_user_data;
user_data.size = sizeof(gcc_user_data);
user_data.p = user_data.data + user_data.size;
s = stream_new(sizeof(gcc_conference_create_request_expected));
gcc_write_conference_create_request(s, &user_data);
ASSERT_STREAM(s, (uint8*) gcc_conference_create_request_expected, sizeof(gcc_conference_create_request_expected));
}
void test_license_encrypt_premaster_secret(void)
{
STREAM _s, *s;
s = &_s;
memcpy(license->premaster_secret, premaster_secret, sizeof(premaster_secret));
memcpy(license->certificate->cert_info.exponent, test_exponent, sizeof(test_exponent));
memcpy(license->certificate->cert_info.modulus.data, test_modulus, sizeof(test_modulus));
license->certificate->cert_info.modulus.length = sizeof(test_modulus);
s->data = license->encrypted_premaster_secret->data;
s->p = s->data + sizeof(test_encrypted_premaster_secret);
ASSERT_STREAM(s, test_encrypted_premaster_secret, sizeof(test_encrypted_premaster_secret));
}
void test_gcc_write_conference_create_request(void)
{
wStream* s;
wStream user_data;
user_data.buffer = gcc_user_data;
user_data.capacity = sizeof(gcc_user_data);
user_data.pointer = user_data.buffer + user_data.capacity;
s = stream_new(sizeof(gcc_conference_create_request_expected));
gcc_write_conference_create_request(s, &user_data);
ASSERT_STREAM(s, (BYTE*) gcc_conference_create_request_expected, sizeof(gcc_conference_create_request_expected));
}
void test_mcs_write_connect_initial(void)
{
STREAM* s;
rdpMcs* mcs;
STREAM* user_data;
mcs = mcs_new((rdpTransport*) NULL);
user_data = stream_new(0);
user_data->data = gcc_CCrq;
user_data->p = user_data->data + sizeof(gcc_CCrq);
s = stream_new(512);
mcs_write_connect_initial(s, mcs, user_data);
ASSERT_STREAM(s, (uint8*) mcs_connect_initial_expected, sizeof(mcs_connect_initial_expected));
}
void test_gcc_write_client_security_data(void)
{
STREAM* s;
rdpSettings* settings;
s = stream_new(12);
settings = settings_new();
settings->encryption_method =
ENCRYPTION_METHOD_40BIT |
ENCRYPTION_METHOD_56BIT |
ENCRYPTION_METHOD_128BIT |
ENCRYPTION_METHOD_FIPS;
gcc_write_client_security_data(s, settings);
ASSERT_STREAM(s, (uint8*) gcc_client_security_data_expected, sizeof(gcc_client_security_data_expected));
}
void test_mcs_write_connect_initial(void)
{
wStream* s;
rdpMcs* mcs;
wStream _user_data, *user_data;
mcs = mcs_new((rdpTransport*) NULL);
user_data = &_user_data;
user_data->buffer = gcc_CCrq;
user_data->pointer = user_data->buffer + sizeof(gcc_CCrq);
s = stream_new(512);
mcs_write_connect_initial(s, mcs, user_data);
ASSERT_STREAM(s, (BYTE*) mcs_connect_initial_expected, sizeof(mcs_connect_initial_expected));
stream_free(s);
}
void test_gcc_write_client_security_data(void)
{
wStream* s;
rdpSettings* settings;
s = stream_new(12);
settings = freerdp_settings_new(NULL);
settings->DisableEncryption = 1; /* turn on encryption */
settings->EncryptionMethods =
ENCRYPTION_METHOD_40BIT |
ENCRYPTION_METHOD_56BIT |
ENCRYPTION_METHOD_128BIT |
ENCRYPTION_METHOD_FIPS;
gcc_write_client_security_data(s, settings);
ASSERT_STREAM(s, (BYTE*) gcc_client_security_data_expected, sizeof(gcc_client_security_data_expected));
}
void test_gcc_write_client_core_data(void)
{
STREAM* s;
rdpSettings* settings;
s = stream_new(512);
settings = settings_new();
settings->width = 1280;
settings->height = 1024;
settings->rdp_version = 5;
settings->color_depth = 24;
settings->kbd_layout = 0x409;
settings->client_build = 3790;
strcpy(settings->client_hostname, "ELTONS-DEV2");
strcpy(settings->client_product_id, "69712-783-0357974-42714");
gcc_write_client_core_data(s, settings);
ASSERT_STREAM(s, (uint8*) gcc_client_core_data_expected, sizeof(gcc_client_core_data_expected));
}
void test_license_decrypt_platform_challenge(void)
{
STREAM _s, *s;
s = &_s;
memcpy(license->licensing_encryption_key, test_licensing_encryption_key,
sizeof(test_licensing_encryption_key));
license->encrypted_platform_challenge->data =
(uint8*) xmalloc(sizeof(test_encrypted_platform_challenge));
license->encrypted_platform_challenge->length =
sizeof(test_encrypted_platform_challenge);
memcpy(license->encrypted_platform_challenge->data, test_encrypted_platform_challenge,
sizeof(test_encrypted_platform_challenge));
license_decrypt_platform_challenge(license);
s->data = license->platform_challenge->data;
s->p = s->data + sizeof(test_platform_challenge);
ASSERT_STREAM(s, test_platform_challenge, sizeof(test_platform_challenge));
}
void test_gcc_write_client_core_data(void)
{
wStream* s;
rdpSettings* settings;
s = stream_new(512);
settings = freerdp_settings_new(NULL);
settings->width = 1280;
settings->height = 1024;
settings->rdp_version = 5;
settings->color_depth = 24;
settings->kbd_layout = 0x409;
settings->kbd_type = 0x04;
settings->kbd_fn_keys = 12;
settings->client_build = 3790;
strcpy(settings->ClientHostname, "ELTONS-DEV2");
strcpy(settings->ClientProductId, "69712-783-0357974-42714");
gcc_write_client_core_data(s, settings);
ASSERT_STREAM(s, (BYTE*) gcc_client_core_data_expected, sizeof(gcc_client_core_data_expected));
}
void test_gcc_write_client_network_data(void)
{
STREAM* s;
rdpSettings* settings;
s = stream_new(44);
settings = settings_new();
settings->num_channels = 3;
memset(settings->channels, 0, sizeof(struct rdp_chan) * settings->num_channels);
strcpy(settings->channels[0].name, "rdpdr");
settings->channels[0].options = 0x80800000;
strcpy(settings->channels[1].name, "cliprdr");
settings->channels[1].options = 0xc0A00000;
strcpy(settings->channels[2].name, "rdpsnd");
settings->channels[2].options = 0xc0000000;
gcc_write_client_network_data(s, settings);
ASSERT_STREAM(s, (uint8*) gcc_client_network_data_expected, sizeof(gcc_client_network_data_expected));
}
void test_gcc_write_client_network_data(void)
{
wStream* s;
rdpSettings* settings;
s = stream_new(44);
settings = freerdp_settings_new(NULL);
settings->ChannelCount = 3;
memset(settings->ChannelDefArray, 0, sizeof(rdpChannel) * settings->ChannelCount);
strcpy(settings->ChannelDefArray[0].Name, "rdpdr");
settings->ChannelDefArray[0].options = 0x80800000;
strcpy(settings->ChannelDefArray[1].Name, "cliprdr");
settings->ChannelDefArray[1].options = 0xc0A00000;
strcpy(settings->ChannelDefArray[2].Name, "rdpsnd");
settings->ChannelDefArray[2].options = 0xc0000000;
gcc_write_client_network_data(s, settings);
ASSERT_STREAM(s, (BYTE*) gcc_client_network_data_expected, sizeof(gcc_client_network_data_expected));
}
void test_per_write_object_identifier(void)
{
STREAM* s = stream_new(6);
per_write_object_identifier(s, per_oid);
ASSERT_STREAM(s, (uint8*) per_oid_expected, sizeof(per_oid_expected));
}
void test_per_write_length(void)
{
STREAM* s = stream_new(2);
per_write_length(s, 298);
ASSERT_STREAM(s, (uint8*) per_length_expected, sizeof(per_length_expected));
}
