diff options
Diffstat (limited to 'src/omemo')
-rw-r--r-- | src/omemo/crypto.c | 112 | ||||
-rw-r--r-- | src/omemo/crypto.h | 60 | ||||
-rw-r--r-- | src/omemo/omemo.c | 543 | ||||
-rw-r--r-- | src/omemo/omemo.h | 57 | ||||
-rw-r--r-- | src/omemo/store.c | 187 | ||||
-rw-r--r-- | src/omemo/store.h | 77 |
6 files changed, 517 insertions, 519 deletions
diff --git a/src/omemo/crypto.c b/src/omemo/crypto.c index d062e058..47477f8e 100644 --- a/src/omemo/crypto.c +++ b/src/omemo/crypto.c @@ -33,13 +33,13 @@ * */ #include <assert.h> +#include <gcrypt.h> #include <signal/signal_protocol.h> #include <signal/signal_protocol_types.h> -#include <gcrypt.h> #include "log.h" -#include "omemo/omemo.h" #include "omemo/crypto.h" +#include "omemo/omemo.h" int omemo_crypto_init(void) @@ -65,14 +65,14 @@ omemo_crypto_init(void) } int -omemo_random_func(uint8_t *data, size_t len, void *user_data) +omemo_random_func(uint8_t* data, size_t len, void* user_data) { gcry_randomize(data, len, GCRY_VERY_STRONG_RANDOM); return 0; } int -omemo_hmac_sha256_init_func(void **hmac_context, const uint8_t *key, size_t key_len, void *user_data) +omemo_hmac_sha256_init_func(void** hmac_context, const uint8_t* key, size_t key_len, void* user_data) { gcry_error_t res; gcry_mac_hd_t hd; @@ -94,7 +94,7 @@ omemo_hmac_sha256_init_func(void **hmac_context, const uint8_t *key, size_t key_ } int -omemo_hmac_sha256_update_func(void *hmac_context, const uint8_t *data, size_t data_len, void *user_data) +omemo_hmac_sha256_update_func(void* hmac_context, const uint8_t* data, size_t data_len, void* user_data) { gcry_error_t res; @@ -108,7 +108,7 @@ omemo_hmac_sha256_update_func(void *hmac_context, const uint8_t *data, size_t da } int -omemo_hmac_sha256_final_func(void *hmac_context, signal_buffer **output, void *user_data) +omemo_hmac_sha256_final_func(void* hmac_context, signal_buffer** output, void* user_data) { gcry_error_t res; size_t mac_len = 32; @@ -125,13 +125,13 @@ omemo_hmac_sha256_final_func(void *hmac_context, signal_buffer **output, void *u } void -omemo_hmac_sha256_cleanup_func(void *hmac_context, void *user_data) +omemo_hmac_sha256_cleanup_func(void* hmac_context, void* user_data) { gcry_mac_close(hmac_context); } int -omemo_sha512_digest_init_func(void **digest_context, void *user_data) +omemo_sha512_digest_init_func(void** digest_context, void* user_data) { gcry_error_t res; gcry_md_hd_t hd; @@ -148,7 +148,7 @@ omemo_sha512_digest_init_func(void **digest_context, void *user_data) } int -omemo_sha512_digest_update_func(void *digest_context, const uint8_t *data, size_t data_len, void *user_data) +omemo_sha512_digest_update_func(void* digest_context, const uint8_t* data, size_t data_len, void* user_data) { gcry_md_write(digest_context, data, data_len); @@ -156,7 +156,7 @@ omemo_sha512_digest_update_func(void *digest_context, const uint8_t *data, size_ } int -omemo_sha512_digest_final_func(void *digest_context, signal_buffer **output, void *user_data) +omemo_sha512_digest_final_func(void* digest_context, signal_buffer** output, void* user_data) { gcry_error_t res; unsigned char out[64]; @@ -172,37 +172,37 @@ omemo_sha512_digest_final_func(void *digest_context, signal_buffer **output, voi } void -omemo_sha512_digest_cleanup_func(void *digest_context, void *user_data) +omemo_sha512_digest_cleanup_func(void* digest_context, void* user_data) { gcry_md_close(digest_context); } int -omemo_encrypt_func(signal_buffer **output, int cipher, const uint8_t *key, size_t key_len, const uint8_t *iv, size_t iv_len, - const uint8_t *plaintext, size_t plaintext_len, void *user_data) +omemo_encrypt_func(signal_buffer** output, int cipher, const uint8_t* key, size_t key_len, const uint8_t* iv, size_t iv_len, + const uint8_t* plaintext, size_t plaintext_len, void* user_data) { gcry_cipher_hd_t hd; - unsigned char *padded_plaintext; - unsigned char *ciphertext; + unsigned char* padded_plaintext; + unsigned char* ciphertext; size_t ciphertext_len; int mode; int algo; uint8_t padding = 0; switch (key_len) { - case 32: - algo = GCRY_CIPHER_AES256; - break; - default: - return OMEMO_ERR_UNSUPPORTED_CRYPTO; + case 32: + algo = GCRY_CIPHER_AES256; + break; + default: + return OMEMO_ERR_UNSUPPORTED_CRYPTO; } switch (cipher) { - case SG_CIPHER_AES_CBC_PKCS5: - mode = GCRY_CIPHER_MODE_CBC; - break; - default: - return OMEMO_ERR_UNSUPPORTED_CRYPTO; + case SG_CIPHER_AES_CBC_PKCS5: + mode = GCRY_CIPHER_MODE_CBC; + break; + default: + return OMEMO_ERR_UNSUPPORTED_CRYPTO; } gcry_cipher_open(&hd, algo, mode, GCRY_CIPHER_SECURE); @@ -210,12 +210,12 @@ omemo_encrypt_func(signal_buffer **output, int cipher, const uint8_t *key, size_ gcry_cipher_setkey(hd, key, key_len); switch (cipher) { - case SG_CIPHER_AES_CBC_PKCS5: - gcry_cipher_setiv(hd, iv, iv_len); - padding = 16 - (plaintext_len % 16); - break; - default: - assert(FALSE); + case SG_CIPHER_AES_CBC_PKCS5: + gcry_cipher_setiv(hd, iv, iv_len); + padding = 16 - (plaintext_len % 16); + break; + default: + assert(FALSE); } padded_plaintext = malloc(plaintext_len + padding); @@ -236,31 +236,31 @@ omemo_encrypt_func(signal_buffer **output, int cipher, const uint8_t *key, size_ } int -omemo_decrypt_func(signal_buffer **output, int cipher, const uint8_t *key, size_t key_len, const uint8_t *iv, size_t iv_len, - const uint8_t *ciphertext, size_t ciphertext_len, void *user_data) +omemo_decrypt_func(signal_buffer** output, int cipher, const uint8_t* key, size_t key_len, const uint8_t* iv, size_t iv_len, + const uint8_t* ciphertext, size_t ciphertext_len, void* user_data) { int ret = SG_SUCCESS; gcry_cipher_hd_t hd; - unsigned char *plaintext; + unsigned char* plaintext; size_t plaintext_len; int mode; int algo; uint8_t padding = 0; switch (key_len) { - case 32: - algo = GCRY_CIPHER_AES256; - break; - default: - return OMEMO_ERR_UNSUPPORTED_CRYPTO; + case 32: + algo = GCRY_CIPHER_AES256; + break; + default: + return OMEMO_ERR_UNSUPPORTED_CRYPTO; } switch (cipher) { - case SG_CIPHER_AES_CBC_PKCS5: - mode = GCRY_CIPHER_MODE_CBC; - break; - default: - return OMEMO_ERR_UNSUPPORTED_CRYPTO; + case SG_CIPHER_AES_CBC_PKCS5: + mode = GCRY_CIPHER_MODE_CBC; + break; + default: + return OMEMO_ERR_UNSUPPORTED_CRYPTO; } gcry_cipher_open(&hd, algo, mode, GCRY_CIPHER_SECURE); @@ -268,11 +268,11 @@ omemo_decrypt_func(signal_buffer **output, int cipher, const uint8_t *key, size_ gcry_cipher_setkey(hd, key, key_len); switch (cipher) { - case SG_CIPHER_AES_CBC_PKCS5: - gcry_cipher_setiv(hd, iv, iv_len); - break; - default: - assert(FALSE); + case SG_CIPHER_AES_CBC_PKCS5: + gcry_cipher_setiv(hd, iv, iv_len); + break; + default: + assert(FALSE); } plaintext_len = ciphertext_len; @@ -280,11 +280,11 @@ omemo_decrypt_func(signal_buffer **output, int cipher, const uint8_t *key, size_ gcry_cipher_decrypt(hd, plaintext, plaintext_len, ciphertext, ciphertext_len); switch (cipher) { - case SG_CIPHER_AES_CBC_PKCS5: - padding = plaintext[plaintext_len - 1]; - break; - default: - assert(FALSE); + case SG_CIPHER_AES_CBC_PKCS5: + padding = plaintext[plaintext_len - 1]; + break; + default: + assert(FALSE); } int i; @@ -306,7 +306,7 @@ out: } int -aes128gcm_encrypt(unsigned char *ciphertext, size_t *ciphertext_len, unsigned char *tag, size_t *tag_len, const unsigned char *const plaintext, size_t plaintext_len, const unsigned char *const iv, const unsigned char *const key) +aes128gcm_encrypt(unsigned char* ciphertext, size_t* ciphertext_len, unsigned char* tag, size_t* tag_len, const unsigned char* const plaintext, size_t plaintext_len, const unsigned char* const iv, const unsigned char* const key) { gcry_error_t res; gcry_cipher_hd_t hd; @@ -340,7 +340,7 @@ out: } int -aes128gcm_decrypt(unsigned char *plaintext, size_t *plaintext_len, const unsigned char *const ciphertext, size_t ciphertext_len, const unsigned char *const iv, size_t iv_len, const unsigned char *const key, const unsigned char *const tag) +aes128gcm_decrypt(unsigned char* plaintext, size_t* plaintext_len, const unsigned char* const ciphertext, size_t ciphertext_len, const unsigned char* const iv, size_t iv_len, const unsigned char* const key, const unsigned char* const tag) { gcry_error_t res; gcry_cipher_hd_t hd; diff --git a/src/omemo/crypto.h b/src/omemo/crypto.h index d0cfdd05..4fb6283e 100644 --- a/src/omemo/crypto.h +++ b/src/omemo/crypto.h @@ -35,7 +35,7 @@ #include <signal/signal_protocol_types.h> #define AES128_GCM_KEY_LENGTH 16 -#define AES128_GCM_IV_LENGTH 12 +#define AES128_GCM_IV_LENGTH 12 #define AES128_GCM_TAG_LENGTH 16 int omemo_crypto_init(void); @@ -47,7 +47,7 @@ int omemo_crypto_init(void); * @param len size of the output buffer * @return 0 on success, negative on failure */ -int omemo_random_func(uint8_t *data, size_t len, void *user_data); +int omemo_random_func(uint8_t* data, size_t len, void* user_data); /** * Callback for an HMAC-SHA256 implementation. @@ -58,7 +58,7 @@ int omemo_random_func(uint8_t *data, size_t len, void *user_data); * @param key_len length of the key * @return 0 on success, negative on failure */ -int omemo_hmac_sha256_init_func(void **hmac_context, const uint8_t *key, size_t key_len, void *user_data); +int omemo_hmac_sha256_init_func(void** hmac_context, const uint8_t* key, size_t key_len, void* user_data); /** * Callback for an HMAC-SHA256 implementation. @@ -69,7 +69,7 @@ int omemo_hmac_sha256_init_func(void **hmac_context, const uint8_t *key, size_t * @param data_len length of the data * @return 0 on success, negative on failure */ -int omemo_hmac_sha256_update_func(void *hmac_context, const uint8_t *data, size_t data_len, void *user_data); +int omemo_hmac_sha256_update_func(void* hmac_context, const uint8_t* data, size_t data_len, void* user_data); /** * Callback for an HMAC-SHA256 implementation. @@ -80,7 +80,7 @@ int omemo_hmac_sha256_update_func(void *hmac_context, const uint8_t *data, size_ * @param output buffer to be allocated and populated with the result * @return 0 on success, negative on failure */ -int omemo_hmac_sha256_final_func(void *hmac_context, signal_buffer **output, void *user_data); +int omemo_hmac_sha256_final_func(void* hmac_context, signal_buffer** output, void* user_data); /** * Callback for an HMAC-SHA256 implementation. @@ -89,7 +89,7 @@ int omemo_hmac_sha256_final_func(void *hmac_context, signal_buffer **output, voi * * @param hmac_context private HMAC context pointer */ -void omemo_hmac_sha256_cleanup_func(void *hmac_context, void *user_data); +void omemo_hmac_sha256_cleanup_func(void* hmac_context, void* user_data); /** * Callback for a SHA512 message digest implementation. @@ -98,7 +98,7 @@ void omemo_hmac_sha256_cleanup_func(void *hmac_context, void *user_data); * @param digest_context private digest context pointer * @return 0 on success, negative on failure */ -int omemo_sha512_digest_init_func(void **digest_context, void *user_data); +int omemo_sha512_digest_init_func(void** digest_context, void* user_data); /** * Callback for a SHA512 message digest implementation. @@ -109,7 +109,7 @@ int omemo_sha512_digest_init_func(void **digest_context, void *user_data); * @param data_len length of the data * @return 0 on success, negative on failure */ -int omemo_sha512_digest_update_func(void *digest_context, const uint8_t *data, size_t data_len, void *user_data); +int omemo_sha512_digest_update_func(void* digest_context, const uint8_t* data, size_t data_len, void* user_data); /** * Callback for a SHA512 message digest implementation. @@ -120,7 +120,7 @@ int omemo_sha512_digest_update_func(void *digest_context, const uint8_t *data, s * @param output buffer to be allocated and populated with the result * @return 0 on success, negative on failure */ -int omemo_sha512_digest_final_func(void *digest_context, signal_buffer **output, void *user_data); +int omemo_sha512_digest_final_func(void* digest_context, signal_buffer** output, void* user_data); /** * Callback for a SHA512 message digest implementation. @@ -129,7 +129,7 @@ int omemo_sha512_digest_final_func(void *digest_context, signal_buffer **output, * * @param digest_context private digest context pointer */ -void omemo_sha512_digest_cleanup_func(void *digest_context, void *user_data); +void omemo_sha512_digest_cleanup_func(void* digest_context, void* user_data); /** * Callback for an AES encryption implementation. @@ -144,12 +144,12 @@ void omemo_sha512_digest_cleanup_func(void *digest_context, void *user_data); * @param plaintext_len length of the plaintext * @return 0 on success, negative on failure */ -int omemo_encrypt_func(signal_buffer **output, - int cipher, - const uint8_t *key, size_t key_len, - const uint8_t *iv, size_t iv_len, - const uint8_t *plaintext, size_t plaintext_len, - void *user_data); +int omemo_encrypt_func(signal_buffer** output, + int cipher, + const uint8_t* key, size_t key_len, + const uint8_t* iv, size_t iv_len, + const uint8_t* plaintext, size_t plaintext_len, + void* user_data); /** * Callback for an AES decryption implementation. @@ -164,19 +164,19 @@ int omemo_encrypt_func(signal_buffer **output, * @param ciphertext_len length of the ciphertext * @return 0 on success, negative on failure */ -int omemo_decrypt_func(signal_buffer **output, - int cipher, - const uint8_t *key, size_t key_len, - const uint8_t *iv, size_t iv_len, - const uint8_t *ciphertext, size_t ciphertext_len, - void *user_data); +int omemo_decrypt_func(signal_buffer** output, + int cipher, + const uint8_t* key, size_t key_len, + const uint8_t* iv, size_t iv_len, + const uint8_t* ciphertext, size_t ciphertext_len, + void* user_data); -int aes128gcm_encrypt(unsigned char *ciphertext, size_t *ciphertext_len, - unsigned char *tag, size_t *tag_len, - const unsigned char *const plaintext, size_t plaintext_len, - const unsigned char *const iv, const unsigned char *const key); +int aes128gcm_encrypt(unsigned char* ciphertext, size_t* ciphertext_len, + unsigned char* tag, size_t* tag_len, + const unsigned char* const plaintext, size_t plaintext_len, + const unsigned char* const iv, const unsigned char* const key); -int aes128gcm_decrypt(unsigned char *plaintext, - size_t *plaintext_len, const unsigned char *const ciphertext, - size_t ciphertext_len, const unsigned char *const iv, size_t iv_len, - const unsigned char *const key, const unsigned char *const tag); +int aes128gcm_decrypt(unsigned char* plaintext, + size_t* plaintext_len, const unsigned char* const ciphertext, + size_t ciphertext_len, const unsigned char* const iv, size_t iv_len, + const unsigned char* const key, const unsigned char* const tag); diff --git a/src/omemo/omemo.c b/src/omemo/omemo.c index 09782d66..6ab117fe 100644 --- a/src/omemo/omemo.c +++ b/src/omemo/omemo.c @@ -33,19 +33,19 @@ * source files in the program, then also delete it here. * */ -#include <sys/time.h> #include <sys/stat.h> +#include <sys/time.h> #include <assert.h> #include <errno.h> +#include <gcrypt.h> #include <glib.h> #include <pthread.h> #include <signal/key_helper.h> #include <signal/protocol.h> -#include <signal/signal_protocol.h> #include <signal/session_builder.h> #include <signal/session_cipher.h> -#include <gcrypt.h> +#include <signal/signal_protocol.h> #include "config/account.h" #include "config/files.h" @@ -70,44 +70,45 @@ static gboolean _load_identity(void); static void _load_trust(void); static void _load_sessions(void); static void _load_known_devices(void); -static void _lock(void *user_data); -static void _unlock(void *user_data); -static void _omemo_log(int level, const char *message, size_t len, void *user_data); -static gboolean _handle_own_device_list(const char *const jid, GList *device_list); -static gboolean _handle_device_list_start_session(const char *const jid, GList *device_list); -static char * _omemo_fingerprint(ec_public_key *identity, gboolean formatted); -static unsigned char *_omemo_fingerprint_decode(const char *const fingerprint, size_t *len); -static char * _omemo_unformat_fingerprint(const char *const fingerprint_formatted); -static void _cache_device_identity(const char *const jid, uint32_t device_id, ec_public_key *identity); -static void _g_hash_table_free(GHashTable *hash_table); - -typedef gboolean (*OmemoDeviceListHandler)(const char *const jid, GList *device_list); - -struct omemo_context_t { +static void _lock(void* user_data); +static void _unlock(void* user_data); +static void _omemo_log(int level, const char* message, size_t len, void* user_data); +static gboolean _handle_own_device_list(const char* const jid, GList* device_list); +static gboolean _handle_device_list_start_session(const char* const jid, GList* device_list); +static char* _omemo_fingerprint(ec_public_key* identity, gboolean formatted); +static unsigned char* _omemo_fingerprint_decode(const char* const fingerprint, size_t* len); +static char* _omemo_unformat_fingerprint(const char* const fingerprint_formatted); +static void _cache_device_identity(const char* const jid, uint32_t device_id, ec_public_key* identity); +static void _g_hash_table_free(GHashTable* hash_table); + +typedef gboolean (*OmemoDeviceListHandler)(const char* const jid, GList* device_list); + +struct omemo_context_t +{ pthread_mutexattr_t attr; pthread_mutex_t lock; - signal_context *signal; + signal_context* signal; uint32_t device_id; - GHashTable *device_list; - GHashTable *device_list_handler; - ratchet_identity_key_pair *identity_key_pair; + GHashTable* device_list; + GHashTable* device_list_handler; + ratchet_identity_key_pair* identity_key_pair; uint32_t registration_id; uint32_t signed_pre_key_id; - signal_protocol_store_context *store; - GHashTable *session_store; - GHashTable *pre_key_store; - GHashTable *signed_pre_key_store; + signal_protocol_store_context* store; + GHashTable* session_store; + GHashTable* pre_key_store; + GHashTable* signed_pre_key_store; identity_key_store_t identity_key_store; - GString *identity_filename; - GKeyFile *identity_keyfile; - GString *trust_filename; - GKeyFile *trust_keyfile; - GString *sessions_filename; - GKeyFile *sessions_keyfile; - GHashTable *known_devices; - GString *known_devices_filename; - GKeyFile *known_devices_keyfile; - GHashTable *fingerprint_ac; + GString* identity_filename; + GKeyFile* identity_keyfile; + GString* trust_filename; + GKeyFile* trust_keyfile; + GString* sessions_filename; + GKeyFile* sessions_keyfile; + GHashTable* known_devices; + GString* known_devices_filename; + GKeyFile* known_devices_keyfile; + GHashTable* fingerprint_ac; }; static omemo_context omemo_ctx; @@ -137,9 +138,9 @@ omemo_close(void) } void -omemo_on_connect(ProfAccount *account) +omemo_on_connect(ProfAccount* account) { - GError *error = NULL; + GError* error = NULL; if (signal_context_create(&omemo_ctx.signal, &omemo_ctx) != 0) { cons_show("Error initializing OMEMO context"); @@ -220,13 +221,12 @@ omemo_on_connect(ProfAccount *account) }; signal_protocol_store_context_set_identity_key_store(omemo_ctx.store, &identity_key_store); - loaded = FALSE; omemo_ctx.device_list = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)g_list_free); omemo_ctx.device_list_handler = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL); omemo_ctx.known_devices = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)_g_hash_table_free); - gchar *omemo_dir = files_get_account_data_path(DIR_OMEMO, account->jid); + gchar* omemo_dir = files_get_account_data_path(DIR_OMEMO, account->jid); omemo_ctx.identity_filename = g_string_new(omemo_dir); g_string_append(omemo_ctx.identity_filename, "/identity.txt"); @@ -237,11 +237,10 @@ omemo_on_connect(ProfAccount *account) omemo_ctx.known_devices_filename = g_string_new(omemo_dir); g_string_append(omemo_ctx.known_devices_filename, "/known_devices.txt"); - errno = 0; int res = g_mkdir_with_parents(omemo_dir, S_IRWXU); if (res == -1) { - char *errmsg = strerror(errno); + char* errmsg = strerror(errno); if (errmsg) { log_error("OMEMO: error creating directory: %s, %s", omemo_dir, errmsg); } else { @@ -312,7 +311,7 @@ omemo_on_disconnect(void) } void -omemo_generate_crypto_materials(ProfAccount *account) +omemo_generate_crypto_materials(ProfAccount* account) { if (loaded) { return; @@ -330,12 +329,12 @@ omemo_generate_crypto_materials(ProfAccount *account) signal_protocol_key_helper_generate_identity_key_pair(&omemo_ctx.identity_key_pair, omemo_ctx.signal); ec_public_key_serialize(&omemo_ctx.identity_key_store.public, ratchet_identity_key_pair_get_public(omemo_ctx.identity_key_pair)); - char *identity_key_public = g_base64_encode(signal_buffer_data(omemo_ctx.identity_key_store.public), signal_buffer_len(omemo_ctx.identity_key_store.public)); + char* identity_key_public = g_base64_encode(signal_buffer_data(omemo_ctx.identity_key_store.public), signal_buffer_len(omemo_ctx.identity_key_store.public)); g_key_file_set_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PUBLIC, identity_key_public); g_free(identity_key_public); ec_private_key_serialize(&omemo_ctx.identity_key_store.private, ratchet_identity_key_pair_get_private(omemo_ctx.identity_key_pair)); - char *identity_key_private = g_base64_encode(signal_buffer_data(omemo_ctx.identity_key_store.private), signal_buffer_len(omemo_ctx.identity_key_store.private)); + char* identity_key_private = g_base64_encode(signal_buffer_data(omemo_ctx.identity_key_store.private), signal_buffer_len(omemo_ctx.identity_key_store.private)); g_key_file_set_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PRIVATE, identity_key_private); g_free(identity_key_private); @@ -365,7 +364,7 @@ omemo_publish_crypto_materials(void) return; } - char *barejid = connection_get_barejid(); + char* barejid = connection_get_barejid(); /* Ensure we get our current device list, and it gets updated with our * device_id */ @@ -380,12 +379,12 @@ omemo_publish_crypto_materials(void) void omemo_start_sessions(void) { - GSList *contacts = roster_get_contacts(ROSTER_ORD_NAME); + GSList* contacts = roster_get_contacts(ROSTER_ORD_NAME); if (contacts) { - GSList *curr; - for (curr = contacts; curr != NULL; curr = g_slist_next(curr)){ + GSList* curr; + for (curr = contacts; curr != NULL; curr = g_slist_next(curr)) { PContact contact = curr->data; - const char *jid = p_contact_barejid(contact); + const char* jid = p_contact_barejid(contact); omemo_start_session(jid); } g_slist_free(contacts); @@ -393,11 +392,11 @@ omemo_start_sessions(void) } void -omemo_start_session(const char *const barejid) +omemo_start_session(const char* const barejid) { - if( omemo_loaded() ) { + if (omemo_loaded()) { log_info("OMEMO: start session with %s", barejid); - GList *device_list = g_hash_table_lookup(omemo_ctx.device_list, barejid); + GList* device_list = g_hash_table_lookup(omemo_ctx.device_list, barejid); if (!device_list) { log_info("OMEMO: missing device list for %s", barejid); omemo_devicelist_request(barejid); @@ -405,7 +404,7 @@ omemo_start_session(const char *const barejid) return; } - GList *device_id; + GList* device_id; for (device_id = device_list; device_id != NULL; device_id = device_id->next) { omemo_bundle_request(barejid, GPOINTER_TO_INT(device_id->data), omemo_start_device_session_handle_bundle, free, strdup(barejid)); } @@ -413,12 +412,12 @@ omemo_start_session(const char *const barejid) } void -omemo_start_muc_sessions(const char *const roomjid) +omemo_start_muc_sessions(const char* const roomjid) { - GList *members = muc_members(roomjid); - GList *iter; + GList* members = muc_members(roomjid); + GList* iter; for (iter = members; iter != NULL; iter = iter->next) { - Jid *jid = jid_create(iter->data); + Jid* jid = jid_create(iter->data); omemo_start_session(jid->barejid); jid_destroy(jid); } @@ -438,9 +437,9 @@ omemo_device_id(void) } void -omemo_identity_key(unsigned char **output, size_t *length) +omemo_identity_key(unsigned char** output, size_t* length) { - signal_buffer *buffer = NULL; + signal_buffer* buffer = NULL; ec_public_key_serialize(&buffer, ratchet_identity_key_pair_get_public(omemo_ctx.identity_key_pair)); *length = signal_buffer_len(buffer); *output = malloc(*length); @@ -449,10 +448,10 @@ omemo_identity_key(unsigned char **output, size_t *length) } void -omemo_signed_prekey(unsigned char **output, size_t *length) +omemo_signed_prekey(unsigned char** output, size_t* length) { - session_signed_pre_key *signed_pre_key; - signal_buffer *buffer = NULL; + session_signed_pre_key* signed_pre_key; + signal_buffer* buffer = NULL; if (signal_protocol_signed_pre_key_load_key(omemo_ctx.store, &signed_pre_key, omemo_ctx.signed_pre_key_id) != SG_SUCCESS) { *output = NULL; @@ -469,9 +468,9 @@ omemo_signed_prekey(unsigned char **output, size_t *length) } void -omemo_signed_prekey_signature(unsigned char **output, size_t *length) +omemo_signed_prekey_signature(unsigned char** output, size_t* length) { - session_signed_pre_key *signed_pre_key; + session_signed_pre_key* signed_pre_key; if (signal_protocol_signed_pre_key_load_key(omemo_ctx.store, &signed_pre_key, omemo_ctx.signed_pre_key_id) != SG_SUCCESS) { *output = NULL; @@ -486,25 +485,25 @@ omemo_signed_prekey_signature(unsigned char **output, size_t *length) } void -omemo_prekeys(GList **prekeys, GList **ids, GList **lengths) +omemo_prekeys(GList** prekeys, GList** ids, GList** lengths) { GHashTableIter iter; gpointer id; g_hash_table_iter_init(&iter, omemo_ctx.pre_key_store); while (g_hash_table_iter_next(&iter, &id, NULL)) { - session_pre_key *pre_key; + session_pre_key* pre_key; int ret; ret = signal_protocol_pre_key_load_key(omemo_ctx.store, &pre_key, GPOINTER_TO_INT(id)); if (ret != SG_SUCCESS) { continue; } - signal_buffer *public_key; + signal_buffer* public_key; ec_public_key_serialize(&public_key, ec_key_pair_get_public(session_pre_key_get_key_pair(pre_key))); SIGNAL_UNREF(pre_key); size_t length = signal_buffer_len(public_key); - unsigned char *prekey_value = malloc(length); + unsigned char* prekey_value = malloc(length); memcpy(prekey_value, signal_buffer_data(public_key), length); signal_buffer_free(public_key); @@ -515,9 +514,9 @@ omemo_prekeys(GList **prekeys, GList **ids, GList **lengths) } void -omemo_set_device_list(const char *const from, GList * device_list) +omemo_set_device_list(const char* const from, GList* device_list) { - Jid *jid; + Jid* jid; if (from) { jid = jid_create(from); } else { @@ -537,7 +536,7 @@ omemo_set_device_list(const char *const from, GList * device_list) jid_destroy(jid); } -GKeyFile * +GKeyFile* omemo_identity_keyfile(void) { return omemo_ctx.identity_keyfile; @@ -546,14 +545,14 @@ omemo_identity_keyfile(void) void omemo_identity_keyfile_save(void) { - GError *error = NULL; + GError* error = NULL; if (!g_key_file_save_to_file(omemo_ctx.identity_keyfile, omemo_ctx.identity_filename->str, &error)) { log_error("OMEMO: error saving identity to: %s, %s", omemo_ctx.identity_filename->str, error->message); } } -GKeyFile * +GKeyFile* omemo_trust_keyfile(void) { return omemo_ctx.trust_keyfile; @@ -562,14 +561,14 @@ omemo_trust_keyfile(void) void omemo_trust_keyfile_save(void) { - GError *error = NULL; + GError* error = NULL; if (!g_key_file_save_to_file(omemo_ctx.trust_keyfile, omemo_ctx.trust_filename->str, &error)) { log_error("OMEMO: error saving trust to: %s, %s", omemo_ctx.trust_filename->str, error->message); } } -GKeyFile * +GKeyFile* omemo_sessions_keyfile(void) { return omemo_ctx.sessions_keyfile; @@ -578,7 +577,7 @@ omemo_sessions_keyfile(void) void omemo_sessions_keyfile_save(void) { - GError *error = NULL; + GError* error = NULL; if (!g_key_file_save_to_file(omemo_ctx.sessions_keyfile, omemo_ctx.sessions_filename->str, &error)) { log_error("OMEMO: error saving sessions to: %s, %s", omemo_ctx.sessions_filename->str, error->message); @@ -588,7 +587,7 @@ omemo_sessions_keyfile_save(void) void omemo_known_devices_keyfile_save(void) { - GError *error = NULL; + GError* error = NULL; if (!g_key_file_save_to_file(omemo_ctx.known_devices_keyfile, omemo_ctx.known_devices_filename->str, &error)) { log_error("OMEMO: error saving known devices to: %s, %s", omemo_ctx.known_devices_filename->str, error->message); @@ -596,11 +595,11 @@ omemo_known_devices_keyfile_save(void) } void -omemo_start_device_session(const char *const jid, uint32_t device_id, - GList *prekeys, uint32_t signed_prekey_id, - const unsigned char *const signed_prekey_raw, size_t signed_prekey_len, - const unsigned char *const signature, size_t signature_len, - const unsigned char *const identity_key_raw, size_t identity_key_len) +omemo_start_device_session(const char* const jid, uint32_t device_id, + GList* prekeys, uint32_t signed_prekey_id, + const unsigned char* const signed_prekey_raw, size_t signed_prekey_len, + const unsigned char* const signature, size_t signature_len, + const unsigned char* const identity_key_raw, size_t identity_key_len) { signal_protocol_address address = { .name = jid, @@ -608,11 +607,11 @@ omemo_start_device_session(const char *const jid, uint32_t device_id, .device_id = device_id, }; - ec_public_key *identity_key; + ec_public_key* identity_key; curve_decode_point(&identity_key, identity_key_raw, identity_key_len, omemo_ctx.signal); _cache_device_identity(jid, device_id, identity_key); - gboolean trusted = is_trusted_identity(&address, (uint8_t *)identity_key_raw, identity_key_len, &omemo_ctx.identity_key_store); + gboolean trusted = is_trusted_identity(&address, (uint8_t*)identity_key_raw, identity_key_len, &omemo_ctx.identity_key_store); if (!trusted) { goto out; @@ -620,15 +619,15 @@ omemo_start_device_session(const char *const jid, uint32_t device_id, if (!contains_session(&address, omemo_ctx.session_store)) { int res; - session_pre_key_bundle *bundle; - signal_protocol_address *address; + session_pre_key_bundle* bundle; + signal_protocol_address* address; address = malloc(sizeof(signal_protocol_address)); address->name = strdup(jid); address->name_len = strlen(jid); address->device_id = device_id; - session_builder *builder; + session_builder* builder; res = session_builder_create(&builder, omemo_ctx.store, address, omemo_ctx.signal); if (res != 0) { log_error("OMEMO: cannot create session builder for %s device %d", jid, device_id); @@ -638,11 +637,11 @@ omemo_start_device_session(const char *const jid, uint32_t device_id, int prekey_index; gcry_randomize(&prekey_index, sizeof(int), GCRY_STRONG_RANDOM); prekey_index %= g_list_length(prekeys); - omemo_key_t *prekey = g_list_nth_data(prekeys, prekey_index); + omemo_key_t* prekey = g_list_nth_data(prekeys, prekey_index); - ec_public_key *prekey_public; + ec_public_key* prekey_public; curve_decode_point(&prekey_public, prekey->data, prekey->length, omemo_ctx.signal); - ec_public_key *signed_prekey; + ec_public_key* signed_prekey; curve_decode_point(&signed_prekey, signed_prekey_raw, signed_prekey_len, omemo_ctx.signal); res = session_pre_key_bundle_create(&bundle, 0, device_id, prekey->id, prekey_public, signed_prekey_id, signed_prekey, signature, signature_len, identity_key); @@ -664,19 +663,19 @@ out: SIGNAL_UNREF(identity_key); } -char * -omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_receipt, gboolean muc, const char *const replace_id) +char* +omemo_on_message_send(ProfWin* win, const char* const message, gboolean request_receipt, gboolean muc, const char* const replace_id) { - char *id = NULL; + char* id = NULL; int res; - Jid *jid = jid_create(connection_get_fulljid()); - GList *keys = NULL; - - unsigned char *key; - unsigned char *iv; - unsigned char *ciphertext; - unsigned char *tag; - unsigned char *key_tag; + Jid* jid = jid_create(connection_get_fulljid()); + GList* keys = NULL; + + unsigned char* key; + unsigned char* iv; + unsigned char* ciphertext; + unsigned char* tag; + unsigned char* key_tag; size_t ciphertext_len, tag_len; ciphertext_len = strlen(message); @@ -688,7 +687,7 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ key = gcry_random_bytes_secure(AES128_GCM_KEY_LENGTH, GCRY_VERY_STRONG_RANDOM); iv = gcry_random_bytes_secure(AES128_GCM_IV_LENGTH, GCRY_VERY_STRONG_RANDOM); - res = aes128gcm_encrypt(ciphertext, &ciphertext_len, tag, &tag_len, (const unsigned char * const)message, strlen(message), iv, key); + res = aes128gcm_encrypt(ciphertext, &ciphertext_len, tag, &tag_len, (const unsigned char* const)message, strlen(message), iv, key); if (res != 0) { log_error("OMEMO: cannot encrypt message"); goto out; @@ -697,31 +696,31 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ memcpy(key_tag, key, AES128_GCM_KEY_LENGTH); memcpy(key_tag + AES128_GCM_KEY_LENGTH, tag, AES128_GCM_TAG_LENGTH); - GList *recipients = NULL; + GList* recipients = NULL; if (muc) { - ProfMucWin *mucwin = (ProfMucWin *)win; + ProfMucWin* mucwin = (ProfMucWin*)win; assert(mucwin->memcheck == PROFMUCWIN_MEMCHECK); - GList *members = muc_members(mucwin->roomjid); - GList *iter; + GList* members = muc_members(mucwin->roomjid); + GList* iter; for (iter = members; iter != NULL; iter = iter->next) { - Jid *jid = jid_create(iter->data); + Jid* jid = jid_create(iter->data); recipients = g_list_append(recipients, strdup(jid->barejid)); jid_destroy(jid); } g_list_free(members); } else { - ProfChatWin *chatwin = (ProfChatWin *)win; + ProfChatWin* chatwin = (ProfChatWin*)win; assert(chatwin->memcheck == PROFCHATWIN_MEMCHECK); recipients = g_list_append(recipients, strdup(chatwin->barejid)); } - GList *device_ids_iter; + GList* device_ids_iter; omemo_ctx.identity_key_store.recv = false; - GList *recipients_iter; + GList* recipients_iter; for (recipients_iter = recipients; recipients_iter != NULL; recipients_iter = recipients_iter->next) { - GList *recipient_device_id = NULL; + GList* recipient_device_id = NULL; recipient_device_id = g_hash_table_lookup(omemo_ctx.device_list, recipients_iter->data); if (!recipient_device_id) { log_warning("OMEMO: cannot find device ids for %s", recipients_iter->data); @@ -730,8 +729,8 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ for (device_ids_iter = recipient_device_id; device_ids_iter != NULL; device_ids_iter = device_ids_iter->next) { int res; - ciphertext_message *ciphertext; - session_cipher *cipher; + ciphertext_message* ciphertext; + session_cipher* cipher; signal_protocol_address address = { .name = recipients_iter->data, .name_len = strlen(recipients_iter->data), @@ -750,8 +749,8 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ log_error("OMEMO: cannot encrypt key for %s device id %d", address.name, address.device_id); continue; } - signal_buffer *buffer = ciphertext_message_get_serialized(ciphertext); - omemo_key_t *key = malloc(sizeof(omemo_key_t)); + signal_buffer* buffer = ciphertext_message_get_serialized(ciphertext); + omemo_key_t* key = malloc(sizeof(omemo_key_t)); key->length = signal_buffer_len(buffer); key->data = malloc(key->length); memcpy(key->data, signal_buffer_data(buffer), key->length); @@ -765,11 +764,11 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ g_list_free_full(recipients, free); if (!muc) { - GList *sender_device_id = g_hash_table_lookup(omemo_ctx.device_list, jid->barejid); + GList* sender_device_id = g_hash_table_lookup(omemo_ctx.device_list, jid->barejid); for (device_ids_iter = sender_device_id; device_ids_iter != NULL; device_ids_iter = device_ids_iter->next) { int res; - ciphertext_message *ciphertext; - session_cipher *cipher; + ciphertext_message* ciphertext; + session_cipher* cipher; signal_protocol_address address = { .name = jid->barejid, .name_len = strlen(jid->barejid), @@ -788,8 +787,8 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ log_error("OMEMO: cannot encrypt key for %s device id %d", address.name, address.device_id); continue; } - signal_buffer *buffer = ciphertext_message_get_serialized(ciphertext); - omemo_key_t *key = malloc(sizeof(omemo_key_t)); + signal_buffer* buffer = ciphertext_message_get_serialized(ciphertext); + omemo_key_t* key = malloc(sizeof(omemo_key_t)); key->length = signal_buffer_len(buffer); key->data = malloc(key->length); memcpy(key->data, signal_buffer_data(buffer), key->length); @@ -801,11 +800,11 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ } if (muc) { - ProfMucWin *mucwin = (ProfMucWin *)win; + ProfMucWin* mucwin = (ProfMucWin*)win; assert(mucwin->memcheck == PROFMUCWIN_MEMCHECK); id = message_send_chat_omemo(mucwin->roomjid, omemo_ctx.device_id, keys, iv, AES128_GCM_IV_LENGTH, ciphertext, ciphertext_len, request_receipt, TRUE, replace_id); } else { - ProfChatWin *chatwin = (ProfChatWin *)win; + ProfChatWin* chatwin = (ProfChatWin*)win; assert(chatwin->memcheck == PROFCHATWIN_MEMCHECK); id = message_send_chat_omemo(chatwin->barejid, omemo_ctx.device_id, keys, iv, AES128_GCM_IV_LENGTH, ciphertext, ciphertext_len, request_receipt, FALSE, replace_id); } @@ -822,24 +821,24 @@ out: return id; } -char * -omemo_on_message_recv(const char *const from_jid, uint32_t sid, - const unsigned char *const iv, size_t iv_len, GList *keys, - const unsigned char *const payload, size_t payload_len, gboolean muc, gboolean *trusted) +char* +omemo_on_message_recv(const char* const from_jid, uint32_t sid, + const unsigned char* const iv, size_t iv_len, GList* keys, + const unsigned char* const payload, size_t payload_len, gboolean muc, gboolean* trusted) { - unsigned char *plaintext = NULL; - Jid *sender = NULL; - Jid *from = jid_create(from_jid); + unsigned char* plaintext = NULL; + Jid* sender = NULL; + Jid* from = jid_create(from_jid); if (!from) { log_error("Invalid jid %s", from_jid); goto out; } int res; - GList *key_iter; - omemo_key_t *key = NULL; + GList* key_iter; + omemo_key_t* key = NULL; for (key_iter = keys; key_iter != NULL; key_iter = key_iter->next) { - if (((omemo_key_t *)key_iter->data)->device_id == omemo_ctx.device_id) { + if (((omemo_key_t*)key_iter->data)->device_id == omemo_ctx.device_id) { key = key_iter->data; break; } @@ -851,10 +850,10 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, } if (muc) { - GList *roster = muc_roster(from->barejid); - GList *iter; + GList* roster = muc_roster(from->barejid); + GList* iter; for (iter = roster; iter != NULL; iter = iter->next) { - Occupant *occupant = (Occupant *)iter->data; + Occupant* occupant = (Occupant*)iter->data; if (g_strcmp0(occupant->nick, from->resourcepart) == 0) { sender = jid_create(occupant->jid); break; @@ -869,8 +868,8 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, sender = jid_create(from->barejid); } - session_cipher *cipher; - signal_buffer *plaintext_key; + session_cipher* cipher; + signal_buffer* plaintext_key; signal_protocol_address address = { .name = sender->barejid, .name_len = strlen(sender->barejid), @@ -885,9 +884,9 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, if (key->prekey) { log_debug("OMEMO: decrypting message with prekey"); - pre_key_signal_message *message; - ec_public_key *their_identity_key; - signal_buffer *identity_buffer = NULL; + pre_key_signal_message* message; + ec_public_key* their_identity_key; + signal_buffer* identity_buffer = NULL; omemo_ctx.identity_key_store.recv = true; @@ -901,12 +900,12 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, /* Perform a real check of the identity */ ec_public_key_serialize(&identity_buffer, their_identity_key); *trusted = is_trusted_identity(&address, signal_buffer_data(identity_buffer), - signal_buffer_len(identity_buffer), &omemo_ctx.identity_key_store); + signal_buffer_len(identity_buffer), &omemo_ctx.identity_key_store); /* Replace used pre_key in bundle */ uint32_t pre_key_id = pre_key_signal_message_get_pre_key_id(message); - ec_key_pair *ec_pair; - session_pre_key *new_pre_key; + ec_key_pair* ec_pair; + session_pre_key* new_pre_key; curve_generate_key_pair(omemo_ctx.signal, &ec_pair); session_pre_key_create(&new_pre_key, pre_key_id, ec_pair); signal_protocol_pre_key_store_key(omemo_ctx.store, new_pre_key); @@ -921,7 +920,7 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, } } else { log_debug("OMEMO: decrypting message with existing session"); - signal_message *message = NULL; + signal_message* message = NULL; res = signal_message_deserialize(&message, key->data, key->length, omemo_ctx.signal); @@ -949,8 +948,8 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, size_t plaintext_len = payload_len; plaintext = malloc(plaintext_len + 1); res = aes128gcm_decrypt(plaintext, &plaintext_len, payload, payload_len, iv, - iv_len, signal_buffer_data(plaintext_key), - signal_buffer_data(plaintext_key) + AES128_GCM_KEY_LENGTH); + iv_len, signal_buffer_data(plaintext_key), + signal_buffer_data(plaintext_key) + AES128_GCM_KEY_LENGTH); signal_buffer_free(plaintext_key); if (res != 0) { log_error("OMEMO: cannot decrypt message: %s", gcry_strerror(res)); @@ -964,13 +963,13 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, out: jid_destroy(from); jid_destroy(sender); - return (char *)plaintext; + return (char*)plaintext; } -char * -omemo_format_fingerprint(const char *const fingerprint) +char* +omemo_format_fingerprint(const char* const fingerprint) { - char *output = malloc(strlen(fingerprint) + strlen(fingerprint) / 8); + char* output = malloc(strlen(fingerprint) + strlen(fingerprint) / 8); int i, j; for (i = 0, j = 0; i < strlen(fingerprint); i++) { @@ -985,11 +984,11 @@ omemo_format_fingerprint(const char *const fingerprint) return output; } -static char * -_omemo_unformat_fingerprint(const char *const fingerprint_formatted) +static char* +_omemo_unformat_fingerprint(const char* const fingerprint_formatted) { /* Unformat fingerprint */ - char *fingerprint = malloc(strlen(fingerprint_formatted)); + char* fingerprint = malloc(strlen(fingerprint_formatted)); int i; int j; for (i = 0, j = 0; fingerprint_formatted[i] != '\0'; i++) { @@ -1004,17 +1003,17 @@ _omemo_unformat_fingerprint(const char *const fingerprint_formatted) return fingerprint; } -char * +char* omemo_own_fingerprint(gboolean formatted) { - ec_public_key *identity = ratchet_identity_key_pair_get_public(omemo_ctx.identity_key_pair); + ec_public_key* identity = ratchet_identity_key_pair_get_public(omemo_ctx.identity_key_pair); return _omemo_fingerprint(identity, formatted); } -GList * -omemo_known_device_identities(const char *const jid) +GList* +omemo_known_device_identities(const char* const jid) { - GHashTable *known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); + GHashTable* known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); if (!known_identities) { return NULL; } @@ -1023,14 +1022,14 @@ omemo_known_device_identities(const char *const jid) } gboolean -omemo_is_trusted_identity(const char *const jid, const char *const fingerprint) +omemo_is_trusted_identity(const char* const jid, const char* const fingerprint) { - GHashTable *known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); + GHashTable* known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); if (!known_identities) { return FALSE; } - void *device_id = g_hash_table_lookup(known_identities, fingerprint); + void* device_id = g_hash_table_lookup(known_identities, fingerprint); if (!device_id) { return FALSE; } @@ -1042,9 +1041,9 @@ omemo_is_trusted_identity(const char *const jid, const char *const fingerprint) }; size_t fingerprint_len; - unsigned char *fingerprint_raw = _omemo_fingerprint_decode(fingerprint, &fingerprint_len); - unsigned char djb_type[] = {'\x05'}; - signal_buffer *buffer = signal_buffer_create(djb_type, 1); + unsigned char* fingerprint_raw = _omemo_fingerprint_decode(fingerprint, &fingerprint_len); + unsigned char djb_type[] = { '\x05' }; + signal_buffer* buffer = signal_buffer_create(djb_type, 1); buffer = signal_buffer_append(buffer, fingerprint_raw, fingerprint_len); gboolean trusted = is_trusted_identity(&address, signal_buffer_data(buffer), signal_buffer_len(buffer), &omemo_ctx.identity_key_store); @@ -1055,21 +1054,21 @@ omemo_is_trusted_identity(const char *const jid, const char *const fingerprint) return trusted; } -static char * -_omemo_fingerprint(ec_public_key *identity, gboolean formatted) +static char* +_omemo_fingerprint(ec_public_key* identity, gboolean formatted) { int i; - signal_buffer *identity_public_key; + signal_buffer* identity_public_key; ec_public_key_serialize(&identity_public_key, identity); size_t identity_public_key_len = signal_buffer_len(identity_public_key); - unsigned char *identity_public_key_data = signal_buffer_data(identity_public_key); + unsigned char* identity_public_key_data = signal_buffer_data(identity_public_key); /* Skip first byte corresponding to signal DJB_TYPE */ identity_public_key_len--; identity_public_key_data = &identity_public_key_data[1]; - char *fingerprint = malloc(identity_public_key_len * 2 + 1); + char* fingerprint = malloc(identity_public_key_len * 2 + 1); for (i = 0; i < identity_public_key_len; i++) { fingerprint[i * 2] = (identity_public_key_data[i] & 0xf0) >> 4; @@ -1091,16 +1090,16 @@ _omemo_fingerprint(ec_public_key *identity, gboolean formatted) if (!formatted) { return fingerprint; } else { - char *formatted_fingerprint = omemo_format_fingerprint(fingerprint); + char* formatted_fingerprint = omemo_format_fingerprint(fingerprint); free(fingerprint); return formatted_fingerprint; } } -static unsigned char * -_omemo_fingerprint_decode(const char *const fingerprint, size_t *len) +static unsigned char* +_omemo_fingerprint_decode(const char* const fingerprint, size_t* len) { - unsigned char *output = malloc(strlen(fingerprint) / 2 + 1); + unsigned char* output = malloc(strlen(fingerprint) / 2 + 1); int i; int j; @@ -1121,18 +1120,18 @@ _omemo_fingerprint_decode(const char *const fingerprint, size_t *len) } void -omemo_trust(const char *const jid, const char *const fingerprint_formatted) +omemo_trust(const char* const jid, const char* const fingerprint_formatted) { size_t len; - GHashTable *known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); + GHashTable* known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); if (!known_identities) { log_warning("OMEMO: cannot trust unknown device: %s", fingerprint_formatted); cons_show("Cannot trust unknown device: %s", fingerprint_formatted); return; } - char *fingerprint = _omemo_unformat_fingerprint(fingerprint_formatted); + char* fingerprint = _omemo_unformat_fingerprint(fingerprint_formatted); uint32_t device_id = GPOINTER_TO_INT(g_hash_table_lookup(known_identities, fingerprint)); free(fingerprint); @@ -1152,9 +1151,9 @@ omemo_trust(const char *const jid, const char *const fingerprint_formatted) .device_id = device_id, }; - unsigned char *fingerprint_raw = _omemo_fingerprint_decode(fingerprint_formatted, &len); - unsigned char djb_type[] = {'\x05'}; - signal_buffer *buffer = signal_buffer_create(djb_type, 1); + unsigned char* fingerprint_raw = _omemo_fingerprint_decode(fingerprint_formatted, &len); + unsigned char djb_type[] = { '\x05' }; + signal_buffer* buffer = signal_buffer_create(djb_type, 1); buffer = signal_buffer_append(buffer, fingerprint_raw, len); save_identity(&address, signal_buffer_data(buffer), signal_buffer_len(buffer), &omemo_ctx.identity_key_store); free(fingerprint_raw); @@ -1164,15 +1163,15 @@ omemo_trust(const char *const jid, const char *const fingerprint_formatted) } void -omemo_untrust(const char *const jid, const char *const fingerprint_formatted) +omemo_untrust(const char* const jid, const char* const fingerprint_formatted) { size_t len; - unsigned char *identity = _omemo_fingerprint_decode(fingerprint_formatted, &len); + unsigned char* identity = _omemo_fingerprint_decode(fingerprint_formatted, &len); GHashTableIter iter; gpointer key, value; - GHashTable *trusted = g_hash_table_lookup(omemo_ctx.identity_key_store.trusted, jid); + GHashTable* trusted = g_hash_table_lookup(omemo_ctx.identity_key_store.trusted, jid); if (!trusted) { free(identity); return; @@ -1180,8 +1179,8 @@ omemo_untrust(const char *const jid, const char *const fingerprint_formatted) g_hash_table_iter_init(&iter, trusted); while (g_hash_table_iter_next(&iter, &key, &value)) { - signal_buffer *buffer = value; - unsigned char *original = signal_buffer_data(buffer); + signal_buffer* buffer = value; + unsigned char* original = signal_buffer_data(buffer); /* Skip DJB_TYPE byte */ original++; if ((signal_buffer_len(buffer) - 1) == len && memcmp(original, identity, len) == 0) { @@ -1190,10 +1189,10 @@ omemo_untrust(const char *const jid, const char *const fingerprint_formatted) } free(identity); - char *fingerprint = _omemo_unformat_fingerprint(fingerprint_formatted); + char* fingerprint = _omemo_unformat_fingerprint(fingerprint_formatted); /* Remove existing session */ - GHashTable *known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); + GHashTable* known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); if (!known_identities) { log_error("OMEMO: cannot find known device while untrusting a fingerprint"); goto out; @@ -1213,7 +1212,7 @@ omemo_untrust(const char *const jid, const char *const fingerprint_formatted) delete_session(&address, omemo_ctx.session_store); /* Remove from keyfile */ - char *device_id_str = g_strdup_printf("%d", device_id); + char* device_id_str = g_strdup_printf("%d", device_id); g_key_file_remove_key(omemo_ctx.trust_keyfile, jid, device_id_str, NULL); g_free(device_id_str); omemo_trust_keyfile_save(); @@ -1223,41 +1222,41 @@ out: } static void -_lock(void *user_data) +_lock(void* user_data) { - omemo_context *ctx = (omemo_context *)user_data; + omemo_context* ctx = (omemo_context*)user_data; pthread_mutex_lock(&ctx->lock); } static void -_unlock(void *user_data) +_unlock(void* user_data) { - omemo_context *ctx = (omemo_context *)user_data; + omemo_context* ctx = (omemo_context*)user_data; pthread_mutex_unlock(&ctx->lock); } static void -_omemo_log(int level, const char *message, size_t len, void *user_data) +_omemo_log(int level, const char* message, size_t len, void* user_data) { switch (level) { - case SG_LOG_ERROR: - log_error("OMEMO: %s", message); - break; - case SG_LOG_WARNING: - log_warning("OMEMO: %s", message); - break; - case SG_LOG_NOTICE: - case SG_LOG_INFO: - log_info("OMEMO: %s", message); - break; - case SG_LOG_DEBUG: - log_debug("OMEMO: %s", message); - break; + case SG_LOG_ERROR: + log_error("OMEMO: %s", message); + break; + case SG_LOG_WARNING: + log_warning("OMEMO: %s", message); + break; + case SG_LOG_NOTICE: + case SG_LOG_INFO: + log_info("OMEMO: %s", message); + break; + case SG_LOG_DEBUG: + log_debug("OMEMO: %s", message); + break; } } static gboolean -_handle_own_device_list(const char *const jid, GList *device_list) +_handle_own_device_list(const char* const jid, GList* device_list) { if (!g_list_find(device_list, GINT_TO_POINTER(omemo_ctx.device_id))) { device_list = g_list_copy(device_list); @@ -1266,7 +1265,7 @@ _handle_own_device_list(const char *const jid, GList *device_list) omemo_devicelist_publish(device_list); } - GList *device_id; + GList* device_id; for (device_id = device_list; device_id != NULL; device_id = device_id->next) { omemo_bundle_request(jid, GPOINTER_TO_INT(device_id->data), omemo_start_device_session_handle_bundle, free, strdup(jid)); } @@ -1275,7 +1274,7 @@ _handle_own_device_list(const char *const jid, GList *device_list) } static gboolean -_handle_device_list_start_session(const char *const jid, GList *device_list) +_handle_device_list_start_session(const char* const jid, GList* device_list) { omemo_start_session(jid); @@ -1283,7 +1282,7 @@ _handle_device_list_start_session(const char *const jid, GList *device_list) } void -omemo_key_free(omemo_key_t *key) +omemo_key_free(omemo_key_t* key) { if (key == NULL) { return; @@ -1294,7 +1293,7 @@ omemo_key_free(omemo_key_t *key) } char* -omemo_fingerprint_autocomplete(const char *const search_str, gboolean previous, void *context) +omemo_fingerprint_autocomplete(const char* const search_str, gboolean previous, void* context) { Autocomplete ac = g_hash_table_lookup(omemo_ctx.fingerprint_ac, context); if (ac != NULL) { @@ -1318,11 +1317,11 @@ omemo_fingerprint_autocomplete_reset(void) } gboolean -omemo_automatic_start(const char *const recipient) +omemo_automatic_start(const char* const recipient) { gboolean result = FALSE; - char *account_name = session_get_account_name(); - ProfAccount *account = accounts_get_account(account_name); + char* account_name = session_get_account_name(); + ProfAccount* account = accounts_get_account(account_name); prof_omemopolicy_t policy; if (account->omemo_policy) { @@ -1338,7 +1337,7 @@ omemo_automatic_start(const char *const recipient) } } else { // check global setting - char *pref_omemo_policy = prefs_get_string(PREF_OMEMO_POLICY); + char* pref_omemo_policy = prefs_get_string(PREF_OMEMO_POLICY); // pref defaults to manual policy = PROF_OMEMOPOLICY_AUTOMATIC; @@ -1353,25 +1352,25 @@ omemo_automatic_start(const char *const recipient) } switch (policy) { - case PROF_OMEMOPOLICY_MANUAL: + case PROF_OMEMOPOLICY_MANUAL: + result = FALSE; + break; + case PROF_OMEMOPOLICY_AUTOMATIC: + if (g_list_find_custom(account->omemo_enabled, recipient, (GCompareFunc)g_strcmp0)) { + result = TRUE; + } else if (g_list_find_custom(account->omemo_disabled, recipient, (GCompareFunc)g_strcmp0)) { result = FALSE; - break; - case PROF_OMEMOPOLICY_AUTOMATIC: - if (g_list_find_custom(account->omemo_enabled, recipient, (GCompareFunc)g_strcmp0)) { - result = TRUE; - } else if (g_list_find_custom(account->omemo_disabled, recipient, (GCompareFunc)g_strcmp0)) { - result = FALSE; - } else { - result = FALSE; - } - break; - case PROF_OMEMOPOLICY_ALWAYS: - if (g_list_find_custom(account->omemo_disabled, recipient, (GCompareFunc)g_strcmp0)) { - result = FALSE; - } else { - result = TRUE; - } - break; + } else { + result = FALSE; + } + break; + case PROF_OMEMOPOLICY_ALWAYS: + if (g_list_find_custom(account->omemo_disabled, recipient, (GCompareFunc)g_strcmp0)) { + result = FALSE; + } else { + result = TRUE; + } + break; } account_free(account); @@ -1381,7 +1380,7 @@ omemo_automatic_start(const char *const recipient) static gboolean _load_identity(void) { - GError *error = NULL; + GError* error = NULL; log_info("Loading OMEMO identity"); /* Device ID */ @@ -1403,50 +1402,50 @@ _load_identity(void) /* Identity key */ error = NULL; - char *identity_key_public_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PUBLIC, &error); + char* identity_key_public_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PUBLIC, &error); if (!identity_key_public_b64) { log_error("OMEMO: cannot load identity public key: %s", error->message); return FALSE; } size_t identity_key_public_len; - unsigned char *identity_key_public = g_base64_decode(identity_key_public_b64, &identity_key_public_len); + unsigned char* identity_key_public = g_base64_decode(identity_key_public_b64, &identity_key_public_len); g_free(identity_key_public_b64); omemo_ctx.identity_key_store.public = signal_buffer_create(identity_key_public, identity_key_public_len); error = NULL; - char *identity_key_private_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PRIVATE, &error); + char* identity_key_private_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PRIVATE, &error); if (!identity_key_private_b64) { log_error("OMEMO: cannot load identity private key: %s", error->message); return FALSE; } size_t identity_key_private_len; - unsigned char *identity_key_private = g_base64_decode(identity_key_private_b64, &identity_key_private_len); + unsigned char* identity_key_private = g_base64_decode(identity_key_private_b64, &identity_key_private_len); g_free(identity_key_private_b64); omemo_ctx.identity_key_store.private = signal_buffer_create(identity_key_private, identity_key_private_len); - ec_public_key *public_key; + ec_public_key* public_key; curve_decode_point(&public_key, identity_key_public, identity_key_public_len, omemo_ctx.signal); - ec_private_key *private_key; + ec_private_key* private_key; curve_decode_private_point(&private_key, identity_key_private, identity_key_private_len, omemo_ctx.signal); ratchet_identity_key_pair_create(&omemo_ctx.identity_key_pair, public_key, private_key); g_free(identity_key_public); g_free(identity_key_private); - char **keys = NULL; + char** keys = NULL; int i; /* Pre keys */ i = 0; keys = g_key_file_get_keys(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_PREKEYS, NULL, NULL); if (keys) { for (i = 0; keys[i] != NULL; i++) { - char *pre_key_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_PREKEYS, keys[i], NULL); + char* pre_key_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_PREKEYS, keys[i], NULL); size_t pre_key_len; - unsigned char *pre_key = g_base64_decode(pre_key_b64, &pre_key_len); + unsigned char* pre_key = g_base64_decode(pre_key_b64, &pre_key_len); g_free(pre_key_b64); - signal_buffer *buffer = signal_buffer_create(pre_key, pre_key_len); + signal_buffer* buffer = signal_buffer_create(pre_key, pre_key_len); g_free(pre_key); g_hash_table_insert(omemo_ctx.pre_key_store, GINT_TO_POINTER(strtoul(keys[i], NULL, 10)), buffer); } @@ -1464,11 +1463,11 @@ _load_identity(void) keys = g_key_file_get_keys(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_SIGNED_PREKEYS, NULL, NULL); if (keys) { for (i = 0; keys[i] != NULL; i++) { - char *signed_pre_key_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_SIGNED_PREKEYS, keys[i], NULL); + char* signed_pre_key_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_SIGNED_PREKEYS, keys[i], NULL); size_t signed_pre_key_len; - unsigned char *signed_pre_key = g_base64_decode(signed_pre_key_b64, &signed_pre_key_len); + unsigned char* signed_pre_key = g_base64_decode(signed_pre_key_b64, &signed_pre_key_len); g_free(signed_pre_key_b64); - signal_buffer *buffer = signal_buffer_create(signed_pre_key, signed_pre_key_len); + signal_buffer* buffer = signal_buffer_create(signed_pre_key, signed_pre_key_len); g_free(signed_pre_key); g_hash_table_insert(omemo_ctx.signed_pre_key_store, GINT_TO_POINTER(strtoul(keys[i], NULL, 10)), buffer); omemo_ctx.signed_pre_key_id = strtoul(keys[i], NULL, 10); @@ -1491,12 +1490,12 @@ _load_identity(void) static void _load_trust(void) { - char **keys = NULL; - char **groups = g_key_file_get_groups(omemo_ctx.trust_keyfile, NULL); + char** keys = NULL; + char** groups = g_key_file_get_groups(omemo_ctx.trust_keyfile, NULL); if (groups) { int i; for (i = 0; groups[i] != NULL; i++) { - GHashTable *trusted; + GHashTable* trusted; trusted = g_hash_table_lookup(omemo_ctx.identity_key_store.trusted, groups[i]); if (!trusted) { @@ -1507,11 +1506,11 @@ _load_trust(void) keys = g_key_file_get_keys(omemo_ctx.trust_keyfile, groups[i], NULL, NULL); int j; for (j = 0; keys[j] != NULL; j++) { - char *key_b64 = g_key_file_get_string(omemo_ctx.trust_keyfile, groups[i], keys[j], NULL); + char* key_b64 = g_key_file_get_string(omemo_ctx.trust_keyfile, groups[i], keys[j], NULL); size_t key_len; - unsigned char *key = g_base64_decode(key_b64, &key_len); + unsigned char* key = g_base64_decode(key_b64, &key_len); g_free(key_b64); - signal_buffer *buffer = signal_buffer_create(key, key_len); + signal_buffer* buffer = signal_buffer_create(key, key_len); g_free(key); uint32_t device_id = strtoul(keys[j], NULL, 10); g_hash_table_insert(trusted, GINT_TO_POINTER(device_id), buffer); @@ -1526,11 +1525,11 @@ static void _load_sessions(void) { int i; - char **groups = g_key_file_get_groups(omemo_ctx.sessions_keyfile, NULL); + char** groups = g_key_file_get_groups(omemo_ctx.sessions_keyfile, NULL); if (groups) { for (i = 0; groups[i] != NULL; i++) { int j; - GHashTable *device_store = NULL; + GHashTable* device_store = NULL; device_store = g_hash_table_lookup(omemo_ctx.session_store, groups[i]); if (!device_store) { @@ -1538,14 +1537,14 @@ _load_sessions(void) g_hash_table_insert(omemo_ctx.session_store, strdup(groups[i]), device_store); } - char **keys = g_key_file_get_keys(omemo_ctx.sessions_keyfile, groups[i], NULL, NULL); + char** keys = g_key_file_get_keys(omemo_ctx.sessions_keyfile, groups[i], NULL, NULL); for (j = 0; keys[j] != NULL; j++) { uint32_t id = strtoul(keys[j], NULL, 10); - char *record_b64 = g_key_file_get_string(omemo_ctx.sessions_keyfile, groups[i], keys[j], NULL); + char* record_b64 = g_key_file_get_string(omemo_ctx.sessions_keyfile, groups[i], keys[j], NULL); size_t record_len; - unsigned char *record = g_base64_decode(record_b64, &record_len); + unsigned char* record = g_base64_decode(record_b64, &record_len); g_free(record_b64); - signal_buffer *buffer = signal_buffer_create(record, record_len); + signal_buffer* buffer = signal_buffer_create(record, record_len); g_free(record); g_hash_table_insert(device_store, GINT_TO_POINTER(id), buffer); } @@ -1559,11 +1558,11 @@ static void _load_known_devices(void) { int i; - char **groups = g_key_file_get_groups(omemo_ctx.known_devices_keyfile, NULL); + char** groups = g_key_file_get_groups(omemo_ctx.known_devices_keyfile, NULL); if (groups) { for (i = 0; groups[i] != NULL; i++) { int j; - GHashTable *known_identities = NULL; + GHashTable* known_identities = NULL; known_identities = g_hash_table_lookup(omemo_ctx.known_devices, groups[i]); if (!known_identities) { @@ -1571,10 +1570,10 @@ _load_known_devices(void) g_hash_table_insert(omemo_ctx.known_devices, strdup(groups[i]), known_identities); } - char **keys = g_key_file_get_keys(omemo_ctx.known_devices_keyfile, groups[i], NULL, NULL); + char** keys = g_key_file_get_keys(omemo_ctx.known_devices_keyfile, groups[i], NULL, NULL); for (j = 0; keys[j] != NULL; j++) { uint32_t device_id = strtoul(keys[j], NULL, 10); - char *fingerprint = g_key_file_get_string(omemo_ctx.known_devices_keyfile, groups[i], keys[j], NULL); + char* fingerprint = g_key_file_get_string(omemo_ctx.known_devices_keyfile, groups[i], keys[j], NULL); g_hash_table_insert(known_identities, strdup(fingerprint), GINT_TO_POINTER(device_id)); g_free(fingerprint); } @@ -1585,19 +1584,19 @@ _load_known_devices(void) } static void -_cache_device_identity(const char *const jid, uint32_t device_id, ec_public_key *identity) +_cache_device_identity(const char* const jid, uint32_t device_id, ec_public_key* identity) { - GHashTable *known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); + GHashTable* known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); if (!known_identities) { known_identities = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL); g_hash_table_insert(omemo_ctx.known_devices, strdup(jid), known_identities); } - char *fingerprint = _omemo_fingerprint(identity, FALSE); + char* fingerprint = _omemo_fingerprint(identity, FALSE); log_info("OMEMO: cache identity for %s:%d: %s", jid, device_id, fingerprint); g_hash_table_insert(known_identities, strdup(fingerprint), GINT_TO_POINTER(device_id)); - char *device_id_str = g_strdup_printf("%d", device_id); + char* device_id_str = g_strdup_printf("%d", device_id); g_key_file_set_string(omemo_ctx.known_devices_keyfile, jid, device_id_str, fingerprint); g_free(device_id_str); omemo_known_devices_keyfile_save(); @@ -1608,14 +1607,14 @@ _cache_device_identity(const char *const jid, uint32_t device_id, ec_public_key g_hash_table_insert(omemo_ctx.fingerprint_ac, strdup(jid), ac); } - char *formatted_fingerprint = omemo_format_fingerprint(fingerprint); + char* formatted_fingerprint = omemo_format_fingerprint(fingerprint); autocomplete_add(ac, formatted_fingerprint); free(formatted_fingerprint); free(fingerprint); } static void -_g_hash_table_free(GHashTable *hash_table) +_g_hash_table_free(GHashTable* hash_table) { g_hash_table_remove_all(hash_table); g_hash_table_unref(hash_table); @@ -1626,12 +1625,12 @@ _generate_pre_keys(int count) { unsigned int start; gcry_randomize(&start, sizeof(unsigned int), GCRY_VERY_STRONG_RANDOM); - signal_protocol_key_helper_pre_key_list_node *pre_keys_head; + signal_protocol_key_helper_pre_key_list_node* pre_keys_head; signal_protocol_key_helper_generate_pre_keys(&pre_keys_head, start, count, omemo_ctx.signal); - signal_protocol_key_helper_pre_key_list_node *p; + signal_protocol_key_helper_pre_key_list_node* p; for (p = pre_keys_head; p != NULL; p = signal_protocol_key_helper_key_list_next(p)) { - session_pre_key *prekey = signal_protocol_key_helper_key_list_element(p); + session_pre_key* prekey = signal_protocol_key_helper_key_list_element(p); signal_protocol_pre_key_store_key(omemo_ctx.store, prekey); } signal_protocol_key_helper_key_list_free(pre_keys_head); @@ -1640,7 +1639,7 @@ _generate_pre_keys(int count) static void _generate_signed_pre_key(void) { - session_signed_pre_key *signed_pre_key; + session_signed_pre_key* signed_pre_key; struct timeval tv; gettimeofday(&tv, NULL); unsigned long long timestamp = (unsigned long long)(tv.tv_sec) * 1000 + (unsigned long long)(tv.tv_usec) / 1000; diff --git a/src/omemo/omemo.h b/src/omemo/omemo.h index 740654a2..f56bdd68 100644 --- a/src/omemo/omemo.h +++ b/src/omemo/omemo.h @@ -34,11 +34,11 @@ */ #include <glib.h> -#include "ui/ui.h" #include "config/account.h" +#include "ui/ui.h" #define OMEMO_ERR_UNSUPPORTED_CRYPTO -10000 -#define OMEMO_ERR_GCRYPT -20000 +#define OMEMO_ERR_GCRYPT -20000 typedef enum { PROF_OMEMOPOLICY_MANUAL, @@ -48,8 +48,9 @@ typedef enum { typedef struct omemo_context_t omemo_context; -typedef struct omemo_key { - unsigned char *data; +typedef struct omemo_key +{ + unsigned char* data; size_t length; gboolean prekey; uint32_t device_id; @@ -58,39 +59,39 @@ typedef struct omemo_key { void omemo_init(void); void omemo_close(void); -void omemo_on_connect(ProfAccount *account); +void omemo_on_connect(ProfAccount* account); void omemo_on_disconnect(void); -void omemo_generate_crypto_materials(ProfAccount *account); -void omemo_key_free(omemo_key_t *key); +void omemo_generate_crypto_materials(ProfAccount* account); +void omemo_key_free(omemo_key_t* key); void omemo_publish_crypto_materials(void); uint32_t omemo_device_id(void); -void omemo_identity_key(unsigned char **output, size_t *length); -void omemo_signed_prekey(unsigned char **output, size_t *length); -void omemo_signed_prekey_signature(unsigned char **output, size_t *length); -void omemo_prekeys(GList **prekeys, GList **ids, GList **lengths); -void omemo_set_device_list(const char *const jid, GList * device_list); -GKeyFile *omemo_identity_keyfile(void); +void omemo_identity_key(unsigned char** output, size_t* length); +void omemo_signed_prekey(unsigned char** output, size_t* length); +void omemo_signed_prekey_signature(unsigned char** output, size_t* length); +void omemo_prekeys(GList** prekeys, GList** ids, GList** lengths); +void omemo_set_device_list(const char* const jid, GList* device_list); +GKeyFile* omemo_identity_keyfile(void); void omemo_identity_keyfile_save(void); -GKeyFile *omemo_trust_keyfile(void); +GKeyFile* omemo_trust_keyfile(void); void omemo_trust_keyfile_save(void); -GKeyFile *omemo_sessions_keyfile(void); +GKeyFile* omemo_sessions_keyfile(void); void omemo_sessions_keyfile_save(void); -char *omemo_format_fingerprint(const char *const fingerprint); -char *omemo_own_fingerprint(gboolean formatted); -void omemo_trust(const char *const jid, const char *const fingerprint); -void omemo_untrust(const char *const jid, const char *const fingerprint); -GList *omemo_known_device_identities(const char *const jid); -gboolean omemo_is_trusted_identity(const char *const jid, const char *const fingerprint); -char *omemo_fingerprint_autocomplete(const char *const search_str, gboolean previous, void *context); +char* omemo_format_fingerprint(const char* const fingerprint); +char* omemo_own_fingerprint(gboolean formatted); +void omemo_trust(const char* const jid, const char* const fingerprint); +void omemo_untrust(const char* const jid, const char* const fingerprint); +GList* omemo_known_device_identities(const char* const jid); +gboolean omemo_is_trusted_identity(const char* const jid, const char* const fingerprint); +char* omemo_fingerprint_autocomplete(const char* const search_str, gboolean previous, void* context); void omemo_fingerprint_autocomplete_reset(void); -gboolean omemo_automatic_start(const char *const recipient); +gboolean omemo_automatic_start(const char* const recipient); void omemo_start_sessions(void); -void omemo_start_session(const char *const barejid); -void omemo_start_muc_sessions(const char *const roomjid); -void omemo_start_device_session(const char *const jid, uint32_t device_id, GList *prekeys, uint32_t signed_prekey_id, const unsigned char *const signed_prekey, size_t signed_prekey_len, const unsigned char *const signature, size_t signature_len, const unsigned char *const identity_key, size_t identity_key_len); +void omemo_start_session(const char* const barejid); +void omemo_start_muc_sessions(const char* const roomjid); +void omemo_start_device_session(const char* const jid, uint32_t device_id, GList* prekeys, uint32_t signed_prekey_id, const unsigned char* const signed_prekey, size_t signed_prekey_len, const unsigned char* const signature, size_t signature_len, const unsigned char* const identity_key, size_t identity_key_len); gboolean omemo_loaded(void); -char * omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_receipt, gboolean muc, const char *const replace_id); -char * omemo_on_message_recv(const char *const from, uint32_t sid, const unsigned char *const iv, size_t iv_len, GList *keys, const unsigned char *const payload, size_t payload_len, gboolean muc, gboolean *trusted); +char* omemo_on_message_send(ProfWin* win, const char* const message, gboolean request_receipt, gboolean muc, const char* const replace_id); +char* omemo_on_message_recv(const char* const from, uint32_t sid, const unsigned char* const iv, size_t iv_len, GList* keys, const unsigned char* const payload, size_t payload_len, gboolean muc, gboolean* trusted); diff --git a/src/omemo/store.c b/src/omemo/store.c index ec39ed1b..434483ed 100644 --- a/src/omemo/store.c +++ b/src/omemo/store.c @@ -39,28 +39,28 @@ #include "omemo/omemo.h" #include "omemo/store.h" -static void _g_hash_table_free(GHashTable *hash_table); +static void _g_hash_table_free(GHashTable* hash_table); -GHashTable * +GHashTable* session_store_new(void) { return g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)_g_hash_table_free); } -GHashTable * +GHashTable* pre_key_store_new(void) { return g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)signal_buffer_free); } -GHashTable * +GHashTable* signed_pre_key_store_new(void) { return g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)signal_buffer_free); } void -identity_key_store_new(identity_key_store_t *identity_key_store) +identity_key_store_new(identity_key_store_t* identity_key_store) { identity_key_store->trusted = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)signal_buffer_free); identity_key_store->private = NULL; @@ -69,16 +69,16 @@ identity_key_store_new(identity_key_store_t *identity_key_store) #ifdef HAVE_LIBSIGNAL_LT_2_3_2 int -load_session(signal_buffer **record, const signal_protocol_address *address, - void *user_data) +load_session(signal_buffer** record, const signal_protocol_address* address, + void* user_data) #else int -load_session(signal_buffer **record, signal_buffer **user_record, - const signal_protocol_address *address, void *user_data) +load_session(signal_buffer** record, signal_buffer** user_record, + const signal_protocol_address* address, void* user_data) #endif { - GHashTable *session_store = (GHashTable *)user_data; - GHashTable *device_store = NULL; + GHashTable* session_store = (GHashTable*)user_data; + GHashTable* device_store = NULL; device_store = g_hash_table_lookup(session_store, address->name); if (!device_store) { @@ -86,7 +86,7 @@ load_session(signal_buffer **record, signal_buffer **user_record, return 0; } - signal_buffer *original = g_hash_table_lookup(device_store, GINT_TO_POINTER(address->device_id)); + signal_buffer* original = g_hash_table_lookup(device_store, GINT_TO_POINTER(address->device_id)); if (!original) { *record = NULL; return 0; @@ -96,11 +96,11 @@ load_session(signal_buffer **record, signal_buffer **user_record, } int -get_sub_device_sessions(signal_int_list **sessions, const char *name, - size_t name_len, void *user_data) +get_sub_device_sessions(signal_int_list** sessions, const char* name, + size_t name_len, void* user_data) { - GHashTable *session_store = (GHashTable *)user_data; - GHashTable *device_store = NULL; + GHashTable* session_store = (GHashTable*)user_data; + GHashTable* device_store = NULL; GHashTableIter iter; gpointer key, value; @@ -115,37 +115,35 @@ get_sub_device_sessions(signal_int_list **sessions, const char *name, signal_int_list_push_back(*sessions, GPOINTER_TO_INT(key)); } - return SG_SUCCESS; } #ifdef HAVE_LIBSIGNAL_LT_2_3_2 int -store_session(const signal_protocol_address *address, uint8_t *record, - size_t record_len, void *user_data) +store_session(const signal_protocol_address* address, uint8_t* record, + size_t record_len, void* user_data) #else int -store_session(const signal_protocol_address *address, - uint8_t *record, size_t record_len, - uint8_t *user_record, size_t user_record_len, - void *user_data) +store_session(const signal_protocol_address* address, + uint8_t* record, size_t record_len, + uint8_t* user_record, size_t user_record_len, + void* user_data) #endif { - GHashTable *session_store = (GHashTable *)user_data; - GHashTable *device_store = NULL; + GHashTable* session_store = (GHashTable*)user_data; + GHashTable* device_store = NULL; - device_store = g_hash_table_lookup(session_store, (void *)address->name); + device_store = g_hash_table_lookup(session_store, (void*)address->name); if (!device_store) { device_store = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)signal_buffer_free); g_hash_table_insert(session_store, strdup(address->name), device_store); } - signal_buffer *buffer = signal_buffer_create(record, record_len); + signal_buffer* buffer = signal_buffer_create(record, record_len); g_hash_table_insert(device_store, GINT_TO_POINTER(address->device_id), buffer); - - char *record_b64 = g_base64_encode(record, record_len); - char *device_id = g_strdup_printf("%d", address->device_id); + char* record_b64 = g_base64_encode(record, record_len); + char* device_id = g_strdup_printf("%d", address->device_id); g_key_file_set_string(omemo_sessions_keyfile(), address->name, device_id, record_b64); free(device_id); g_free(record_b64); @@ -156,10 +154,10 @@ store_session(const signal_protocol_address *address, } int -contains_session(const signal_protocol_address *address, void *user_data) +contains_session(const signal_protocol_address* address, void* user_data) { - GHashTable *session_store = (GHashTable *)user_data; - GHashTable *device_store = NULL; + GHashTable* session_store = (GHashTable*)user_data; + GHashTable* device_store = NULL; device_store = g_hash_table_lookup(session_store, address->name); if (!device_store) { @@ -174,10 +172,10 @@ contains_session(const signal_protocol_address *address, void *user_data) } int -delete_session(const signal_protocol_address *address, void *user_data) +delete_session(const signal_protocol_address* address, void* user_data) { - GHashTable *session_store = (GHashTable *)user_data; - GHashTable *device_store = NULL; + GHashTable* session_store = (GHashTable*)user_data; + GHashTable* device_store = NULL; device_store = g_hash_table_lookup(session_store, address->name); if (!device_store) { @@ -186,7 +184,7 @@ delete_session(const signal_protocol_address *address, void *user_data) g_hash_table_remove(device_store, GINT_TO_POINTER(address->device_id)); - char *device_id_str = g_strdup_printf("%d", address->device_id); + char* device_id_str = g_strdup_printf("%d", address->device_id); g_key_file_remove_key(omemo_sessions_keyfile(), address->name, device_id_str, NULL); g_free(device_id_str); omemo_sessions_keyfile_save(); @@ -195,10 +193,10 @@ delete_session(const signal_protocol_address *address, void *user_data) } int -delete_all_sessions(const char *name, size_t name_len, void *user_data) +delete_all_sessions(const char* name, size_t name_len, void* user_data) { - GHashTable *session_store = (GHashTable *)user_data; - GHashTable *device_store = NULL; + GHashTable* session_store = (GHashTable*)user_data; + GHashTable* device_store = NULL; device_store = g_hash_table_lookup(session_store, name); if (!device_store) { @@ -211,10 +209,10 @@ delete_all_sessions(const char *name, size_t name_len, void *user_data) } int -load_pre_key(signal_buffer **record, uint32_t pre_key_id, void *user_data) +load_pre_key(signal_buffer** record, uint32_t pre_key_id, void* user_data) { - signal_buffer *original; - GHashTable *pre_key_store = (GHashTable *)user_data; + signal_buffer* original; + GHashTable* pre_key_store = (GHashTable*)user_data; original = g_hash_table_lookup(pre_key_store, GINT_TO_POINTER(pre_key_id)); if (original == NULL) { @@ -226,17 +224,17 @@ load_pre_key(signal_buffer **record, uint32_t pre_key_id, void *user_data) } int -store_pre_key(uint32_t pre_key_id, uint8_t *record, size_t record_len, - void *user_data) +store_pre_key(uint32_t pre_key_id, uint8_t* record, size_t record_len, + void* user_data) { - GHashTable *pre_key_store = (GHashTable *)user_data; + GHashTable* pre_key_store = (GHashTable*)user_data; - signal_buffer *buffer = signal_buffer_create(record, record_len); + signal_buffer* buffer = signal_buffer_create(record, record_len); g_hash_table_insert(pre_key_store, GINT_TO_POINTER(pre_key_id), buffer); /* Long term storage */ - char *pre_key_id_str = g_strdup_printf("%d", pre_key_id); - char *record_b64 = g_base64_encode(record, record_len); + char* pre_key_id_str = g_strdup_printf("%d", pre_key_id); + char* record_b64 = g_base64_encode(record, record_len); g_key_file_set_string(omemo_identity_keyfile(), OMEMO_STORE_GROUP_PREKEYS, pre_key_id_str, record_b64); g_free(pre_key_id_str); g_free(record_b64); @@ -247,22 +245,22 @@ store_pre_key(uint32_t pre_key_id, uint8_t *record, size_t record_len, } int -contains_pre_key(uint32_t pre_key_id, void *user_data) +contains_pre_key(uint32_t pre_key_id, void* user_data) { - GHashTable *pre_key_store = (GHashTable *)user_data; + GHashTable* pre_key_store = (GHashTable*)user_data; return g_hash_table_lookup(pre_key_store, GINT_TO_POINTER(pre_key_id)) != NULL; } int -remove_pre_key(uint32_t pre_key_id, void *user_data) +remove_pre_key(uint32_t pre_key_id, void* user_data) { - GHashTable *pre_key_store = (GHashTable *)user_data; + GHashTable* pre_key_store = (GHashTable*)user_data; int ret = g_hash_table_remove(pre_key_store, GINT_TO_POINTER(pre_key_id)); /* Long term storage */ - char *pre_key_id_str = g_strdup_printf("%d", pre_key_id); + char* pre_key_id_str = g_strdup_printf("%d", pre_key_id); g_key_file_remove_key(omemo_identity_keyfile(), OMEMO_STORE_GROUP_PREKEYS, pre_key_id_str, NULL); g_free(pre_key_id_str); @@ -276,11 +274,11 @@ remove_pre_key(uint32_t pre_key_id, void *user_data) } int -load_signed_pre_key(signal_buffer **record, uint32_t signed_pre_key_id, - void *user_data) +load_signed_pre_key(signal_buffer** record, uint32_t signed_pre_key_id, + void* user_data) { - signal_buffer *original; - GHashTable *signed_pre_key_store = (GHashTable *)user_data; + signal_buffer* original; + GHashTable* signed_pre_key_store = (GHashTable*)user_data; original = g_hash_table_lookup(signed_pre_key_store, GINT_TO_POINTER(signed_pre_key_id)); if (!original) { @@ -292,17 +290,17 @@ load_signed_pre_key(signal_buffer **record, uint32_t signed_pre_key_id, } int -store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t *record, - size_t record_len, void *user_data) +store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t* record, + size_t record_len, void* user_data) { - GHashTable *signed_pre_key_store = (GHashTable *)user_data; + GHashTable* signed_pre_key_store = (GHashTable*)user_data; - signal_buffer *buffer = signal_buffer_create(record, record_len); + signal_buffer* buffer = signal_buffer_create(record, record_len); g_hash_table_insert(signed_pre_key_store, GINT_TO_POINTER(signed_pre_key_id), buffer); /* Long term storage */ - char *signed_pre_key_id_str = g_strdup_printf("%d", signed_pre_key_id); - char *record_b64 = g_base64_encode(record, record_len); + char* signed_pre_key_id_str = g_strdup_printf("%d", signed_pre_key_id); + char* record_b64 = g_base64_encode(record, record_len); g_key_file_set_string(omemo_identity_keyfile(), OMEMO_STORE_GROUP_SIGNED_PREKEYS, signed_pre_key_id_str, record_b64); g_free(signed_pre_key_id_str); g_free(record_b64); @@ -313,22 +311,22 @@ store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t *record, } int -contains_signed_pre_key(uint32_t signed_pre_key_id, void *user_data) +contains_signed_pre_key(uint32_t signed_pre_key_id, void* user_data) { - GHashTable *signed_pre_key_store = (GHashTable *)user_data; + GHashTable* signed_pre_key_store = (GHashTable*)user_data; return g_hash_table_lookup(signed_pre_key_store, GINT_TO_POINTER(signed_pre_key_id)) != NULL; } int -remove_signed_pre_key(uint32_t signed_pre_key_id, void *user_data) +remove_signed_pre_key(uint32_t signed_pre_key_id, void* user_data) { - GHashTable *signed_pre_key_store = (GHashTable *)user_data; + GHashTable* signed_pre_key_store = (GHashTable*)user_data; int ret = g_hash_table_remove(signed_pre_key_store, GINT_TO_POINTER(signed_pre_key_id)); /* Long term storage */ - char *signed_pre_key_id_str = g_strdup_printf("%d", signed_pre_key_id); + char* signed_pre_key_id_str = g_strdup_printf("%d", signed_pre_key_id); g_key_file_remove_key(omemo_identity_keyfile(), OMEMO_STORE_GROUP_PREKEYS, signed_pre_key_id_str, NULL); g_free(signed_pre_key_id_str); @@ -338,10 +336,10 @@ remove_signed_pre_key(uint32_t signed_pre_key_id, void *user_data) } int -get_identity_key_pair(signal_buffer **public_data, signal_buffer **private_data, - void *user_data) +get_identity_key_pair(signal_buffer** public_data, signal_buffer** private_data, + void* user_data) { - identity_key_store_t *identity_key_store = (identity_key_store_t *)user_data; + identity_key_store_t* identity_key_store = (identity_key_store_t*)user_data; *public_data = signal_buffer_copy(identity_key_store->public); *private_data = signal_buffer_copy(identity_key_store->private); @@ -350,9 +348,9 @@ get_identity_key_pair(signal_buffer **public_data, signal_buffer **private_data, } int -get_local_registration_id(void *user_data, uint32_t *registration_id) +get_local_registration_id(void* user_data, uint32_t* registration_id) { - identity_key_store_t *identity_key_store = (identity_key_store_t *)user_data; + identity_key_store_t* identity_key_store = (identity_key_store_t*)user_data; *registration_id = identity_key_store->registration_id; @@ -360,10 +358,10 @@ get_local_registration_id(void *user_data, uint32_t *registration_id) } int -save_identity(const signal_protocol_address *address, uint8_t *key_data, - size_t key_len, void *user_data) +save_identity(const signal_protocol_address* address, uint8_t* key_data, + size_t key_len, void* user_data) { - identity_key_store_t *identity_key_store = (identity_key_store_t *)user_data; + identity_key_store_t* identity_key_store = (identity_key_store_t*)user_data; if (identity_key_store->recv) { /* Do not trust identity automatically */ @@ -377,9 +375,9 @@ save_identity(const signal_protocol_address *address, uint8_t *key_data, } } - signal_buffer *buffer = signal_buffer_create(key_data, key_len); + signal_buffer* buffer = signal_buffer_create(key_data, key_len); - GHashTable *trusted = g_hash_table_lookup(identity_key_store->trusted, address->name); + GHashTable* trusted = g_hash_table_lookup(identity_key_store->trusted, address->name); if (!trusted) { trusted = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)signal_buffer_free); g_hash_table_insert(identity_key_store->trusted, strdup(address->name), trusted); @@ -387,8 +385,8 @@ save_identity(const signal_protocol_address *address, uint8_t *key_data, g_hash_table_insert(trusted, GINT_TO_POINTER(address->device_id), buffer); /* Long term storage */ - char *key_b64 = g_base64_encode(key_data, key_len); - char *device_id = g_strdup_printf("%d", address->device_id); + char* key_b64 = g_base64_encode(key_data, key_len); + char* device_id = g_strdup_printf("%d", address->device_id); g_key_file_set_string(omemo_trust_keyfile(), address->name, device_id, key_b64); g_free(device_id); g_free(key_b64); @@ -399,13 +397,13 @@ save_identity(const signal_protocol_address *address, uint8_t *key_data, } int -is_trusted_identity(const signal_protocol_address *address, uint8_t *key_data, - size_t key_len, void *user_data) +is_trusted_identity(const signal_protocol_address* address, uint8_t* key_data, + size_t key_len, void* user_data) { int ret; - identity_key_store_t *identity_key_store = (identity_key_store_t *)user_data; + identity_key_store_t* identity_key_store = (identity_key_store_t*)user_data; - GHashTable *trusted = g_hash_table_lookup(identity_key_store->trusted, address->name); + GHashTable* trusted = g_hash_table_lookup(identity_key_store->trusted, address->name); if (!trusted) { if (identity_key_store->recv) { return 1; @@ -414,14 +412,13 @@ is_trusted_identity(const signal_protocol_address *address, uint8_t *key_data, } } - signal_buffer *buffer = signal_buffer_create(key_data, key_len); - signal_buffer *original = g_hash_table_lookup(trusted, GINT_TO_POINTER(address->device_id)); + signal_buffer* buffer = signal_buffer_create(key_data, key_len); + signal_buffer* original = g_hash_table_lookup(trusted, GINT_TO_POINTER(address->device_id)); ret = original != NULL && signal_buffer_compare(buffer, original) == 0; signal_buffer_free(buffer); - if (identity_key_store->recv) { return 1; } else { @@ -430,23 +427,23 @@ is_trusted_identity(const signal_protocol_address *address, uint8_t *key_data, } int -store_sender_key(const signal_protocol_sender_key_name *sender_key_name, - uint8_t *record, size_t record_len, uint8_t *user_record, - size_t user_record_len, void *user_data) +store_sender_key(const signal_protocol_sender_key_name* sender_key_name, + uint8_t* record, size_t record_len, uint8_t* user_record, + size_t user_record_len, void* user_data) { return SG_SUCCESS; } int -load_sender_key(signal_buffer **record, signal_buffer **user_record, - const signal_protocol_sender_key_name *sender_key_name, - void *user_data) +load_sender_key(signal_buffer** record, signal_buffer** user_record, + const signal_protocol_sender_key_name* sender_key_name, + void* user_data) { return SG_SUCCESS; } static void -_g_hash_table_free(GHashTable *hash_table) +_g_hash_table_free(GHashTable* hash_table) { g_hash_table_remove_all(hash_table); g_hash_table_unref(hash_table); diff --git a/src/omemo/store.h b/src/omemo/store.h index 9b523fb6..f84db5ed 100644 --- a/src/omemo/store.h +++ b/src/omemo/store.h @@ -36,26 +36,27 @@ #include "config.h" -#define OMEMO_STORE_GROUP_IDENTITY "identity" -#define OMEMO_STORE_GROUP_PREKEYS "prekeys" -#define OMEMO_STORE_GROUP_SIGNED_PREKEYS "signed_prekeys" -#define OMEMO_STORE_KEY_DEVICE_ID "device_id" -#define OMEMO_STORE_KEY_REGISTRATION_ID "registration_id" -#define OMEMO_STORE_KEY_IDENTITY_KEY_PUBLIC "identity_key_public" +#define OMEMO_STORE_GROUP_IDENTITY "identity" +#define OMEMO_STORE_GROUP_PREKEYS "prekeys" +#define OMEMO_STORE_GROUP_SIGNED_PREKEYS "signed_prekeys" +#define OMEMO_STORE_KEY_DEVICE_ID "device_id" +#define OMEMO_STORE_KEY_REGISTRATION_ID "registration_id" +#define OMEMO_STORE_KEY_IDENTITY_KEY_PUBLIC "identity_key_public" #define OMEMO_STORE_KEY_IDENTITY_KEY_PRIVATE "identity_key_private" -typedef struct { - signal_buffer *public; - signal_buffer *private; - uint32_t registration_id; - GHashTable *trusted; - bool recv; +typedef struct +{ + signal_buffer* public; + signal_buffer* private; + uint32_t registration_id; + GHashTable* trusted; + bool recv; } identity_key_store_t; -GHashTable * session_store_new(void); -GHashTable * pre_key_store_new(void); -GHashTable * signed_pre_key_store_new(void); -void identity_key_store_new(identity_key_store_t *identity_key_store); +GHashTable* session_store_new(void); +GHashTable* pre_key_store_new(void); +GHashTable* signed_pre_key_store_new(void); +void identity_key_store_new(identity_key_store_t* identity_key_store); /** * Returns a copy of the serialized session record corresponding to the @@ -68,9 +69,9 @@ void identity_key_store_new(identity_key_store_t *identity_key_store); * @return 1 if the session was loaded, 0 if the session was not found, negative on failure */ #ifdef HAVE_LIBSIGNAL_LT_2_3_2 -int load_session(signal_buffer **record, const signal_protocol_address *address, void *user_data); +int load_session(signal_buffer** record, const signal_protocol_address* address, void* user_data); #else -int load_session(signal_buffer **record, signal_buffer **user_record, const signal_protocol_address *address, void *user_data); +int load_session(signal_buffer** record, signal_buffer** user_record, const signal_protocol_address* address, void* user_data); #endif /** @@ -81,7 +82,7 @@ int load_session(signal_buffer **record, signal_buffer **user_record, const sign * @param name_len the length of the name * @return size of the sessions array, or negative on failure */ -int get_sub_device_sessions(signal_int_list **sessions, const char *name, size_t name_len, void *user_data); +int get_sub_device_sessions(signal_int_list** sessions, const char* name, size_t name_len, void* user_data); /** * Commit to storage the session record for a given @@ -94,9 +95,9 @@ int get_sub_device_sessions(signal_int_list **sessions, const char *name, size_t * @return 0 on success, negative on failure */ #ifdef HAVE_LIBSIGNAL_LT_2_3_2 -int store_session(const signal_protocol_address *address, uint8_t *record, size_t record_len, void *user_data); +int store_session(const signal_protocol_address* address, uint8_t* record, size_t record_len, void* user_data); #else -int store_session(const signal_protocol_address *address, uint8_t *record, size_t record_len, uint8_t *user_record, size_t user_record_len, void *user_data); +int store_session(const signal_protocol_address* address, uint8_t* record, size_t record_len, uint8_t* user_record, size_t user_record_len, void* user_data); #endif /** @@ -106,7 +107,7 @@ int store_session(const signal_protocol_address *address, uint8_t *record, size_ * @param address the address of the remote client * @return 1 if a session record exists, 0 otherwise. */ -int contains_session(const signal_protocol_address *address, void *user_data); +int contains_session(const signal_protocol_address* address, void* user_data); /** * Remove a session record for a recipient ID + device ID tuple. @@ -114,7 +115,7 @@ int contains_session(const signal_protocol_address *address, void *user_data); * @param address the address of the remote client * @return 1 if a session was deleted, 0 if a session was not deleted, negative on error */ -int delete_session(const signal_protocol_address *address, void *user_data); +int delete_session(const signal_protocol_address* address, void* user_data); /** * Remove the session records corresponding to all devices of a recipient ID. @@ -123,7 +124,7 @@ int delete_session(const signal_protocol_address *address, void *user_data); * @param name_len the length of the name * @return the number of deleted sessions on success, negative on failure */ -int delete_all_sessions(const char *name, size_t name_len, void *user_data); +int delete_all_sessions(const char* name, size_t name_len, void* user_data); /** * Load a local serialized PreKey record. @@ -135,7 +136,7 @@ int delete_all_sessions(const char *name, size_t name_len, void *user_data); * @retval SG_SUCCESS if the key was found * @retval SG_ERR_INVALID_KEY_ID if the key could not be found */ -int load_pre_key(signal_buffer **record, uint32_t pre_key_id, void *user_data); +int load_pre_key(signal_buffer** record, uint32_t pre_key_id, void* user_data); /** * Store a local serialized PreKey record. @@ -145,7 +146,7 @@ int load_pre_key(signal_buffer **record, uint32_t pre_key_id, void *user_data); * @param record_len length of the serialized record * @return 0 on success, negative on failure */ -int store_pre_key(uint32_t pre_key_id, uint8_t *record, size_t record_len, void *user_data); +int store_pre_key(uint32_t pre_key_id, uint8_t* record, size_t record_len, void* user_data); /** * Determine whether there is a committed PreKey record matching the @@ -154,7 +155,7 @@ int store_pre_key(uint32_t pre_key_id, uint8_t *record, size_t record_len, void * @param pre_key_id A PreKey record ID. * @return 1 if the store has a record for the PreKey ID, 0 otherwise */ -int contains_pre_key(uint32_t pre_key_id, void *user_data); +int contains_pre_key(uint32_t pre_key_id, void* user_data); /** * Delete a PreKey record from local storage. @@ -162,7 +163,7 @@ int contains_pre_key(uint32_t pre_key_id, void *user_data); * @param pre_key_id The ID of the PreKey record to remove. * @return 0 on success, negative on failure */ -int remove_pre_key(uint32_t pre_key_id, void *user_data); +int remove_pre_key(uint32_t pre_key_id, void* user_data); /** * Load a local serialized signed PreKey record. @@ -174,7 +175,7 @@ int remove_pre_key(uint32_t pre_key_id, void *user_data); * @retval SG_SUCCESS if the key was found * @retval SG_ERR_INVALID_KEY_ID if the key could not be found */ -int load_signed_pre_key(signal_buffer **record, uint32_t signed_pre_key_id, void *user_data); +int load_signed_pre_key(signal_buffer** record, uint32_t signed_pre_key_id, void* user_data); /** * Store a local serialized signed PreKey record. @@ -184,7 +185,7 @@ int load_signed_pre_key(signal_buffer **record, uint32_t signed_pre_key_id, void * @param record_len length of the serialized record * @return 0 on success, negative on failure */ -int store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t *record, size_t record_len, void *user_data); +int store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t* record, size_t record_len, void* user_data); /** * Determine whether there is a committed signed PreKey record matching @@ -193,7 +194,7 @@ int store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t *record, size_t rec * @param signed_pre_key_id A signed PreKey record ID. * @return 1 if the store has a record for the signed PreKey ID, 0 otherwise */ -int contains_signed_pre_key(uint32_t signed_pre_key_id, void *user_data); +int contains_signed_pre_key(uint32_t signed_pre_key_id, void* user_data); /** * Delete a SignedPreKeyRecord from local storage. @@ -201,7 +202,7 @@ int contains_signed_pre_key(uint32_t signed_pre_key_id, void *user_data); * @param signed_pre_key_id The ID of the signed PreKey record to remove. * @return 0 on success, negative on failure */ -int remove_signed_pre_key(uint32_t signed_pre_key_id, void *user_data); +int remove_signed_pre_key(uint32_t signed_pre_key_id, void* user_data); /** * Get the local client's identity key pair. @@ -214,7 +215,7 @@ int remove_signed_pre_key(uint32_t signed_pre_key_id, void *user_data); * The Signal Protocol library is responsible for freeing this buffer. * @return 0 on success, negative on failure */ -int get_identity_key_pair(signal_buffer **public_data, signal_buffer **private_data, void *user_data); +int get_identity_key_pair(signal_buffer** public_data, signal_buffer** private_data, void* user_data); /** * Return the local client's registration ID. @@ -226,7 +227,7 @@ int get_identity_key_pair(signal_buffer **public_data, signal_buffer **private_d * registration ID, if it was successfully retrieved. * @return 0 on success, negative on failure */ -int get_local_registration_id(void *user_data, uint32_t *registration_id); +int get_local_registration_id(void* user_data, uint32_t* registration_id); /** * Save a remote client's identity key @@ -241,7 +242,7 @@ int get_local_registration_id(void *user_data, uint32_t *registration_id); * @param key_len Length of the remote client's identity key * @return 0 on success, negative on failure */ -int save_identity(const signal_protocol_address *address, uint8_t *key_data, size_t key_len, void *user_data); +int save_identity(const signal_protocol_address* address, uint8_t* key_data, size_t key_len, void* user_data); /** * Verify a remote client's identity key. @@ -259,7 +260,7 @@ int save_identity(const signal_protocol_address *address, uint8_t *key_data, siz * @param key_len Length of the identity key to verify * @return 1 if trusted, 0 if untrusted, negative on failure */ -int is_trusted_identity(const signal_protocol_address *address, uint8_t *key_data, size_t key_len, void *user_data); +int is_trusted_identity(const signal_protocol_address* address, uint8_t* key_data, size_t key_len, void* user_data); /** * Store a serialized sender key record for a given @@ -270,7 +271,7 @@ int is_trusted_identity(const signal_protocol_address *address, uint8_t *key_dat * @param record_len length of the serialized record * @return 0 on success, negative on failure */ -int store_sender_key(const signal_protocol_sender_key_name *sender_key_name, uint8_t *record, size_t record_len, uint8_t *user_record, size_t user_record_len, void *user_data); +int store_sender_key(const signal_protocol_sender_key_name* sender_key_name, uint8_t* record, size_t record_len, uint8_t* user_record, size_t user_record_len, void* user_data); /** * Returns a copy of the sender key record corresponding to the @@ -282,4 +283,4 @@ int store_sender_key(const signal_protocol_sender_key_name *sender_key_name, uin * @param sender_key_name the (groupId + senderId + deviceId) tuple * @return 1 if the record was loaded, 0 if the record was not found, negative on failure */ -int load_sender_key(signal_buffer **record, signal_buffer **user_record, const signal_protocol_sender_key_name *sender_key_name, void *user_data); +int load_sender_key(signal_buffer** record, signal_buffer** user_record, const signal_protocol_sender_key_name* sender_key_name, void* user_data); |