From fed5ec754dc057d48e96abbb158a6e9fa60a3a85 Mon Sep 17 00:00:00 2001 From: Ola Bini Date: Wed, 3 Oct 2018 19:36:31 -0500 Subject: [PATCH] Part of #163 - remove separate management of the shared prekey, instead make it part of the prekey profile structure --- src/client.c | 40 +----------- src/client.h | 6 -- src/client_callbacks.c | 1 - src/client_callbacks.h | 4 -- src/messaging.c | 65 ------------------- src/messaging.h | 10 --- src/otrng.c | 2 +- src/persistence.c | 93 ---------------------------- src/persistence.h | 6 -- src/prekey_profile.c | 58 +++++++++++++---- src/prekey_profile.h | 5 +- src/protocol.c | 5 +- src/test/test_fixtures.c | 11 ---- src/test/units/test_messaging.c | 67 +++----------------- src/test/units/test_otrng.c | 3 - src/test/units/test_prekey_profile.c | 8 +-- 16 files changed, 65 insertions(+), 319 deletions(-) diff --git a/src/client.c b/src/client.c index 6c4870b8..754fa2bb 100644 --- a/src/client.c +++ b/src/client.c @@ -123,7 +123,6 @@ API void otrng_client_free(otrng_client_s *client) { otrng_client_profile_free(client->exp_client_profile); otrng_prekey_profile_free(client->prekey_profile); otrng_prekey_profile_free(client->exp_prekey_profile); - otrng_shared_prekey_pair_free(client->shared_prekey_pair); otrng_list_free(client->conversations, conversation_free); otrng_prekey_client_free(client->prekey_client); @@ -869,39 +868,6 @@ API otrng_result otrng_client_add_exp_client_profile( return OTRNG_SUCCESS; } -INTERNAL otrng_result otrng_client_add_shared_prekey_v4( - otrng_client_s *client, const uint8_t sym[ED448_PRIVATE_BYTES]) { - assert(client); - - if (client->shared_prekey_pair) { - return OTRNG_ERROR; - } - - /* @secret_information: the shared keypair lives for as long the client - decides */ - client->shared_prekey_pair = otrng_shared_prekey_pair_new(); - if (!client->shared_prekey_pair) { - return OTRNG_ERROR; - } - - otrng_shared_prekey_pair_generate(client->shared_prekey_pair, sym); - return OTRNG_SUCCESS; -} - -static const otrng_shared_prekey_pair_s * -get_shared_prekey_pair(otrng_client_s *client) { - assert(client); - - if (client->shared_prekey_pair) { - return client->shared_prekey_pair; - } - - client->global_state->callbacks->create_shared_prekey(client, - client->client_id); - - return client->shared_prekey_pair; -} - API otrng_prekey_profile_s * otrng_client_get_prekey_profile(otrng_client_s *client) { assert(client); @@ -920,17 +886,13 @@ API otrng_prekey_profile_s * otrng_client_build_default_prekey_profile(otrng_client_s *client) { assert(client); - /* @secret: the shared prekey should be deleted once the prekey profile - * expires */ return otrng_prekey_profile_build(otrng_client_get_instance_tag(client), - otrng_client_get_keypair_v4(client), - get_shared_prekey_pair(client)); + otrng_client_get_keypair_v4(client)); } API otrng_result otrng_client_add_prekey_profile( otrng_client_s *client, const otrng_prekey_profile_s *profile) { assert(client); - if (client->prekey_profile) { return OTRNG_ERROR; } diff --git a/src/client.h b/src/client.h index b233db05..81eba67f 100644 --- a/src/client.h +++ b/src/client.h @@ -68,9 +68,6 @@ typedef struct otrng_client_s { otrng_prekey_profile_s *exp_prekey_profile; list_element_s *our_prekeys; /* otrng_stored_prekeys_s */ - /* @secret: this should be deleted once the prekey profile expires */ - otrng_shared_prekey_pair_s *shared_prekey_pair; - unsigned int max_stored_msg_keys; unsigned int max_published_prekey_msg; unsigned int minimum_stored_prekey_msg; @@ -217,9 +214,6 @@ otrng_client_get_exp_client_profile(otrng_client_s *client); API otrng_result otrng_client_add_exp_client_profile( otrng_client_s *client, const otrng_client_profile_s *exp_profile); -INTERNAL otrng_result otrng_client_add_shared_prekey_v4( - otrng_client_s *client, const uint8_t sym[ED448_PRIVATE_BYTES]); - API otrng_prekey_profile_s * otrng_client_get_prekey_profile(otrng_client_s *client); diff --git a/src/client_callbacks.c b/src/client_callbacks.c index 567f1aa6..cb5fa5a1 100644 --- a/src/client_callbacks.c +++ b/src/client_callbacks.c @@ -31,7 +31,6 @@ otrng_client_callbacks_ensure_needed_exist(const otrng_client_callbacks_s *cb) { cb->write_expired_client_profile != NULL && cb->create_prekey_profile != NULL && cb->write_expired_prekey_profile != NULL && - cb->create_shared_prekey != NULL && cb->get_shared_session_state != NULL && cb->load_privkey_v4 != NULL && cb->load_client_profile != NULL && cb->load_prekey_profile != NULL && cb->store_client_profile != NULL && cb->store_prekey_profile != NULL); diff --git a/src/client_callbacks.h b/src/client_callbacks.h index f2aaf5d0..3b5ff508 100644 --- a/src/client_callbacks.h +++ b/src/client_callbacks.h @@ -83,10 +83,6 @@ typedef struct otrng_client_callbacks_s { struct otrng_client_s *client, const struct otrng_client_id_s client_opdata); - /* REQUIRED */ - void (*create_shared_prekey)(struct otrng_client_s *client, - const struct otrng_client_id_s client_opdata); - /* OPTIONAL */ void (*gone_secure)(const struct otrng_s *); diff --git a/src/messaging.c b/src/messaging.c index fc9d88e7..b827629a 100644 --- a/src/messaging.c +++ b/src/messaging.c @@ -176,26 +176,6 @@ API otrng_result otrng_global_state_generate_forging_key( return r; } -API otrng_result otrng_global_state_generate_shared_prekey( - otrng_global_state_s *gs, const otrng_client_id_s client_id) { - otrng_result r; - uint8_t *sym = otrng_secure_alloc(ED448_PRIVATE_BYTES); - otrng_client_s *client; - - gcry_randomize(sym, ED448_PRIVATE_BYTES, GCRY_VERY_STRONG_RANDOM); - - client = get_client(gs, client_id); - if (!client) { - return OTRNG_ERROR; - } - - r = otrng_client_add_shared_prekey_v4(client, sym); - - otrng_secure_wipe(sym, ED448_PRIVATE_BYTES); - free(sym); - return r; -} - API otrng_result otrng_global_state_generate_client_profile( otrng_global_state_s *gs, const otrng_client_id_s client_id) { otrng_client_profile_s *profile; @@ -276,25 +256,6 @@ API otrng_result otrng_global_state_forging_key_write_to( return OTRNG_SUCCESS; } -tstatic void add_shared_prekey_to(list_element_s *node, void *context) { - otrng_client_s *client = node->data; - // TODO: check the return value - if (!otrng_client_shared_prekey_write_to(client, context)) { - return; - } -} - -API otrng_result otrng_global_state_shared_prekey_write_to( - const otrng_global_state_s *gs, FILE *shared_prekey_f) { - if (!shared_prekey_f) { - return OTRNG_ERROR; - } - - otrng_list_foreach(gs->clients, add_shared_prekey_to, shared_prekey_f); - - return OTRNG_SUCCESS; -} - tstatic void add_client_profile_to(list_element_s *node, void *context) { otrng_client_client_profile_write_to(node->data, context); } @@ -409,32 +370,6 @@ API otrng_result otrng_global_state_forging_key_read_from( return OTRNG_SUCCESS; } -API otrng_result otrng_global_state_shared_prekey_read_from( - otrng_global_state_s *gs, FILE *shared_prekeyf, - otrng_client_id_s (*read_client_id_for_key)(FILE *filep)) { - if (!shared_prekeyf) { - return OTRNG_ERROR; - } - - // Scan the whole file for a private key for this client - while (!feof(shared_prekeyf)) { - otrng_client_s *client; - const otrng_client_id_s client_id = read_client_id_for_key(shared_prekeyf); - if (!client_id.protocol || !client_id.account) { - continue; - } - - client = get_client(gs, client_id); - if (otrng_client_shared_prekey_read_from(client, shared_prekeyf) != - OTRNG_SUCCESS) { - return OTRNG_ERROR; /* We decide to abort, since this means the file is - malformed */ - } - } - - return OTRNG_SUCCESS; -} - API otrng_result otrng_global_state_client_profile_read_from( otrng_global_state_s *gs, FILE *profile_filep, otrng_client_id_s (*read_client_id_for_key)(FILE *filep)) { diff --git a/src/messaging.h b/src/messaging.h index 6d20ed2c..123e481e 100644 --- a/src/messaging.h +++ b/src/messaging.h @@ -72,9 +72,6 @@ API otrng_result otrng_global_state_generate_private_key( API otrng_result otrng_global_state_generate_forging_key( otrng_global_state_s *gs, const otrng_client_id_s client_id); -API otrng_result otrng_global_state_generate_shared_prekey( - otrng_global_state_s *gs, const otrng_client_id_s client_id); - API otrng_result otrng_global_state_generate_client_profile( otrng_global_state_s *gs, const otrng_client_id_s client_id); @@ -87,9 +84,6 @@ API otrng_result otrng_global_state_private_key_v4_write_to( API otrng_result otrng_global_state_forging_key_write_to( const otrng_global_state_s *gs, FILE *f); -API otrng_result otrng_global_state_shared_prekey_write_to( - const otrng_global_state_s *gs, FILE *shared_prekey_f); - API otrng_result otrng_global_state_client_profile_write_to( const otrng_global_state_s *gs, FILE *privf); @@ -113,10 +107,6 @@ API otrng_result otrng_global_state_forging_key_read_from( otrng_global_state_s *gs, FILE *f, otrng_client_id_s (*read_client_id_for_key)(FILE *f)); -API otrng_result otrng_global_state_shared_prekey_read_from( - otrng_global_state_s *gs, FILE *shared_prekeyf, - otrng_client_id_s (*read_client_id_for_key)(FILE *filep)); - API otrng_result otrng_global_state_client_profile_read_from( otrng_global_state_s *gs, FILE *profile_filep, otrng_client_id_s (*read_client_id_for_key)(FILE *filep)); diff --git a/src/otrng.c b/src/otrng.c index 990cc7ee..e5fa7392 100644 --- a/src/otrng.c +++ b/src/otrng.c @@ -141,7 +141,7 @@ tstatic void allowed_versions(string_p destination, const otrng_s *otr) { tstatic const otrng_shared_prekey_pair_s * our_shared_prekey(const otrng_s *otr) { - return otr->client->shared_prekey_pair; + return otr->client->prekey_profile->keys; } INTERNAL otrng_s *otrng_new(otrng_client_s *client, otrng_policy_s policy) { diff --git a/src/persistence.c b/src/persistence.c index 043c719c..93fe1ab6 100644 --- a/src/persistence.c +++ b/src/persistence.c @@ -265,99 +265,6 @@ INTERNAL otrng_result otrng_client_forging_key_read_from(otrng_client_s *client, return otrng_client_add_forging_key(client, key); } -INTERNAL otrng_result otrng_client_shared_prekey_write_to( - const otrng_client_s *client, FILE *shared_prekey_f) { - char *storage_id; - int err; - char *buff = NULL; - size_t s = 0; - - if (!shared_prekey_f) { - return OTRNG_ERROR; - } - - if (!client->shared_prekey_pair) { - return OTRNG_ERROR; - } - - storage_id = otrng_client_get_storage_id(client); - if (!storage_id) { - return OTRNG_ERROR; - } - - err = fputs(storage_id, shared_prekey_f); - free(storage_id); - - if (EOF == err) { - return OTRNG_ERROR; - } - - if (EOF == fputs("\n", shared_prekey_f)) { - return OTRNG_ERROR; - } - - if (!otrng_symmetric_key_serialize(&buff, &s, - client->shared_prekey_pair->sym)) { - return OTRNG_ERROR; - } - - err = fwrite(buff, s, 1, shared_prekey_f); - free(buff); - - if (err != 1) { - return OTRNG_ERROR; - } - - if (EOF == fputs("\n", shared_prekey_f)) { - return OTRNG_ERROR; - } - - return OTRNG_SUCCESS; -} - -INTERNAL otrng_result otrng_client_shared_prekey_read_from( - otrng_client_s *client, FILE *shared_prekeyf) { - char *line = NULL; - int len = 0; - otrng_shared_prekey_pair_s *shared_prekey_pair; - - if (!shared_prekeyf) { - return OTRNG_ERROR; - } - - if (feof(shared_prekeyf)) { - return OTRNG_ERROR; - } - - /* Free current keypair if any */ - otrng_shared_prekey_pair_free(client->shared_prekey_pair); - client->shared_prekey_pair = NULL; - - shared_prekey_pair = otrng_shared_prekey_pair_new(); - if (!shared_prekey_pair) { - return OTRNG_ERROR; - } - - len = get_limited_line(&line, shared_prekeyf); - if (len < 0) { - return OTRNG_ERROR; - } - - /* line has the /n */ - if (!otrng_symmetric_shared_prekey_deserialize(shared_prekey_pair, line, - len)) { - free(line); - otrng_shared_prekey_pair_free(client->shared_prekey_pair); - return OTRNG_ERROR; - } - - free(line); - - client->shared_prekey_pair = shared_prekey_pair; - - return OTRNG_SUCCESS; -} - INTERNAL otrng_result otrng_client_instance_tag_write_to(otrng_client_s *client, FILE *instagf) { // TODO: We could use a "get storage key" callback and use it as diff --git a/src/persistence.h b/src/persistence.h index 1e0be65b..a89c0266 100644 --- a/src/persistence.h +++ b/src/persistence.h @@ -35,12 +35,6 @@ otrng_client_private_key_v4_write_to(const otrng_client_s *client, FILE *privf); INTERNAL otrng_result otrng_client_forging_key_write_to(const otrng_client_s *client, FILE *f); -INTERNAL otrng_result otrng_client_shared_prekey_write_to( - const otrng_client_s *client, FILE *shared_prekey_f); - -INTERNAL otrng_result otrng_client_shared_prekey_read_from( - otrng_client_s *client, FILE *shared_prekeyf); - INTERNAL otrng_result otrng_client_instance_tag_read_from(otrng_client_s *client, FILE *instag); diff --git a/src/prekey_profile.c b/src/prekey_profile.c index 2cc1fbb8..9376af31 100644 --- a/src/prekey_profile.c +++ b/src/prekey_profile.c @@ -31,6 +31,7 @@ INTERNAL void otrng_prekey_profile_destroy(otrng_prekey_profile_s *destination) { + otrng_shared_prekey_pair_free(destination->keys); otrng_ec_point_destroy(destination->shared_prekey); memset(destination->signature, 0, ED448_SIGNATURE_BYTES); } @@ -56,6 +57,11 @@ INTERNAL void otrng_prekey_profile_copy(otrng_prekey_profile_s *destination, destination->expires = source->expires; otrng_ec_point_copy(destination->shared_prekey, source->shared_prekey); + if (destination->keys != NULL) { + otrng_shared_prekey_pair_free(destination->keys); + } + destination->keys = otrng_secure_alloc(sizeof(otrng_shared_prekey_pair_s)); + memcpy(destination->keys, source->keys, sizeof(otrng_shared_prekey_pair_s)); memcpy(destination->signature, source->signature, ED448_SIGNATURE_BYTES); destination->should_publish = source->should_publish; @@ -136,22 +142,43 @@ INTERNAL otrng_result otrng_prekey_profile_deserialize( INTERNAL otrng_result otrng_prekey_profile_deserialize_with_metadata( otrng_prekey_profile_s *target, const uint8_t *buffer, size_t buflen, size_t *nread) { - size_t nread1, nread2; + size_t read = 0; + size_t w = 0; otrng_result result = - otrng_prekey_profile_deserialize(target, buffer, buflen, &nread1); + otrng_prekey_profile_deserialize(target, buffer, buflen, &read); + if (otrng_failed(result)) { + return result; + } + + w += read; + + result = otrng_deserialize_uint8(&target->should_publish, buffer + w, + buflen - w, &read); + if (otrng_failed(result)) { return result; } - result = otrng_deserialize_uint8(&target->should_publish, buffer + nread1, - buflen - nread1, &nread2); + w += read; + + target->keys = otrng_secure_alloc(sizeof(otrng_shared_prekey_pair_s)); + result = otrng_deserialize_bytes_array(target->keys->sym, ED448_PRIVATE_BYTES, + buffer + w, buflen - w); + if (otrng_failed(result)) { + return OTRNG_ERROR; + } + + otrng_shared_prekey_pair_generate(target->keys, target->keys->sym); + otrng_ec_point_copy(target->shared_prekey, target->keys->pub); + + w += ED448_PRIVATE_BYTES; if (otrng_failed(result)) { return result; } if (nread) { - *nread = nread1 + nread2; + *nread = w; } return OTRNG_SUCCESS; @@ -220,7 +247,8 @@ INTERNAL otrng_result otrng_prekey_profile_serialize( INTERNAL otrng_result otrng_prekey_profile_serialize_with_metadata( uint8_t **destination, size_t *nbytes, otrng_prekey_profile_s *profile) { - size_t size = PREKEY_PROFILE_BODY_BYTES + ED448_SIGNATURE_BYTES + 1; + size_t size = PREKEY_PROFILE_BODY_BYTES + ED448_SIGNATURE_BYTES + 1 + + ED448_PRIVATE_BYTES; uint8_t *buff = otrng_xmalloc_z(size); size_t written; @@ -241,6 +269,9 @@ INTERNAL otrng_result otrng_prekey_profile_serialize_with_metadata( written += otrng_serialize_uint8(buff + written, profile->should_publish); + written += otrng_serialize_bytes_array(buff + written, profile->keys->sym, + ED448_PRIVATE_BYTES); + *destination = buff; if (nbytes) { *nbytes = written; @@ -267,24 +298,27 @@ INTERNAL otrng_result prekey_profile_sign( INTERNAL otrng_prekey_profile_s * otrng_prekey_profile_build(uint32_t instance_tag, - const otrng_keypair_s *longterm_pair, - const otrng_shared_prekey_pair_s *prekey_pair) { + const otrng_keypair_s *longterm_pair) { otrng_prekey_profile_s *prekey_profile; time_t expires = time(NULL); - if (!prekey_pair || !longterm_pair || - !otrng_instance_tag_valid(instance_tag)) { + if (!longterm_pair || !otrng_instance_tag_valid(instance_tag)) { return NULL; } prekey_profile = otrng_xmalloc_z(sizeof(otrng_prekey_profile_s)); + prekey_profile->keys = otrng_shared_prekey_pair_new(); + gcry_randomize(prekey_profile->keys->sym, ED448_PRIVATE_BYTES, + GCRY_VERY_STRONG_RANDOM); + otrng_shared_prekey_pair_generate(prekey_profile->keys, + prekey_profile->keys->sym); + otrng_ec_point_copy(prekey_profile->shared_prekey, prekey_profile->keys->pub); + prekey_profile->instance_tag = instance_tag; #define PREKEY_PROFILE_EXPIRATION_SECONDS 1 * 30 * 24 * 60 * 60; /* 1 month */ prekey_profile->expires = expires + PREKEY_PROFILE_EXPIRATION_SECONDS; - otrng_ec_point_copy(prekey_profile->shared_prekey, - prekey_pair->pub); /* Key "D" */ if (!prekey_profile_sign(prekey_profile, longterm_pair)) { otrng_prekey_profile_free(prekey_profile); diff --git a/src/prekey_profile.h b/src/prekey_profile.h index 773105ee..345ffbaa 100644 --- a/src/prekey_profile.h +++ b/src/prekey_profile.h @@ -31,6 +31,8 @@ typedef struct prekey_profile_s { ec_point_t shared_prekey; /* Key "D" */ eddsa_signature_t signature; + otrng_shared_prekey_pair_s *keys; + otrng_bool should_publish; otrng_bool is_publishing; } otrng_prekey_profile_s; @@ -44,8 +46,7 @@ INTERNAL void otrng_prekey_profile_copy(otrng_prekey_profile_s *destination, INTERNAL otrng_prekey_profile_s * otrng_prekey_profile_build(uint32_t instance_tag, - const otrng_keypair_s *longterm_pair, - const otrng_shared_prekey_pair_s *prekey_pair); + const otrng_keypair_s *longterm_pair); INTERNAL otrng_bool otrng_prekey_profile_expired(time_t expires); diff --git a/src/protocol.c b/src/protocol.c index 27be549b..f1cbfb5f 100644 --- a/src/protocol.c +++ b/src/protocol.c @@ -50,10 +50,6 @@ INTERNAL void maybe_create_keys(otrng_client_s *client) { cb->create_forging_key(client_id); } - if (!client->shared_prekey_pair) { - cb->create_shared_prekey(client, client_id); - } - instance_tag = otrng_client_get_instance_tag(client); if (!instance_tag) { otrng_client_callbacks_create_instag(cb, client_id); @@ -81,6 +77,7 @@ INTERNAL const otrng_client_profile_s *get_my_exp_client_profile(otrng_s *otr) { INTERNAL const otrng_prekey_profile_s *get_my_prekey_profile(otrng_s *otr) { otrng_client_s *client = otr->client; + maybe_create_keys(client); return otrng_client_get_prekey_profile(client); } diff --git a/src/test/test_fixtures.c b/src/test/test_fixtures.c index 3523ab63..1784f67c 100644 --- a/src/test/test_fixtures.c +++ b/src/test/test_fixtures.c @@ -112,7 +112,6 @@ otrng_client_callbacks_s test_callbacks[1] = {{ .create_forging_key = &create_forging_key_cb_empty, .write_expired_client_profile = &write_expired_client_profile_cb_empty, .write_expired_prekey_profile = &write_expired_prekey_profile_cb_empty, - .create_shared_prekey = &create_shared_prekey_cb_empty, .load_privkey_v4 = &load_privkey_v4_cb_empty, .load_client_profile = &load_client_profile_cb_empty, .load_prekey_profile = &load_prekey_profile_cb_empty, @@ -142,7 +141,6 @@ void otrng_fixture_set_up(otrng_fixture_s *otrng_fixture, gconstpointer data) { otrng_public_key_t *fk = create_forging_key_from(sym2); otrng_client_add_forging_key(otrng_fixture->client, *fk); free(fk); - otrng_client_add_shared_prekey_v4(otrng_fixture->client, sym); otrng_policy_s policy = {.allows = OTRNG_ALLOW_V4}; otrng_fixture->otr = otrng_new(otrng_fixture->client, policy); @@ -351,13 +349,11 @@ void set_up_client(otrng_client_s *client, const char *account_name, int byte) { uint8_t long_term_priv[ED448_PRIVATE_BYTES] = {byte + 0xA}; uint8_t forging_sym[ED448_PRIVATE_BYTES] = {byte + 0xD}; - uint8_t shared_prekey_priv[ED448_PRIVATE_BYTES] = {byte + 0xF}; otrng_client_add_private_key_v4(client, long_term_priv); otrng_public_key_t *fk = create_forging_key_from(forging_sym); otrng_client_add_forging_key(client, *fk); free(fk); - otrng_client_add_shared_prekey_v4(client, shared_prekey_priv); otrng_client_add_instance_tag(client, 0x100 + byte); client->client_profile = otrng_client_build_default_client_profile(client); @@ -420,13 +416,6 @@ void write_expired_prekey_profile_cb_empty( (void)client_opdata; } -void create_shared_prekey_cb_empty( - struct otrng_client_s *client, - const struct otrng_client_id_s client_opdata) { - (void)client; - (void)client_opdata; -} - otrng_shared_session_state_s get_shared_session_state_cb_empty(const struct otrng_s *conv) { otrng_shared_session_state_s result; diff --git a/src/test/units/test_messaging.c b/src/test/units/test_messaging.c index 81f1cc37..da38f2b1 100644 --- a/src/test/units/test_messaging.c +++ b/src/test/units/test_messaging.c @@ -66,7 +66,6 @@ static otrng_client_callbacks_s empty_callbacks[1] = {{ .create_forging_key = &create_forging_key_cb_empty, .write_expired_client_profile = &write_expired_client_profile_cb_empty, .write_expired_prekey_profile = &write_expired_prekey_profile_cb_empty, - .create_shared_prekey = &create_shared_prekey_cb_empty, .load_privkey_v4 = &load_privkey_v4_cb_empty, .load_client_profile = &load_client_profile_cb_empty, .load_prekey_profile = &load_prekey_profile_cb_empty, @@ -119,55 +118,6 @@ static void test_global_state_key_management(void) { otrng_global_state_free(state); } -static void test_global_state_shared_prekey_management(void) { - const uint8_t alice_sym[ED448_PRIVATE_BYTES] = {1}; - const uint8_t bob_sym[ED448_PRIVATE_BYTES] = {2}; - - otrng_global_state_s *state = - otrng_global_state_new(empty_callbacks, otrng_false); - otrng_global_state_add_private_key_v4( - state, create_client_id("otr", alice_account), alice_sym); - otrng_global_state_add_private_key_v4( - state, create_client_id("otr", bob_account), bob_sym); - - otrng_assert(otrng_global_state_get_private_key_v4( - state, create_client_id("otr", alice_account))); - otrng_assert(otrng_global_state_get_private_key_v4( - state, create_client_id("otr", bob_account))); - otrng_assert(!otrng_global_state_get_private_key_v4( - state, create_client_id("otr", charlie_account))); - - /* Generate file */ - FILE *keys = tmpfile(); - - fputs("charlie@xmpp\n" - "mgRi+jOWSHludTU/v0QE/" - "6W88WmxUmKMh1QpRbrEw4LESkL0mnOgZBbqpInVFJGy3v2aKbBFj4c0\n", - keys); - rewind(keys); - - otrng_result result = otrng_global_state_shared_prekey_read_from( - state, keys, read_client_id_for_privf); - otrng_assert_is_success(result); - fclose(keys); - - otrng_client_s *client = - get_client(state, create_client_id("otr", charlie_account)); - - char *buffer = NULL; - size_t s = 0; - otrng_symmetric_key_serialize(&buffer, &s, client->shared_prekey_pair->sym); - - const char *expected = - "mgRi+jOWSHludTU/v0QE/" - "6W88WmxUmKMh1QpRbrEw4LESkL0mnOgZBbqpInVFJGy3v2aKbBFj4c0"; - - otrng_assert_cmpmem(expected, buffer, s); - - free(buffer); - otrng_global_state_free(state); -} - static void test_global_state_client_profile_management(void) { const uint8_t alice_sym[ED448_PRIVATE_BYTES] = {1}; const uint8_t bob_sym[ED448_PRIVATE_BYTES] = {2}; @@ -281,7 +231,9 @@ static void test_global_state_prekey_profile_management(void) { "s1vlz8xF+vPV82xSwmEA65IyR3ZaR6NzZNNAznBrXXb7YjvMuYtTtKnp+" "LZfUSYFcjoZACAqnA8V5fDvuuCFFMINr6rKZihf4wTVOKO+hO+" "rMWi7dsYeLu3eee7fZ9LsHUuriHxadL6mW0J6QAPeo2n75TnDUt1aVpjCK0Mrut0hTstbD" - "oyyEVaVNh2Rx87o30YStXn92fDNCBsGHU+F2xv/ZQ2OQAA\n", + "oyyEVaVNh2Rx87o30YStXn92fDNCBsGHU+F2xv/ZQ2OQAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n", prekey_profile); rewind(prekey_profile); @@ -299,12 +251,13 @@ static void test_global_state_prekey_profile_management(void) { size_t s = 0; otrng_prekey_profile_serialize(&buffer, &s, client->prekey_profile); char *encoded = otrng_base64_encode(buffer, s); + const char *expected = - "26FP8QAAAABbxy5lABFQAQ3a/" - "s1vlz8xF+vPV82xSwmEA65IyR3ZaR6NzZNNAznBrXXb7YjvMuYtTtKnp+" - "LZfUSYFcjoZACAqnA8V5fDvuuCFFMINr6rKZihf4wTVOKO+hO+" - "rMWi7dsYeLu3eee7fZ9LsHUuriHxadL6mW0J6QAPeo2n75TnDUt1aVpjCK0Mrut0hTstbDoy" - "yEVaVNh2Rx87o30YStXn92fDNCBsGHU+F2xv/ZQ2OQAA"; + "26FP8QAAAABbxy5lABFbOv4Dh" + "4pJsoIy1PGkQq694Qn4B6zvff2af2W5Yv5S1lRzEsrOz/BDN1CPnSUpqP" + "FmkWmyHDLEgACAqnA8V5fDvuuCFFMINr6rKZihf4wTVOKO+hO+" + "rMWi7dsYeLu3eee7fZ9LsHUuriHxadL6mW0J6QAPeo2n75TnDUt1aVpjCK0Mrut0hTstbD" + "oyyEVaVNh2Rx87o30YStXn92fDNCBsGHU+F2xv/ZQ2OQA="; otrng_assert_cmpmem(expected, encoded, s); @@ -418,8 +371,6 @@ static void test_instance_tag_api(void) { void units_messaging_add_tests() { g_test_add_func("/global_state/key_management", test_global_state_key_management); - g_test_add_func("/global_state/shared_prekey_management", - test_global_state_shared_prekey_management); g_test_add_func("/global_state/client_profile", test_global_state_client_profile_management); g_test_add_func("/global_state/prekey_profile", diff --git a/src/test/units/test_otrng.c b/src/test/units/test_otrng.c index 04ddb020..c0091ad3 100644 --- a/src/test/units/test_otrng.c +++ b/src/test/units/test_otrng.c @@ -238,7 +238,6 @@ static void test_otrng_destroy() { static void test_otrng_build_prekey_ensemble() { uint8_t long_term_priv[ED448_PRIVATE_BYTES] = {0xA}; - uint8_t shared_prekey_priv[ED448_PRIVATE_BYTES] = {0XF}; uint8_t forging_priv[ED448_PRIVATE_BYTES] = { 2}; // non-random forging key on purpose otrng_keypair_s *kforging = otrng_keypair_new(); @@ -251,8 +250,6 @@ static void test_otrng_build_prekey_ensemble() { otrng_client_add_private_key_v4(client, long_term_priv)); otrng_assert_is_success(otrng_client_add_forging_key(client, kforging->pub)); otrng_keypair_free(kforging); - otrng_assert_is_success( - otrng_client_add_shared_prekey_v4(client, shared_prekey_priv)); otrng_assert_is_success(otrng_client_add_instance_tag(client, 0x100A0F)); otrng_keypair_s *keypair = otrng_client_get_keypair_v4(client); diff --git a/src/test/units/test_prekey_profile.c b/src/test/units/test_prekey_profile.c index 759b3161..7ee129bb 100644 --- a/src/test/units/test_prekey_profile.c +++ b/src/test/units/test_prekey_profile.c @@ -34,8 +34,8 @@ static void test_prekey_profile_validates() { otrng_shared_prekey_pair_s *shared_prekey = otrng_shared_prekey_pair_new(); otrng_shared_prekey_pair_generate(shared_prekey, sym_shared); - otrng_prekey_profile_s *profile = otrng_prekey_profile_build( - OTRNG_MIN_VALID_INSTAG + 0x01, long_term, shared_prekey); + otrng_prekey_profile_s *profile = + otrng_prekey_profile_build(OTRNG_MIN_VALID_INSTAG + 0x01, long_term); otrng_assert(otrng_prekey_profile_valid(profile, profile->instance_tag, long_term->pub)); @@ -71,7 +71,7 @@ static void test_prekey_profile_serialize() { otrng_shared_prekey_pair_generate(shared_prekey, sym); otrng_prekey_profile_s *profile = - otrng_prekey_profile_build(instance_tag, &keypair, shared_prekey); + otrng_prekey_profile_build(instance_tag, &keypair); otrng_assert(profile != NULL); @@ -118,7 +118,7 @@ static void test_prekey_profile_deserialize() { otrng_shared_prekey_pair_generate(shared_prekey, sym); otrng_prekey_profile_s *profile = - otrng_prekey_profile_build(instance_tag, &keypair, shared_prekey); + otrng_prekey_profile_build(instance_tag, &keypair); otrng_assert(profile != NULL);