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, 519 insertions, 517 deletions
diff --git a/src/omemo/crypto.c b/src/omemo/crypto.c index 47477f8e..d062e058 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/crypto.h" #include "omemo/omemo.h" +#include "omemo/crypto.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 4fb6283e..d0cfdd05 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 6ab117fe..09782d66 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/stat.h> #include <sys/time.h> +#include <sys/stat.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 <signal/signal_protocol.h> +#include <gcrypt.h> #include "config/account.h" #include "config/files.h" @@ -70,45 +70,44 @@ 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; @@ -138,9 +137,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"); @@ -221,12 +220,13 @@ 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,10 +237,11 @@ 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 { @@ -311,7 +312,7 @@ omemo_on_disconnect(void) } void -omemo_generate_crypto_materials(ProfAccount* account) +omemo_generate_crypto_materials(ProfAccount *account) { if (loaded) { return; @@ -329,12 +330,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); @@ -364,7 +365,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 */ @@ -379,12 +380,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); @@ -392,11 +393,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); @@ -404,7 +405,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)); } @@ -412,12 +413,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); } @@ -437,9 +438,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); @@ -448,10 +449,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; @@ -468,9 +469,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; @@ -485,25 +486,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); @@ -514,9 +515,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 { @@ -536,7 +537,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; @@ -545,14 +546,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; @@ -561,14 +562,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; @@ -577,7 +578,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); @@ -587,7 +588,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); @@ -595,11 +596,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, @@ -607,11 +608,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; @@ -619,15 +620,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); @@ -637,11 +638,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); @@ -663,19 +664,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); @@ -687,7 +688,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; @@ -696,31 +697,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); @@ -729,8 +730,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), @@ -749,8 +750,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); @@ -764,11 +765,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), @@ -787,8 +788,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); @@ -800,11 +801,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); } @@ -821,24 +822,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; } @@ -850,10 +851,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; @@ -868,8 +869,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), @@ -884,9 +885,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; @@ -900,12 +901,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); @@ -920,7 +921,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); @@ -948,8 +949,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)); @@ -963,13 +964,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++) { @@ -984,11 +985,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++) { @@ -1003,17 +1004,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; } @@ -1022,14 +1023,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; } @@ -1041,9 +1042,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); @@ -1054,21 +1055,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; @@ -1090,16 +1091,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; @@ -1120,18 +1121,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); @@ -1151,9 +1152,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); @@ -1163,15 +1164,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; @@ -1179,8 +1180,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) { @@ -1189,10 +1190,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; @@ -1212,7 +1213,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(); @@ -1222,41 +1223,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); @@ -1265,7 +1266,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)); } @@ -1274,7 +1275,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); @@ -1282,7 +1283,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; @@ -1293,7 +1294,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) { @@ -1317,11 +1318,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) { @@ -1337,7 +1338,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; @@ -1352,25 +1353,25 @@ omemo_automatic_start(const char* const recipient) } switch (policy) { - 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; - } else { - result = FALSE; - } - break; - case PROF_OMEMOPOLICY_ALWAYS: - if (g_list_find_custom(account->omemo_disabled, recipient, (GCompareFunc)g_strcmp0)) { + case PROF_OMEMOPOLICY_MANUAL: result = FALSE; - } else { - result = TRUE; - } - break; + 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; } account_free(account); @@ -1380,7 +1381,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 */ @@ -1402,50 +1403,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); } @@ -1463,11 +1464,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); @@ -1490,12 +1491,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) { @@ -1506,11 +1507,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); @@ -1525,11 +1526,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) { @@ -1537,14 +1538,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); } @@ -1558,11 +1559,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) { @@ -1570,10 +1571,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); } @@ -1584,19 +1585,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(); @@ -1607,14 +1608,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); @@ -1625,12 +1626,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); @@ -1639,7 +1640,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 f56bdd68..740654a2 100644 --- a/src/omemo/omemo.h +++ b/src/omemo/omemo.h @@ -34,11 +34,11 @@ */ #include <glib.h> -#include "config/account.h" #include "ui/ui.h" +#include "config/account.h" #define OMEMO_ERR_UNSUPPORTED_CRYPTO -10000 -#define OMEMO_ERR_GCRYPT -20000 +#define OMEMO_ERR_GCRYPT -20000 typedef enum { PROF_OMEMOPOLICY_MANUAL, @@ -48,9 +48,8 @@ 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; @@ -59,39 +58,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 434483ed..ec39ed1b 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,35 +115,37 @@ 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); @@ -154,10 +156,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) { @@ -172,10 +174,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) { @@ -184,7 +186,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(); @@ -193,10 +195,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) { @@ -209,10 +211,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) { @@ -224,17 +226,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); @@ -245,22 +247,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); @@ -274,11 +276,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) { @@ -290,17 +292,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); @@ -311,22 +313,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); @@ -336,10 +338,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); @@ -348,9 +350,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; @@ -358,10 +360,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 */ @@ -375,9 +377,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); @@ -385,8 +387,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); @@ -397,13 +399,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; @@ -412,13 +414,14 @@ 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 { @@ -427,23 +430,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 f84db5ed..9b523fb6 100644 --- a/src/omemo/store.h +++ b/src/omemo/store.h @@ -36,27 +36,26 @@ #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 @@ -69,9 +68,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 /** @@ -82,7 +81,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 @@ -95,9 +94,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 /** @@ -107,7 +106,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. @@ -115,7 +114,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. @@ -124,7 +123,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. @@ -136,7 +135,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. @@ -146,7 +145,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 @@ -155,7 +154,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. @@ -163,7 +162,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. @@ -175,7 +174,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. @@ -185,7 +184,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 @@ -194,7 +193,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. @@ -202,7 +201,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. @@ -215,7 +214,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. @@ -227,7 +226,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 @@ -242,7 +241,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. @@ -260,7 +259,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 @@ -271,7 +270,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 @@ -283,4 +282,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); |