int scannable_fingerprint_compare(scannable_fingerprint *scannable, const scannable_fingerprint *other_scannable) { if(!other_scannable->remote_identity_key || !other_scannable->local_identity_key || other_scannable->version != scannable->version) { return SG_ERR_FP_VERSION_MISMATCH; } if(strcmp(scannable->local_stable_identifier, other_scannable->remote_stable_identifier) != 0) { return SG_ERR_FP_IDENT_MISMATCH; } if(strcmp(scannable->remote_stable_identifier, other_scannable->local_stable_identifier) != 0) { return SG_ERR_FP_IDENT_MISMATCH; } if(ec_public_key_compare(scannable->local_identity_key, other_scannable->remote_identity_key) != 0) { return 0; } if(ec_public_key_compare(scannable->remote_identity_key, other_scannable->local_identity_key) != 0) { return 0; } return 1; }
END_TEST START_TEST(test_curve25519_generate_public) { int result; uint8_t alicePublic[] = { 0x05, 0x1b, 0xb7, 0x59, 0x66, 0xf2, 0xe9, 0x3a, 0x36, 0x91, 0xdf, 0xff, 0x94, 0x2b, 0xb2, 0xa4, 0x66, 0xa1, 0xc0, 0x8b, 0x8d, 0x78, 0xca, 0x3f, 0x4d, 0x6d, 0xf8, 0xb8, 0xbf, 0xa2, 0xe4, 0xee, 0x28}; uint8_t alicePrivate[] = { 0xc8, 0x06, 0x43, 0x9d, 0xc9, 0xd2, 0xc4, 0x76, 0xff, 0xed, 0x8f, 0x25, 0x80, 0xc0, 0x88, 0x8d, 0x58, 0xab, 0x40, 0x6b, 0xf7, 0xae, 0x36, 0x98, 0x87, 0x90, 0x21, 0xb9, 0x6b, 0xb4, 0xbf, 0x59}; ec_private_key *alice_private_key = 0; ec_public_key *alice_expected_public_key = 0; ec_public_key *alice_public_key = 0; /* Initialize Alice's private key */ result = curve_decode_private_point(&alice_private_key, alicePrivate, sizeof(alicePrivate), global_context); ck_assert_int_eq(result, 0); ck_assert_ptr_ne(alice_private_key, 0); /* Initialize Alice's expected public key */ result = curve_decode_point(&alice_expected_public_key, alicePublic, sizeof(alicePublic), global_context); ck_assert_int_eq(result, 0); ck_assert_ptr_ne(alice_expected_public_key, 0); /* Generate Alice's actual public key */ result = curve_generate_public_key(&alice_public_key, alice_private_key); ck_assert_int_eq(result, 0); ck_assert_ptr_ne(alice_public_key, 0); /* Assert that expected and actual public keys match */ ck_assert_int_eq(ec_public_key_compare(alice_expected_public_key, alice_public_key), 0); /* Cleanup */ SIGNAL_UNREF(alice_public_key); SIGNAL_UNREF(alice_expected_public_key); SIGNAL_UNREF(alice_private_key); }
END_TEST START_TEST(test_serialize_sender_key_distribution_message) { int result = 0; sender_key_distribution_message *message = 0; sender_key_distribution_message *result_message = 0; static const char chain_key[] = "WhisperChainKey"; ec_public_key *signature_key = create_test_ec_public_key(global_context); result = sender_key_distribution_message_create(&message, 10, /* id */ 1, /* iteration */ (uint8_t *)chain_key, sizeof(chain_key) - 1, signature_key, global_context); ck_assert_int_eq(result, 0); signal_buffer *serialized = ciphertext_message_get_serialized((ciphertext_message *)message); ck_assert_ptr_ne(serialized, 0); result = sender_key_distribution_message_deserialize(&result_message, signal_buffer_data(serialized), signal_buffer_len(serialized), global_context); ck_assert_int_eq(result, 0); int id1 = sender_key_distribution_message_get_id(message); int id2 = sender_key_distribution_message_get_id(result_message); ck_assert_int_eq(id1, id2); int iteration1 = sender_key_distribution_message_get_iteration(message); int iteration2 = sender_key_distribution_message_get_iteration(result_message); ck_assert_int_eq(iteration1, iteration2); signal_buffer *chain_key1 = sender_key_distribution_message_get_chain_key(message); signal_buffer *chain_key2 = sender_key_distribution_message_get_chain_key(result_message); ck_assert_int_eq(signal_buffer_compare(chain_key1, chain_key2), 0); ec_public_key *signature_key1 = sender_key_distribution_message_get_signature_key(message); ec_public_key *signature_key2 = sender_key_distribution_message_get_signature_key(result_message); ck_assert_int_eq(ec_public_key_compare(signature_key1, signature_key2), 0); /* Cleanup */ SIGNAL_UNREF(message); SIGNAL_UNREF(result_message); SIGNAL_UNREF(signature_key); }
void compare_signal_messages(signal_message *message1, signal_message *message2) { ec_public_key *sender_ratchet_key1 = signal_message_get_sender_ratchet_key(message1); ec_public_key *sender_ratchet_key2 = signal_message_get_sender_ratchet_key(message2); ck_assert_int_eq(ec_public_key_compare(sender_ratchet_key1, sender_ratchet_key2), 0); int version1 = signal_message_get_message_version(message1); int version2 = signal_message_get_message_version(message2); ck_assert_int_eq(version1, version2); int counter1 = signal_message_get_counter(message1); int counter2 = signal_message_get_counter(message2); ck_assert_int_eq(counter1, counter2); signal_buffer *body1 = signal_message_get_body(message1); signal_buffer *body2 = signal_message_get_body(message2); ck_assert_int_eq(signal_buffer_compare(body1, body2), 0); }
void compare_sender_key_states(sender_key_state *state1, sender_key_state *state2) { /* Compare key IDs */ int key_id1 = sender_key_state_get_key_id(state1); int key_id2 = sender_key_state_get_key_id(state2); ck_assert_int_eq(key_id1, key_id2); /* Compare chain keys */ sender_chain_key *chain_key1 = sender_key_state_get_chain_key(state1); sender_chain_key *chain_key2 = sender_key_state_get_chain_key(state2); compare_sender_chain_keys(chain_key1, chain_key2); /* Compare public signing keys */ ec_public_key *key_public1 = sender_key_state_get_signing_key_public(state1); ec_public_key *key_public2 = sender_key_state_get_signing_key_public(state2); ck_assert_int_eq(ec_public_key_compare(key_public1, key_public2), 0); /* Compare private signing keys */ ec_private_key *key_private1 = sender_key_state_get_signing_key_private(state1); ec_private_key *key_private2 = sender_key_state_get_signing_key_private(state2); ck_assert_int_eq(ec_private_key_compare(key_private1, key_private2), 0); /* Message keys are not compared here */ }
END_TEST START_TEST(test_serialize_pre_key_signal_message) { int result = 0; static const char ciphertext[] = "WhisperCipherText"; ec_public_key *sender_ratchet_key = create_test_ec_public_key(global_context); ec_public_key *sender_identity_key = create_test_ec_public_key(global_context); ec_public_key *receiver_identity_key = create_test_ec_public_key(global_context); ec_public_key *base_key = create_test_ec_public_key(global_context); ec_public_key *identity_key = create_test_ec_public_key(global_context); uint8_t mac_key[RATCHET_MAC_KEY_LENGTH]; memset(mac_key, 1, sizeof(mac_key)); signal_message *message = 0; pre_key_signal_message *pre_key_message = 0; pre_key_signal_message *result_pre_key_message = 0; result = signal_message_create(&message, 3, mac_key, sizeof(mac_key), sender_ratchet_key, 2, /* counter */ 1, /* previous counter */ (uint8_t *)ciphertext, sizeof(ciphertext) - 1, sender_identity_key, receiver_identity_key, global_context); ck_assert_int_eq(result, 0); uint32_t pre_key_id = 56; result = pre_key_signal_message_create(&pre_key_message, 3, /* message version */ 42, /* registration ID */ &pre_key_id, /* pre key ID */ 72, /* signed pre key ID */ base_key, identity_key, message, global_context); ck_assert_int_eq(result, 0); signal_buffer *serialized = ciphertext_message_get_serialized((ciphertext_message *)pre_key_message); ck_assert_ptr_ne(serialized, 0); result = pre_key_signal_message_deserialize(&result_pre_key_message, signal_buffer_data(serialized), signal_buffer_len(serialized), global_context); ck_assert_int_eq(result, 0); int version1 = pre_key_signal_message_get_message_version(pre_key_message); int version2 = pre_key_signal_message_get_message_version(result_pre_key_message); ck_assert_int_eq(version1, version2); ec_public_key *identity_key1 = pre_key_signal_message_get_identity_key(pre_key_message); ec_public_key *identity_key2 = pre_key_signal_message_get_identity_key(result_pre_key_message); ck_assert_int_eq(ec_public_key_compare(identity_key1, identity_key2), 0); int registration_id1 = pre_key_signal_message_get_registration_id(pre_key_message); int registration_id2 = pre_key_signal_message_get_registration_id(result_pre_key_message); ck_assert_int_eq(registration_id1, registration_id2); int has_pre_key_id1 = pre_key_signal_message_has_pre_key_id(pre_key_message); int has_pre_key_id2 = pre_key_signal_message_has_pre_key_id(result_pre_key_message); ck_assert_int_eq(has_pre_key_id1, has_pre_key_id2); if(has_pre_key_id1) { int pre_key_id1 = pre_key_signal_message_get_pre_key_id(pre_key_message); int pre_key_id2 = pre_key_signal_message_get_pre_key_id(result_pre_key_message); ck_assert_int_eq(pre_key_id1, pre_key_id2); } int signed_pre_key_id1 = pre_key_signal_message_get_signed_pre_key_id(pre_key_message); int signed_pre_key_id2 = pre_key_signal_message_get_signed_pre_key_id(result_pre_key_message); ck_assert_int_eq(signed_pre_key_id1, signed_pre_key_id2); ec_public_key *base_key1 = pre_key_signal_message_get_base_key(pre_key_message); ec_public_key *base_key2 = pre_key_signal_message_get_base_key(result_pre_key_message); ck_assert_int_eq(ec_public_key_compare(base_key1, base_key2), 0); signal_message *message1 = pre_key_signal_message_get_signal_message(pre_key_message); signal_message *message2 = pre_key_signal_message_get_signal_message(result_pre_key_message); compare_signal_messages(message1, message2); /* Cleanup */ SIGNAL_UNREF(message); SIGNAL_UNREF(result_pre_key_message); SIGNAL_UNREF(pre_key_message); SIGNAL_UNREF(sender_ratchet_key); SIGNAL_UNREF(sender_identity_key); SIGNAL_UNREF(receiver_identity_key); SIGNAL_UNREF(base_key); SIGNAL_UNREF(identity_key); }