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)); }