signal_protocol.h

#ifndef SIGNAL_PROTOCOL_H
#define SIGNAL_PROTOCOL_H

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#include "ratchet.h"
#include "curve.h"
#include "session_record.h"
#include "session_pre_key.h"
#include "sender_key_record.h"
#include "signal_protocol_types.h"

#ifdef __cplusplus
extern "C" {
#endif

#define SG_SUCCESS 0

/* Standard error codes with values that match errno.h equivalents */
#define SG_ERR_NOMEM -12   /* Not enough space */
#define SG_ERR_INVAL -22   /* Invalid argument */

/* Custom error codes for error conditions specific to the library */
#define SG_ERR_UNKNOWN              -1000
#define SG_ERR_DUPLICATE_MESSAGE    -1001
#define SG_ERR_INVALID_KEY          -1002
#define SG_ERR_INVALID_KEY_ID       -1003
#define SG_ERR_INVALID_MAC          -1004
#define SG_ERR_INVALID_MESSAGE      -1005
#define SG_ERR_INVALID_VERSION      -1006
#define SG_ERR_LEGACY_MESSAGE       -1007
#define SG_ERR_NO_SESSION           -1008
#define SG_ERR_STALE_KEY_EXCHANGE   -1009
#define SG_ERR_UNTRUSTED_IDENTITY   -1010
#define SG_ERR_VRF_SIG_VERIF_FAILED -1011
#define SG_ERR_INVALID_PROTO_BUF    -1100
#define SG_ERR_FP_VERSION_MISMATCH  -1200
#define SG_ERR_FP_IDENT_MISMATCH    -1201

/*
 * Minimum negative error code value that this library may use.
 * When implementing library callback functions, using values
 * less than this constant will ensure that application-specific
 * errors can be distinguished from library errors.
 */
#define SG_ERR_MINIMUM              -9999

/* Log levels */
#define SG_LOG_ERROR   0
#define SG_LOG_WARNING 1
#define SG_LOG_NOTICE  2
#define SG_LOG_INFO    3
#define SG_LOG_DEBUG   4

/* Mode settings for the crypto callbacks */
#define SG_CIPHER_AES_CTR_NOPADDING 1
#define SG_CIPHER_AES_CBC_PKCS5     2

void signal_type_ref(signal_type_base *instance);
void signal_type_unref(signal_type_base *instance);

#ifdef DEBUG_REFCOUNT
int signal_type_ref_count(signal_type_base *instance);
#define SIGNAL_REF(instance) do { \
    signal_type_ref((signal_type_base *)instance); \
    fprintf(stderr, "REF: " #instance " = %d\n", signal_type_ref_count((signal_type_base *)instance)); \
    } while (0)
#define SIGNAL_UNREF(instance) do { \
    fprintf(stderr, "UNREF: " #instance " = %d\n", signal_type_ref_count((signal_type_base *)instance)); \
    signal_type_unref((signal_type_base *)instance); \
    instance = 0; \
    } while(0)
#else
#define SIGNAL_REF(instance) signal_type_ref((signal_type_base *)instance)
#define SIGNAL_UNREF(instance) do { signal_type_unref((signal_type_base *)instance); instance = 0; } while(0)
#endif

signal_buffer *signal_buffer_alloc(size_t len);

signal_buffer *signal_buffer_create(const uint8_t *data, size_t len);

signal_buffer *signal_buffer_copy(const signal_buffer *buffer);

signal_buffer *signal_buffer_n_copy(const signal_buffer *buffer, size_t n);

signal_buffer *signal_buffer_append(signal_buffer *buffer, const uint8_t *data, size_t len);

uint8_t *signal_buffer_data(signal_buffer *buffer);

const uint8_t *signal_buffer_const_data(const signal_buffer *buffer);

size_t signal_buffer_len(const signal_buffer *buffer);

int signal_buffer_compare(signal_buffer *buffer1, signal_buffer *buffer2);

void signal_buffer_free(signal_buffer *buffer);

void signal_buffer_bzero_free(signal_buffer *buffer);

signal_buffer_list *signal_buffer_list_alloc(void);

signal_buffer_list *signal_buffer_list_copy(const signal_buffer_list *list);

int signal_buffer_list_push_back(signal_buffer_list *list, signal_buffer *buffer);

unsigned int signal_buffer_list_size(signal_buffer_list *list);

signal_buffer *signal_buffer_list_at(signal_buffer_list *list, unsigned int index);

void signal_buffer_list_free(signal_buffer_list *list);

void signal_buffer_list_bzero_free(signal_buffer_list *list);

signal_int_list *signal_int_list_alloc(void);

int signal_int_list_push_back(signal_int_list *list, int value);

unsigned int signal_int_list_size(signal_int_list *list);

int signal_int_list_at(signal_int_list *list, unsigned int index);

void signal_int_list_free(signal_int_list *list);

typedef struct signal_crypto_provider {
    int (*random_func)(uint8_t *data, size_t len, void *user_data);

    int (*hmac_sha256_init_func)(void **hmac_context, const uint8_t *key, size_t key_len, void *user_data);

    int (*hmac_sha256_update_func)(void *hmac_context, const uint8_t *data, size_t data_len, void *user_data);

    int (*hmac_sha256_final_func)(void *hmac_context, signal_buffer **output, void *user_data);

    void (*hmac_sha256_cleanup_func)(void *hmac_context, void *user_data);

    int (*sha512_digest_init_func)(void **digest_context, void *user_data);

    int (*sha512_digest_update_func)(void *digest_context, const uint8_t *data, size_t data_len, void *user_data);

    int (*sha512_digest_final_func)(void *digest_context, signal_buffer **output, void *user_data);

    void (*sha512_digest_cleanup_func)(void *digest_context, void *user_data);

    int (*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 (*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);

    void *user_data;
} signal_crypto_provider;

typedef struct signal_protocol_session_store {
    int (*load_session_func)(signal_buffer **record, signal_buffer **user_record, const signal_protocol_address *address, void *user_data);

    int (*get_sub_device_sessions_func)(signal_int_list **sessions, const char *name, size_t name_len, void *user_data);

    int (*store_session_func)(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 (*contains_session_func)(const signal_protocol_address *address, void *user_data);

    int (*delete_session_func)(const signal_protocol_address *address, void *user_data);

    int (*delete_all_sessions_func)(const char *name, size_t name_len, void *user_data);

    void (*destroy_func)(void *user_data);

    void *user_data;
} signal_protocol_session_store;

typedef struct signal_protocol_pre_key_store {
    int (*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);

    int (*contains_pre_key)(uint32_t pre_key_id, void *user_data);

    int (*remove_pre_key)(uint32_t pre_key_id, void *user_data);

    void (*destroy_func)(void *user_data);

    void *user_data;
} signal_protocol_pre_key_store;

typedef struct signal_protocol_signed_pre_key_store {
    int (*load_signed_pre_key)(signal_buffer **record, uint32_t signed_pre_key_id, void *user_data);

    int (*store_signed_pre_key)(uint32_t signed_pre_key_id, uint8_t *record, size_t record_len, void *user_data);

    int (*contains_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);

    void (*destroy_func)(void *user_data);

    void *user_data;
} signal_protocol_signed_pre_key_store;

typedef struct signal_protocol_identity_key_store {
    int (*get_identity_key_pair)(signal_buffer **public_data, signal_buffer **private_data, void *user_data);

    int (*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);

    int (*is_trusted_identity)(const signal_protocol_address *address, uint8_t *key_data, size_t key_len, void *user_data);

    void (*destroy_func)(void *user_data);

    void *user_data;
} signal_protocol_identity_key_store;

typedef struct signal_protocol_sender_key_store {
    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 (*load_sender_key)(signal_buffer **record, signal_buffer **user_record, const signal_protocol_sender_key_name *sender_key_name, void *user_data);

    void (*destroy_func)(void *user_data);

    void *user_data;
} signal_protocol_sender_key_store;

int signal_context_create(signal_context **context, void *user_data);

int signal_context_set_crypto_provider(signal_context *context, const signal_crypto_provider *crypto_provider);

int signal_context_set_locking_functions(signal_context *context,
        void (*lock)(void *user_data), void (*unlock)(void *user_data));

int signal_context_set_log_function(signal_context *context,
        void (*log)(int level, const char *message, size_t len, void *user_data));

void signal_context_destroy(signal_context *context);

int signal_protocol_store_context_create(signal_protocol_store_context **context, signal_context *global_context);

int signal_protocol_store_context_set_session_store(signal_protocol_store_context *context, const signal_protocol_session_store *store);
int signal_protocol_store_context_set_pre_key_store(signal_protocol_store_context *context, const signal_protocol_pre_key_store *store);
int signal_protocol_store_context_set_signed_pre_key_store(signal_protocol_store_context *context, const signal_protocol_signed_pre_key_store *store);
int signal_protocol_store_context_set_identity_key_store(signal_protocol_store_context *context, const signal_protocol_identity_key_store *store);
int signal_protocol_store_context_set_sender_key_store(signal_protocol_store_context *context, const signal_protocol_sender_key_store *store);

void signal_protocol_store_context_destroy(signal_protocol_store_context *context);

/*
 * Interface to the session store.
 * These functions will use the callbacks in the provided
 * signal_protocol_store_context instance and operate in terms of higher level
 * library data structures.
 */

int signal_protocol_session_load_session(signal_protocol_store_context *context, session_record **record, const signal_protocol_address *address);
int signal_protocol_session_get_sub_device_sessions(signal_protocol_store_context *context, signal_int_list **sessions, const char *name, size_t name_len);
int signal_protocol_session_store_session(signal_protocol_store_context *context, const signal_protocol_address *address, session_record *record);
int signal_protocol_session_contains_session(signal_protocol_store_context *context, const signal_protocol_address *address);
int signal_protocol_session_delete_session(signal_protocol_store_context *context, const signal_protocol_address *address);
int signal_protocol_session_delete_all_sessions(signal_protocol_store_context *context, const char *name, size_t name_len);


/*
 * Interface to the pre-key store.
 * These functions will use the callbacks in the provided
 * signal_protocol_store_context instance and operate in terms of higher level
 * library data structures.
 */

int signal_protocol_pre_key_load_key(signal_protocol_store_context *context, session_pre_key **pre_key, uint32_t pre_key_id);
int signal_protocol_pre_key_store_key(signal_protocol_store_context *context, session_pre_key *pre_key);
int signal_protocol_pre_key_contains_key(signal_protocol_store_context *context, uint32_t pre_key_id);
int signal_protocol_pre_key_remove_key(signal_protocol_store_context *context, uint32_t pre_key_id);


/*
 * Interface to the signed pre-key store.
 * These functions will use the callbacks in the provided
 * signal_protocol_store_context instance and operate in terms of higher level
 * library data structures.
 */

int signal_protocol_signed_pre_key_load_key(signal_protocol_store_context *context, session_signed_pre_key **pre_key, uint32_t signed_pre_key_id);
int signal_protocol_signed_pre_key_store_key(signal_protocol_store_context *context, session_signed_pre_key *pre_key);
int signal_protocol_signed_pre_key_contains_key(signal_protocol_store_context *context, uint32_t signed_pre_key_id);
int signal_protocol_signed_pre_key_remove_key(signal_protocol_store_context *context, uint32_t signed_pre_key_id);


/*
 * Interface to the identity key store.
 * These functions will use the callbacks in the provided
 * signal_protocol_store_context instance and operate in terms of higher level
 * library data structures.
 */

int signal_protocol_identity_get_key_pair(signal_protocol_store_context *context, ratchet_identity_key_pair **key_pair);
int signal_protocol_identity_get_local_registration_id(signal_protocol_store_context *context, uint32_t *registration_id);
int signal_protocol_identity_save_identity(signal_protocol_store_context *context, const signal_protocol_address *address, ec_public_key *identity_key);
int signal_protocol_identity_is_trusted_identity(signal_protocol_store_context *context, const signal_protocol_address *address, ec_public_key *identity_key);


/*
 * Interface to the sender key store.
 * These functions will use the callbacks in the provided
 * signal_protocol_store_context instance and operate in terms of higher level
 * library data structures.
 */

int signal_protocol_sender_key_store_key(signal_protocol_store_context *context, const signal_protocol_sender_key_name *sender_key_name, sender_key_record *record);
int signal_protocol_sender_key_load_key(signal_protocol_store_context *context, sender_key_record **record, const signal_protocol_sender_key_name *sender_key_name);

#ifdef __cplusplus
}
#endif

#endif /* SIGNAL_PROTOCOL_H */