diff options
Diffstat (limited to 'protocols/Tox/libtox/src')
52 files changed, 16995 insertions, 663 deletions
diff --git a/protocols/Tox/libtox/src/toxcore/DHT.c b/protocols/Tox/libtox/src/toxcore/DHT.c index 8aa161102b..91f0e0ae47 100644 --- a/protocols/Tox/libtox/src/toxcore/DHT.c +++ b/protocols/Tox/libtox/src/toxcore/DHT.c @@ -18,6 +18,7 @@ #include "mono_time.h" #include "network.h" #include "ping.h" +#include "shared_key_cache.h" #include "state.h" #include "util.h" @@ -43,6 +44,13 @@ /** Number of get node requests to send to quickly find close nodes. */ #define MAX_BOOTSTRAP_TIMES 5 +// TODO(sudden6): find out why we need multiple callbacks and if we really need 32 +#define DHT_FRIEND_MAX_LOCKS 32 + +/* Settings for the shared key cache */ +#define MAX_KEYS_PER_SLOT 4 +#define KEYS_TIMEOUT 600 + typedef struct DHT_Friend_Callback { dht_ip_cb *ip_callback; void *data; @@ -61,7 +69,8 @@ struct DHT_Friend { /* Symmetric NAT hole punching stuff. */ NAT nat; - uint16_t lock_count; + /* Each set bit represents one installed callback */ + uint32_t lock_flags; DHT_Friend_Callback callbacks[DHT_FRIEND_MAX_LOCKS]; Node_format to_bootstrap[MAX_SENT_NODES]; @@ -71,6 +80,8 @@ struct DHT_Friend { static const DHT_Friend empty_dht_friend = {{0}}; const Node_format empty_node_format = {{0}}; +static_assert(sizeof (empty_dht_friend.lock_flags) * 8 == DHT_FRIEND_MAX_LOCKS, "Bitfield size and number of locks don't match"); + typedef struct Cryptopacket_Handler { cryptopacket_handler_cb *function; void *object; @@ -101,8 +112,8 @@ struct DHT { uint32_t loaded_num_nodes; unsigned int loaded_nodes_index; - Shared_Keys shared_keys_recv; - Shared_Keys shared_keys_sent; + Shared_Key_Cache *shared_keys_recv; + Shared_Key_Cache *shared_keys_sent; struct Ping *ping; Ping_Array *dht_ping_array; @@ -200,12 +211,6 @@ static IP_Port ip_port_normalize(const IP_Port *ip_port) return res; } -/** @brief Compares pk1 and pk2 with pk. - * - * @retval 0 if both are same distance. - * @retval 1 if pk1 is closer. - * @retval 2 if pk2 is closer. - */ int id_closest(const uint8_t *pk, const uint8_t *pk1, const uint8_t *pk2) { for (size_t i = 0; i < CRYPTO_PUBLIC_KEY_SIZE; ++i) { @@ -250,98 +255,25 @@ unsigned int bit_by_bit_cmp(const uint8_t *pk1, const uint8_t *pk2) } /** - * Shared key generations are costly, it is therefore smart to store commonly used - * ones so that they can be re-used later without being computed again. - * - * If a shared key is already in shared_keys, copy it to shared_key. - * Otherwise generate it into shared_key and copy it to shared_keys - */ -void get_shared_key(const Mono_Time *mono_time, Shared_Keys *shared_keys, uint8_t *shared_key, - const uint8_t *secret_key, const uint8_t *public_key) -{ - uint32_t num = -1; - uint32_t curr = 0; - - for (uint32_t i = 0; i < MAX_KEYS_PER_SLOT; ++i) { - const int index = public_key[30] * MAX_KEYS_PER_SLOT + i; - Shared_Key *const key = &shared_keys->keys[index]; - - if (key->stored) { - if (pk_equal(public_key, key->public_key)) { - memcpy(shared_key, key->shared_key, CRYPTO_SHARED_KEY_SIZE); - ++key->times_requested; - key->time_last_requested = mono_time_get(mono_time); - return; - } - - if (num != 0) { - if (mono_time_is_timeout(mono_time, key->time_last_requested, KEYS_TIMEOUT)) { - num = 0; - curr = index; - } else if (num > key->times_requested) { - num = key->times_requested; - curr = index; - } - } - } else if (num != 0) { - num = 0; - curr = index; - } - } - - encrypt_precompute(public_key, secret_key, shared_key); - - if (num != UINT32_MAX) { - Shared_Key *const key = &shared_keys->keys[curr]; - key->stored = true; - key->times_requested = 1; - memcpy(key->public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE); - memcpy(key->shared_key, shared_key, CRYPTO_SHARED_KEY_SIZE); - key->time_last_requested = mono_time_get(mono_time); - } -} - -/** * Copy shared_key to encrypt/decrypt DHT packet from public_key into shared_key * for packets that we receive. */ -void dht_get_shared_key_recv(DHT *dht, uint8_t *shared_key, const uint8_t *public_key) +const uint8_t *dht_get_shared_key_recv(DHT *dht, const uint8_t *public_key) { - get_shared_key(dht->mono_time, &dht->shared_keys_recv, shared_key, dht->self_secret_key, public_key); + return shared_key_cache_lookup(dht->shared_keys_recv, public_key); } /** * Copy shared_key to encrypt/decrypt DHT packet from public_key into shared_key * for packets that we send. */ -void dht_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *public_key) +const uint8_t *dht_get_shared_key_sent(DHT *dht, const uint8_t *public_key) { - get_shared_key(dht->mono_time, &dht->shared_keys_sent, shared_key, dht->self_secret_key, public_key); + return shared_key_cache_lookup(dht->shared_keys_sent, public_key); } #define CRYPTO_SIZE (1 + CRYPTO_PUBLIC_KEY_SIZE * 2 + CRYPTO_NONCE_SIZE) -/** - * @brief Create a request to peer. - * - * Packs the data and sender public key and encrypts the packet. - * - * @param[in] send_public_key public key of the sender. - * @param[in] send_secret_key secret key of the sender. - * @param[out] packet an array of @ref MAX_CRYPTO_REQUEST_SIZE big. - * @param[in] recv_public_key public key of the receiver. - * @param[in] data represents the data we send with the request. - * @param[in] data_length the length of the data. - * @param[in] request_id the id of the request (32 = friend request, 254 = ping request). - * - * @attention Constraints: - * @code - * sizeof(packet) >= MAX_CRYPTO_REQUEST_SIZE - * @endcode - * - * @retval -1 on failure. - * @return the length of the created packet on success. - */ int create_request(const Random *rng, const uint8_t *send_public_key, const uint8_t *send_secret_key, uint8_t *packet, const uint8_t *recv_public_key, const uint8_t *data, uint32_t data_length, uint8_t request_id) @@ -375,28 +307,6 @@ int create_request(const Random *rng, const uint8_t *send_public_key, const uint return len + CRYPTO_SIZE; } -/** - * @brief Decrypts and unpacks a DHT request packet. - * - * Puts the senders public key in the request in @p public_key, the data from - * the request in @p data. - * - * @param[in] self_public_key public key of the receiver (us). - * @param[in] self_secret_key secret key of the receiver (us). - * @param[out] public_key public key of the sender, copied from the input packet. - * @param[out] data decrypted request data, copied from the input packet, must - * have room for @ref MAX_CRYPTO_REQUEST_SIZE bytes. - * @param[in] packet is the request packet. - * @param[in] packet_length length of the packet. - * - * @attention Constraints: - * @code - * sizeof(data) >= MAX_CRYPTO_REQUEST_SIZE - * @endcode - * - * @retval -1 if not valid request. - * @return the length of the unpacked data. - */ int handle_request(const uint8_t *self_public_key, const uint8_t *self_secret_key, uint8_t *public_key, uint8_t *data, uint8_t *request_id, const uint8_t *packet, uint16_t packet_length) { @@ -435,9 +345,6 @@ int handle_request(const uint8_t *self_public_key, const uint8_t *self_secret_ke return len1; } -/** @return packet size of packed node with ip_family on success. - * @retval -1 on failure. - */ int packed_node_size(Family ip_family) { if (net_family_is_ipv4(ip_family) || net_family_is_tcp_ipv4(ip_family)) { @@ -452,13 +359,6 @@ int packed_node_size(Family ip_family) } -/** @brief Pack an IP_Port structure into data of max size length. - * - * Packed_length is the offset of data currently packed. - * - * @return size of packed IP_Port data on success. - * @retval -1 on failure. - */ int pack_ip_port(const Logger *logger, uint8_t *data, uint16_t length, const IP_Port *ip_port) { if (data == nullptr) { @@ -514,11 +414,6 @@ int pack_ip_port(const Logger *logger, uint8_t *data, uint16_t length, const IP_ } } -/** @brief Encrypt plain and write resulting DHT packet into packet with max size length. - * - * @return size of packet on success. - * @retval -1 on failure. - */ int dht_create_packet(const Random *rng, const uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE], const uint8_t *shared_key, const uint8_t type, const uint8_t *plain, size_t plain_length, @@ -554,13 +449,6 @@ int dht_create_packet(const Random *rng, const uint8_t public_key[CRYPTO_PUBLIC_ return 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + encrypted_length; } -/** @brief Unpack IP_Port structure from data of max size length into ip_port. - * - * len_processed is the offset of data currently unpacked. - * - * @return size of unpacked ip_port on success. - * @retval -1 on failure. - */ int unpack_ip_port(IP_Port *ip_port, const uint8_t *data, uint16_t length, bool tcp_enabled) { if (data == nullptr) { @@ -621,11 +509,6 @@ int unpack_ip_port(IP_Port *ip_port, const uint8_t *data, uint16_t length, bool } } -/** @brief Pack number of nodes into data of maxlength length. - * - * @return length of packed nodes on success. - * @retval -1 on failure. - */ int pack_nodes(const Logger *logger, uint8_t *data, uint16_t length, const Node_format *nodes, uint16_t number) { uint32_t packed_length = 0; @@ -655,13 +538,6 @@ int pack_nodes(const Logger *logger, uint8_t *data, uint16_t length, const Node_ return packed_length; } -/** @brief Unpack data of length into nodes of size max_num_nodes. - * Put the length of the data processed in processed_data_len. - * tcp_enabled sets if TCP nodes are expected (true) or not (false). - * - * @return number of unpacked nodes on success. - * @retval -1 on failure. - */ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed_data_len, const uint8_t *data, uint16_t length, bool tcp_enabled) { @@ -1057,8 +933,7 @@ static bool send_announce_ping(DHT *dht, const uint8_t *public_key, const IP_Por public_key, CRYPTO_PUBLIC_KEY_SIZE); memcpy(plain + CRYPTO_PUBLIC_KEY_SIZE, &ping_id, sizeof(ping_id)); - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - dht_get_shared_key_sent(dht, shared_key, public_key); + const uint8_t *shared_key = dht_get_shared_key_sent(dht, public_key); uint8_t request[1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + sizeof(plain) + CRYPTO_MAC_SIZE]; @@ -1086,8 +961,7 @@ static int handle_data_search_response(void *object, const IP_Port *source, VLA(uint8_t, plain, plain_len); const uint8_t *public_key = packet + 1; - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - dht_get_shared_key_recv(dht, shared_key, public_key); + const uint8_t *shared_key = dht_get_shared_key_recv(dht, public_key); if (decrypt_data_symmetric(shared_key, packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, @@ -1419,8 +1293,9 @@ uint32_t addto_lists(DHT *dht, const IP_Port *ip_port, const uint8_t *public_key return used; } - for (uint32_t i = 0; i < friend_foundip->lock_count; ++i) { - if (friend_foundip->callbacks[i].ip_callback != nullptr) { + for (uint32_t i = 0; i < DHT_FRIEND_MAX_LOCKS; ++i) { + const bool has_lock = (friend_foundip->lock_flags & (UINT32_C(1) << i)) > 0; + if (has_lock && friend_foundip->callbacks[i].ip_callback != nullptr) { friend_foundip->callbacks[i].ip_callback(friend_foundip->callbacks[i].data, friend_foundip->callbacks[i].number, &ipp_copy); } @@ -1515,15 +1390,12 @@ bool dht_getnodes(DHT *dht, const IP_Port *ip_port, const uint8_t *public_key, c memcpy(plain, client_id, CRYPTO_PUBLIC_KEY_SIZE); memcpy(plain + CRYPTO_PUBLIC_KEY_SIZE, &ping_id, sizeof(ping_id)); - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - dht_get_shared_key_sent(dht, shared_key, public_key); + const uint8_t *shared_key = dht_get_shared_key_sent(dht, public_key); const int len = dht_create_packet(dht->rng, dht->self_public_key, shared_key, NET_PACKET_GET_NODES, plain, sizeof(plain), data, sizeof(data)); - crypto_memzero(shared_key, sizeof(shared_key)); - if (len != sizeof(data)) { LOGGER_ERROR(dht->log, "getnodes packet encryption failed"); return false; @@ -1598,9 +1470,7 @@ static int handle_getnodes(void *object, const IP_Port *source, const uint8_t *p } uint8_t plain[CRYPTO_NODE_SIZE]; - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - - dht_get_shared_key_recv(dht, shared_key, packet + 1); + const uint8_t *shared_key = dht_get_shared_key_recv(dht, packet + 1); const int len = decrypt_data_symmetric( shared_key, packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, @@ -1609,7 +1479,6 @@ static int handle_getnodes(void *object, const IP_Port *source, const uint8_t *p plain); if (len != CRYPTO_NODE_SIZE) { - crypto_memzero(shared_key, sizeof(shared_key)); return 1; } @@ -1617,8 +1486,6 @@ static int handle_getnodes(void *object, const IP_Port *source, const uint8_t *p ping_add(dht->ping, packet + 1, source); - crypto_memzero(shared_key, sizeof(shared_key)); - return 0; } @@ -1663,8 +1530,7 @@ static bool handle_sendnodes_core(void *object, const IP_Port *source, const uin } VLA(uint8_t, plain, 1 + data_size + sizeof(uint64_t)); - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - dht_get_shared_key_sent(dht, shared_key, packet + 1); + const uint8_t *shared_key = dht_get_shared_key_sent(dht, packet + 1); const int len = decrypt_data_symmetric( shared_key, packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, @@ -1672,8 +1538,6 @@ static bool handle_sendnodes_core(void *object, const IP_Port *source, const uin 1 + data_size + sizeof(uint64_t) + CRYPTO_MAC_SIZE, plain); - crypto_memzero(shared_key, sizeof(shared_key)); - if ((unsigned int)len != SIZEOF_VLA(plain)) { return false; } @@ -1745,35 +1609,75 @@ static int handle_sendnodes_ipv6(void *object, const IP_Port *source, const uint /*----------------------------------------------------------------------------------*/ /*------------------------END of packet handling functions--------------------------*/ -non_null(1) nullable(2, 3, 5) -static void dht_friend_lock(DHT_Friend *const dht_friend, dht_ip_cb *ip_callback, - void *data, int32_t number, uint16_t *lock_count) +non_null(1) nullable(2, 3) +static uint32_t dht_friend_lock(DHT_Friend *const dht_friend, dht_ip_cb *ip_callback, + void *data, int32_t number) { - const uint16_t lock_num = dht_friend->lock_count; - ++dht_friend->lock_count; + // find first free slot + uint8_t lock_num; + uint32_t lock_token = 0; + for (lock_num = 0; lock_num < DHT_FRIEND_MAX_LOCKS; ++lock_num) { + lock_token = UINT32_C(1) << lock_num; + if ((dht_friend->lock_flags & lock_token) == 0) { + break; + } + } + + // One of the conditions would be enough, but static analyzers don't get that + if (lock_token == 0 || lock_num == DHT_FRIEND_MAX_LOCKS) { + return 0; + } + + // Claim that slot + dht_friend->lock_flags |= lock_token; + dht_friend->callbacks[lock_num].ip_callback = ip_callback; dht_friend->callbacks[lock_num].data = data; dht_friend->callbacks[lock_num].number = number; - if (lock_count != nullptr) { - *lock_count = lock_num + 1; + return lock_token; +} + +non_null() +static void dht_friend_unlock(DHT_Friend *const dht_friend, uint32_t lock_token) +{ + // If this triggers, there was a double free + assert((lock_token & dht_friend->lock_flags) > 0); + + // find used slot + uint8_t lock_num; + for (lock_num = 0; lock_num < DHT_FRIEND_MAX_LOCKS; ++lock_num) { + if (((UINT32_C(1) << lock_num) & lock_token) > 0) { + break; + } } + + if (lock_num == DHT_FRIEND_MAX_LOCKS) { + // Gracefully handle double unlock + return; + } + + // Clear the slot + dht_friend->lock_flags &= ~lock_token; + + dht_friend->callbacks[lock_num].ip_callback = nullptr; + dht_friend->callbacks[lock_num].data = nullptr; + dht_friend->callbacks[lock_num].number = 0; } int dht_addfriend(DHT *dht, const uint8_t *public_key, dht_ip_cb *ip_callback, - void *data, int32_t number, uint16_t *lock_count) + void *data, int32_t number, uint32_t *lock_token) { const uint32_t friend_num = index_of_friend_pk(dht->friends_list, dht->num_friends, public_key); if (friend_num != UINT32_MAX) { /* Is friend already in DHT? */ DHT_Friend *const dht_friend = &dht->friends_list[friend_num]; + const uint32_t tmp_lock_token = dht_friend_lock(dht_friend, ip_callback, data, number); - if (dht_friend->lock_count == DHT_FRIEND_MAX_LOCKS) { + if (tmp_lock_token == 0) { return -1; } - dht_friend_lock(dht_friend, ip_callback, data, number, lock_count); - return 0; } @@ -1791,7 +1695,8 @@ int dht_addfriend(DHT *dht, const uint8_t *public_key, dht_ip_cb *ip_callback, dht_friend->nat.nat_ping_id = random_u64(dht->rng); ++dht->num_friends; - dht_friend_lock(dht_friend, ip_callback, data, number, lock_count); + *lock_token = dht_friend_lock(dht_friend, ip_callback, data, number); + assert(*lock_token != 0); // Friend was newly allocated dht_friend->num_to_bootstrap = get_close_nodes(dht, dht_friend->public_key, dht_friend->to_bootstrap, net_family_unspec(), true, false); @@ -1799,7 +1704,7 @@ int dht_addfriend(DHT *dht, const uint8_t *public_key, dht_ip_cb *ip_callback, return 0; } -int dht_delfriend(DHT *dht, const uint8_t *public_key, uint16_t lock_count) +int dht_delfriend(DHT *dht, const uint8_t *public_key, uint32_t lock_token) { const uint32_t friend_num = index_of_friend_pk(dht->friends_list, dht->num_friends, public_key); @@ -1808,13 +1713,9 @@ int dht_delfriend(DHT *dht, const uint8_t *public_key, uint16_t lock_count) } DHT_Friend *const dht_friend = &dht->friends_list[friend_num]; - --dht_friend->lock_count; - - if (dht_friend->lock_count > 0 && lock_count > 0) { /* DHT friend is still in use.*/ - --lock_count; - dht_friend->callbacks[lock_count].ip_callback = nullptr; - dht_friend->callbacks[lock_count].data = nullptr; - dht_friend->callbacks[lock_count].number = 0; + dht_friend_unlock(dht_friend, lock_token); + if (dht_friend->lock_flags > 0) { + /* DHT friend is still in use.*/ return 0; } @@ -1855,7 +1756,7 @@ int dht_getfriendip(const DHT *dht, const uint8_t *public_key, IP_Port *ip_port) const DHT_Friend *const frnd = &dht->friends_list[friend_index]; const uint32_t client_index = index_of_client_pk(frnd->client_list, MAX_FRIEND_CLIENTS, public_key); - if (client_index == -1) { + if (client_index == UINT32_MAX) { return 0; } @@ -2059,11 +1960,6 @@ int dht_bootstrap_from_address(DHT *dht, const char *address, bool ipv6enabled, return 0; } -/** @brief Send the given packet to node with public_key. - * - * @return number of bytes sent. - * @retval -1 if failure. - */ int route_packet(const DHT *dht, const uint8_t *public_key, const uint8_t *packet, uint16_t length) { for (uint32_t i = 0; i < LCLIENT_LIST; ++i) { @@ -2752,6 +2648,15 @@ DHT *new_dht(const Logger *log, const Random *rng, const Network *ns, Mono_Time crypto_new_keypair(rng, dht->self_public_key, dht->self_secret_key); + dht->shared_keys_recv = shared_key_cache_new(mono_time, dht->self_secret_key, KEYS_TIMEOUT, MAX_KEYS_PER_SLOT); + dht->shared_keys_sent = shared_key_cache_new(mono_time, dht->self_secret_key, KEYS_TIMEOUT, MAX_KEYS_PER_SLOT); + + if (dht->shared_keys_recv == nullptr || dht->shared_keys_sent == nullptr) { + kill_dht(dht); + return nullptr; + } + + dht->dht_ping_array = ping_array_new(DHT_PING_ARRAY_SIZE, PING_TIMEOUT); if (dht->dht_ping_array == nullptr) { @@ -2765,7 +2670,8 @@ DHT *new_dht(const Logger *log, const Random *rng, const Network *ns, Mono_Time crypto_new_keypair(rng, random_public_key_bytes, random_secret_key_bytes); - if (dht_addfriend(dht, random_public_key_bytes, nullptr, nullptr, 0, nullptr) != 0) { + uint32_t token; // We don't intend to delete these ever, but need to pass the token + if (dht_addfriend(dht, random_public_key_bytes, nullptr, nullptr, 0, &token) != 0) { kill_dht(dht); return nullptr; } @@ -2813,12 +2719,12 @@ void kill_dht(DHT *dht) networking_registerhandler(dht->net, NET_PACKET_LAN_DISCOVERY, nullptr, nullptr); cryptopacket_registerhandler(dht, CRYPTO_PACKET_NAT_PING, nullptr, nullptr); + shared_key_cache_free(dht->shared_keys_recv); + shared_key_cache_free(dht->shared_keys_sent); ping_array_kill(dht->dht_ping_array); ping_kill(dht->ping); free(dht->friends_list); free(dht->loaded_nodes_list); - crypto_memzero(&dht->shared_keys_recv, sizeof(dht->shared_keys_recv)); - crypto_memzero(&dht->shared_keys_sent, sizeof(dht->shared_keys_sent)); crypto_memzero(dht->self_secret_key, sizeof(dht->self_secret_key)); free(dht); } @@ -2929,11 +2835,6 @@ void dht_save(const DHT *dht, uint8_t *data) /** Bootstrap from this number of nodes every time `dht_connect_after_load()` is called */ #define SAVE_BOOTSTAP_FREQUENCY 8 -/** @brief Start sending packets after DHT loaded_friends_list and loaded_clients_list are set. - * - * @retval 0 if successful - * @retval -1 otherwise - */ int dht_connect_after_load(DHT *dht) { if (dht == nullptr) { @@ -3003,11 +2904,6 @@ static State_Load_Status dht_load_state_callback(void *outer, const uint8_t *dat return STATE_LOAD_STATUS_CONTINUE; } -/** @brief Load the DHT from data of size size. - * - * @retval -1 if failure. - * @retval 0 if success. - */ int dht_load(DHT *dht, const uint8_t *data, uint32_t length) { const uint32_t cookie_len = sizeof(uint32_t); @@ -3066,16 +2962,6 @@ bool dht_non_lan_connected(const DHT *dht) return false; } -/** @brief Copies our own ip_port structure to `dest`. - * - * WAN addresses take priority over LAN addresses. - * - * This function will zero the `dest` buffer before use. - * - * @retval 0 if our ip port can't be found (this usually means we're not connected to the DHT). - * @retval 1 if IP is a WAN address. - * @retval 2 if IP is a LAN address. - */ unsigned int ipport_self_copy(const DHT *dht, IP_Port *dest) { ipport_reset(dest); diff --git a/protocols/Tox/libtox/src/toxcore/DHT.h b/protocols/Tox/libtox/src/toxcore/DHT.h index 34ecf9dd0b..86ac4f9d40 100644 --- a/protocols/Tox/libtox/src/toxcore/DHT.h +++ b/protocols/Tox/libtox/src/toxcore/DHT.h @@ -22,6 +22,20 @@ extern "C" { #endif +/* Encryption and signature keys definition */ +#define ENC_PUBLIC_KEY_SIZE CRYPTO_PUBLIC_KEY_SIZE +#define ENC_SECRET_KEY_SIZE CRYPTO_SECRET_KEY_SIZE +#define SIG_PUBLIC_KEY_SIZE CRYPTO_SIGN_PUBLIC_KEY_SIZE +#define SIG_SECRET_KEY_SIZE CRYPTO_SIGN_SECRET_KEY_SIZE + +/* Size of the group chat_id */ +#define CHAT_ID_SIZE SIG_PUBLIC_KEY_SIZE + +/* Extended keys for group chats */ +#define EXT_SECRET_KEY_SIZE (ENC_SECRET_KEY_SIZE + SIG_SECRET_KEY_SIZE) +#define EXT_PUBLIC_KEY_SIZE (ENC_PUBLIC_KEY_SIZE + SIG_PUBLIC_KEY_SIZE) + + /* Maximum size of a signature (may be smaller) */ #define SIGNATURE_SIZE CRYPTO_SIGNATURE_SIZE /** Maximum number of clients stored per friend. */ @@ -172,8 +186,6 @@ typedef struct NAT { uint64_t nat_ping_timestamp; } NAT; -#define DHT_FRIEND_MAX_LOCKS 32 - typedef struct Node_format { uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]; IP_Port ip_port; @@ -242,24 +254,6 @@ non_null(1, 4) nullable(3) int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed_data_len, const uint8_t *data, uint16_t length, bool tcp_enabled); - -/*----------------------------------------------------------------------------------*/ -/* struct to store some shared keys so we don't have to regenerate them for each request. */ -#define MAX_KEYS_PER_SLOT 4 -#define KEYS_TIMEOUT 600 - -typedef struct Shared_Key { - uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]; - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - uint32_t times_requested; - bool stored; - uint64_t time_last_requested; -} Shared_Key; - -typedef struct Shared_Keys { - Shared_Key keys[256 * MAX_KEYS_PER_SLOT]; -} Shared_Keys; - /*----------------------------------------------------------------------------------*/ typedef int cryptopacket_handler_cb(void *object, const IP_Port *ip_port, const uint8_t *source_pubkey, @@ -284,30 +278,18 @@ non_null() const uint8_t *dht_get_friend_public_key(const DHT *dht, uint32_t fri /*----------------------------------------------------------------------------------*/ /** - * Shared key generations are costly, it is therefore smart to store commonly used - * ones so that they can be re-used later without being computed again. - * - * If a shared key is already in shared_keys, copy it to shared_key. - * Otherwise generate it into shared_key and copy it to shared_keys - */ -non_null() -void get_shared_key( - const Mono_Time *mono_time, Shared_Keys *shared_keys, uint8_t *shared_key, - const uint8_t *secret_key, const uint8_t *public_key); - -/** * Copy shared_key to encrypt/decrypt DHT packet from public_key into shared_key * for packets that we receive. */ non_null() -void dht_get_shared_key_recv(DHT *dht, uint8_t *shared_key, const uint8_t *public_key); +const uint8_t *dht_get_shared_key_recv(DHT *dht, const uint8_t *public_key); /** * Copy shared_key to encrypt/decrypt DHT packet from public_key into shared_key * for packets that we send. */ non_null() -void dht_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *public_key); +const uint8_t *dht_get_shared_key_sent(DHT *dht, const uint8_t *public_key); /** * Sends a getnodes request to `ip_port` with the public key `public_key` for nodes @@ -327,29 +309,34 @@ non_null(1) nullable(2) void dht_callback_get_nodes_response(DHT *dht, dht_get_nodes_response_cb *function); /** @brief Add a new friend to the friends list. - * public_key must be CRYPTO_PUBLIC_KEY_SIZE bytes long. + * @param public_key must be CRYPTO_PUBLIC_KEY_SIZE bytes long. * - * ip_callback is the callback of a function that will be called when the ip address + * @param ip_callback is the callback of a function that will be called when the ip address * is found along with arguments data and number. + * @param data User data for the callback + * @param number Will be passed to ip_callback * - * lock_count will be set to a non zero number that must be passed to `dht_delfriend()` + * @param lock_token will be set to a non zero number that must be passed to `dht_delfriend()` * to properly remove the callback. * * @retval 0 if success. * @retval -1 if failure (friends list is full). */ -non_null(1, 2) nullable(3, 4, 6) +non_null(1, 2, 6) nullable(3, 4) int dht_addfriend(DHT *dht, const uint8_t *public_key, dht_ip_cb *ip_callback, - void *data, int32_t number, uint16_t *lock_count); + void *data, int32_t number, uint32_t *lock_token); /** @brief Delete a friend from the friends list. * public_key must be CRYPTO_PUBLIC_KEY_SIZE bytes long. + * @param dht The DHT object + * @param public_key The public key of the friend + * @param lock_token The token received by dht_addfriend(...) * * @retval 0 if success. * @retval -1 if failure (public_key not in friends list). */ non_null() -int dht_delfriend(DHT *dht, const uint8_t *public_key, uint16_t lock_count); +int dht_delfriend(DHT *dht, const uint8_t *public_key, uint32_t lock_token); /** @brief Get ip of friend. * diff --git a/protocols/Tox/libtox/src/toxcore/LAN_discovery.c b/protocols/Tox/libtox/src/toxcore/LAN_discovery.c index 82c02b59e9..ef44d3b552 100644 --- a/protocols/Tox/libtox/src/toxcore/LAN_discovery.c +++ b/protocols/Tox/libtox/src/toxcore/LAN_discovery.c @@ -339,7 +339,8 @@ bool ip_is_lan(const IP *ip) } -bool lan_discovery_send(const Networking_Core *net, const Broadcast_Info *broadcast, const uint8_t *dht_pk, uint16_t port) +bool lan_discovery_send(const Networking_Core *net, const Broadcast_Info *broadcast, const uint8_t *dht_pk, + uint16_t port) { if (broadcast == nullptr) { return false; diff --git a/protocols/Tox/libtox/src/toxcore/LAN_discovery.h b/protocols/Tox/libtox/src/toxcore/LAN_discovery.h index 85ea9478f4..5d9c83335b 100644 --- a/protocols/Tox/libtox/src/toxcore/LAN_discovery.h +++ b/protocols/Tox/libtox/src/toxcore/LAN_discovery.h @@ -24,7 +24,8 @@ typedef struct Broadcast_Info Broadcast_Info; * @return true on success, false on failure. */ non_null() -bool lan_discovery_send(const Networking_Core *net, const Broadcast_Info *broadcast, const uint8_t *dht_pk, uint16_t port); +bool lan_discovery_send(const Networking_Core *net, const Broadcast_Info *broadcast, const uint8_t *dht_pk, + uint16_t port); /** * Discovers broadcast devices and IP addresses. diff --git a/protocols/Tox/libtox/src/toxcore/Messenger.c b/protocols/Tox/libtox/src/toxcore/Messenger.c index 6042fd725b..118c7d946c 100644 --- a/protocols/Tox/libtox/src/toxcore/Messenger.c +++ b/protocols/Tox/libtox/src/toxcore/Messenger.c @@ -14,7 +14,10 @@ #include <string.h> #include <time.h> +#include "DHT.h" #include "ccompat.h" +#include "group_chats.h" +#include "group_onion_announce.h" #include "logger.h" #include "mono_time.h" #include "network.h" @@ -26,6 +29,16 @@ static_assert(MAX_CONCURRENT_FILE_PIPES <= UINT8_MAX + 1, static const Friend empty_friend = {{0}}; +/** + * Determines if the friendnumber passed is valid in the Messenger object. + * + * @param friendnumber The index in the friend list. + */ +bool friend_is_valid(const Messenger *m, int32_t friendnumber) +{ + return (uint32_t)friendnumber < m->numfriends && m->friendlist[friendnumber].status != 0; +} + /** @brief Set the size of the friend list to numfriends. * * @retval -1 if realloc fails. @@ -107,15 +120,11 @@ void getaddress(const Messenger *m, uint8_t *address) } non_null() -static bool send_online_packet(Messenger *m, int32_t friendnumber) +static bool send_online_packet(Messenger *m, int friendcon_id) { - if (!m_friend_exists(m, friendnumber)) { - return false; - } - uint8_t packet = PACKET_ID_ONLINE; - return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, - m->friendlist[friendnumber].friendcon_id), &packet, sizeof(packet), false) != -1; + return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, friendcon_id), &packet, + sizeof(packet), false) != -1; } non_null() @@ -174,7 +183,7 @@ static int32_t init_new_friend(Messenger *m, const uint8_t *real_pk, uint8_t sta } if (friend_con_connected(m->fr_c, friendcon_id) == FRIENDCONN_STATUS_CONNECTED) { - send_online_packet(m, i); + send_online_packet(m, friendcon_id); } return i; @@ -184,6 +193,20 @@ static int32_t init_new_friend(Messenger *m, const uint8_t *real_pk, uint8_t sta return FAERR_NOMEM; } +non_null() +static int32_t m_add_friend_contact_norequest(Messenger *m, const uint8_t *real_pk) +{ + if (getfriend_id(m, real_pk) != -1) { + return FAERR_ALREADYSENT; + } + + if (pk_equal(real_pk, nc_get_self_public_key(m->net_crypto))) { + return FAERR_OWNKEY; + } + + return init_new_friend(m, real_pk, FRIEND_CONFIRMED); +} + /** * Add a friend. * @@ -268,10 +291,6 @@ int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, u int32_t m_addfriend_norequest(Messenger *m, const uint8_t *real_pk) { - if (getfriend_id(m, real_pk) != -1) { - return FAERR_ALREADYSENT; - } - if (!public_key_valid(real_pk)) { return FAERR_BADCHECKSUM; } @@ -280,7 +299,7 @@ int32_t m_addfriend_norequest(Messenger *m, const uint8_t *real_pk) return FAERR_OWNKEY; } - return init_new_friend(m, real_pk, FRIEND_CONFIRMED); + return m_add_friend_contact_norequest(m, real_pk); } non_null() @@ -344,6 +363,53 @@ static int friend_received_packet(const Messenger *m, int32_t friendnumber, uint m->friendlist[friendnumber].friendcon_id), number); } +bool m_create_group_connection(Messenger *m, GC_Chat *chat) +{ + random_bytes(m->rng, chat->m_group_public_key, CRYPTO_PUBLIC_KEY_SIZE); + const int friendcon_id = new_friend_connection(m->fr_c, chat->m_group_public_key); + + if (friendcon_id == -1) { + return false; + } + + const Friend_Conn *connection = get_conn(m->fr_c, friendcon_id); + + if (connection == nullptr) { + return false; + } + + chat->friend_connection_id = friendcon_id; + + if (friend_con_connected(m->fr_c, friendcon_id) == FRIENDCONN_STATUS_CONNECTED) { + send_online_packet(m, friendcon_id); + } + + const int onion_friend_number = friend_conn_get_onion_friendnum(connection); + Onion_Friend *onion_friend = onion_get_friend(m->onion_c, (uint16_t)onion_friend_number); + + onion_friend_set_gc_public_key(onion_friend, get_chat_id(chat->chat_public_key)); + onion_friend_set_gc_data(onion_friend, nullptr, 0); + + return true; +} + +/** + * Kills the friend connection for a groupchat. + */ +void m_kill_group_connection(Messenger *m, const GC_Chat *chat) +{ + remove_request_received(m->fr, chat->m_group_public_key); + + friend_connection_callbacks(m->fr_c, chat->friend_connection_id, MESSENGER_CALLBACK_INDEX, nullptr, + nullptr, nullptr, nullptr, 0); + + if (friend_con_connected(m->fr_c, chat->friend_connection_id) == FRIENDCONN_STATUS_CONNECTED) { + send_offline_packet(m, chat->friend_connection_id); + } + + kill_friend_connection(m->fr_c, chat->friend_connection_id); +} + non_null(1) nullable(3) static int do_receipts(Messenger *m, int32_t friendnumber, void *userdata) { @@ -991,6 +1057,11 @@ void m_callback_conference_invite(Messenger *m, m_conference_invite_cb *function m->conference_invite = function; } +/** @brief the callback for group invites. */ +void m_callback_group_invite(Messenger *m, m_group_invite_cb *function) +{ + m->group_invite = function; +} /** @brief Send a conference invite packet. * @@ -1002,6 +1073,17 @@ bool send_conference_invite_packet(const Messenger *m, int32_t friendnumber, con return write_cryptpacket_id(m, friendnumber, PACKET_ID_INVITE_CONFERENCE, data, length, false); } + +/** @brief Send a group invite packet. + * + * @retval true if success + */ +bool send_group_invite_packet(const Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length) +{ + return write_cryptpacket_id(m, friendnumber, PACKET_ID_INVITE_GROUPCHAT, data, length, false); +} + + /*** FILE SENDING */ @@ -1922,12 +2004,13 @@ static void check_friend_request_timed_out(Messenger *m, uint32_t i, uint64_t t, } } +non_null(1) nullable(4) static int m_handle_status(void *object, int i, bool status, void *userdata) { Messenger *m = (Messenger *)object; if (status) { /* Went online. */ - send_online_packet(m, i); + send_online_packet(m, m->friendlist[i].friendcon_id); } else { /* Went offline. */ if (m->friendlist[i].status == FRIEND_ONLINE) { set_friend_status(m, i, FRIEND_CONFIRMED, userdata); @@ -1937,321 +2020,396 @@ static int m_handle_status(void *object, int i, bool status, void *userdata) return 0; } -static int m_handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata) +non_null(1, 3) nullable(5) +static int m_handle_packet_offline(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata) { - if (len == 0) { - return -1; + if (data_length == 0) { + set_friend_status(m, i, FRIEND_CONFIRMED, userdata); } - Messenger *m = (Messenger *)object; - const uint8_t packet_id = temp[0]; - const uint8_t *data = temp + 1; - const uint16_t data_length = len - 1; + return 0; +} - if (m->friendlist[i].status != FRIEND_ONLINE) { - if (packet_id == PACKET_ID_ONLINE && len == 1) { - set_friend_status(m, i, FRIEND_ONLINE, userdata); - send_online_packet(m, i); - } else { - return -1; - } +non_null(1, 3) nullable(5) +static int m_handle_packet_nickname(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata) +{ + if (data_length > MAX_NAME_LENGTH) { + return 0; } - switch (packet_id) { - case PACKET_ID_OFFLINE: { - if (data_length > 0) { - break; - } - - set_friend_status(m, i, FRIEND_CONFIRMED, userdata); - break; - } + /* Make sure the NULL terminator is present. */ + VLA(uint8_t, data_terminated, data_length + 1); + memcpy(data_terminated, data, data_length); + data_terminated[data_length] = 0; - case PACKET_ID_NICKNAME: { - if (data_length > MAX_NAME_LENGTH) { - break; - } + /* inform of namechange before we overwrite the old name */ + if (m->friend_namechange != nullptr) { + m->friend_namechange(m, i, data_terminated, data_length, userdata); + } - /* Make sure the NULL terminator is present. */ - VLA(uint8_t, data_terminated, data_length + 1); - memcpy(data_terminated, data, data_length); - data_terminated[data_length] = 0; + memcpy(m->friendlist[i].name, data_terminated, data_length); + m->friendlist[i].name_length = data_length; - /* inform of namechange before we overwrite the old name */ - if (m->friend_namechange != nullptr) { - m->friend_namechange(m, i, data_terminated, data_length, userdata); - } + return 0; +} - memcpy(m->friendlist[i].name, data_terminated, data_length); - m->friendlist[i].name_length = data_length; +non_null(1, 3) nullable(5) +static int m_handle_packet_statusmessage(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata) +{ + if (data_length > MAX_STATUSMESSAGE_LENGTH) { + return 0; + } - break; - } + /* Make sure the NULL terminator is present. */ + VLA(uint8_t, data_terminated, data_length + 1); + memcpy(data_terminated, data, data_length); + data_terminated[data_length] = 0; - case PACKET_ID_STATUSMESSAGE: { - if (data_length > MAX_STATUSMESSAGE_LENGTH) { - break; - } + if (m->friend_statusmessagechange != nullptr) { + m->friend_statusmessagechange(m, i, data_terminated, data_length, userdata); + } - /* Make sure the NULL terminator is present. */ - VLA(uint8_t, data_terminated, data_length + 1); - memcpy(data_terminated, data, data_length); - data_terminated[data_length] = 0; + set_friend_statusmessage(m, i, data_terminated, data_length); - if (m->friend_statusmessagechange != nullptr) { - m->friend_statusmessagechange(m, i, data_terminated, data_length, userdata); - } + return 0; +} - set_friend_statusmessage(m, i, data_terminated, data_length); - break; - } +non_null(1, 3) nullable(5) +static int m_handle_packet_userstatus(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata) +{ + if (data_length != 1) { + return 0; + } - case PACKET_ID_USERSTATUS: { - if (data_length != 1) { - break; - } + const Userstatus status = (Userstatus)data[0]; - const Userstatus status = (Userstatus)data[0]; + if (status >= USERSTATUS_INVALID) { + return 0; + } - if (status >= USERSTATUS_INVALID) { - break; - } + if (m->friend_userstatuschange != nullptr) { + m->friend_userstatuschange(m, i, status, userdata); + } - if (m->friend_userstatuschange != nullptr) { - m->friend_userstatuschange(m, i, status, userdata); - } + set_friend_userstatus(m, i, status); - set_friend_userstatus(m, i, status); - break; - } + return 0; +} - case PACKET_ID_TYPING: { - if (data_length != 1) { - break; - } +non_null(1, 3) nullable(5) +static int m_handle_packet_typing(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata) +{ + if (data_length != 1) { + return 0; + } - const bool typing = data[0] != 0; + const bool typing = data[0] != 0; - set_friend_typing(m, i, typing); + set_friend_typing(m, i, typing); - if (m->friend_typingchange != nullptr) { - m->friend_typingchange(m, i, typing, userdata); - } + if (m->friend_typingchange != nullptr) { + m->friend_typingchange(m, i, typing, userdata); + } - break; - } + return 0; +} - case PACKET_ID_MESSAGE: // fall-through - case PACKET_ID_ACTION: { - if (data_length == 0) { - break; - } +non_null(1, 3) nullable(6) +static int m_handle_packet_message(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, const Message_Type message_type, void *userdata) +{ + if (data_length == 0) { + return 0; + } - const uint8_t *message = data; - const uint16_t message_length = data_length; + const uint8_t *message = data; + const uint16_t message_length = data_length; - /* Make sure the NULL terminator is present. */ - VLA(uint8_t, message_terminated, message_length + 1); - memcpy(message_terminated, message, message_length); - message_terminated[message_length] = 0; - const uint8_t type = packet_id - PACKET_ID_MESSAGE; + /* Make sure the NULL terminator is present. */ + VLA(uint8_t, message_terminated, message_length + 1); + memcpy(message_terminated, message, message_length); + message_terminated[message_length] = 0; - if (m->friend_message != nullptr) { - m->friend_message(m, i, type, message_terminated, message_length, userdata); - } + if (m->friend_message != nullptr) { + m->friend_message(m, i, message_type, message_terminated, message_length, userdata); + } - break; - } + return 0; +} - case PACKET_ID_INVITE_CONFERENCE: { - if (data_length == 0) { - break; - } +non_null(1, 3) nullable(5) +static int m_handle_packet_invite_conference(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata) +{ + if (data_length == 0) { + return 0; + } - if (m->conference_invite != nullptr) { - m->conference_invite(m, i, data, data_length, userdata); - } + if (m->conference_invite != nullptr) { + m->conference_invite(m, i, data, data_length, userdata); + } - break; - } + return 0; +} - case PACKET_ID_FILE_SENDREQUEST: { - const unsigned int head_length = 1 + sizeof(uint32_t) + sizeof(uint64_t) + FILE_ID_LENGTH; +non_null(1, 3) nullable(5) +static int m_handle_packet_file_sendrequest(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata) +{ + const unsigned int head_length = 1 + sizeof(uint32_t) + sizeof(uint64_t) + FILE_ID_LENGTH; - if (data_length < head_length) { - break; - } + if (data_length < head_length) { + return 0; + } - const uint8_t filenumber = data[0]; + const uint8_t filenumber = data[0]; #if UINT8_MAX >= MAX_CONCURRENT_FILE_PIPES - if (filenumber >= MAX_CONCURRENT_FILE_PIPES) { - break; - } + if (filenumber >= MAX_CONCURRENT_FILE_PIPES) { + return 0; + } #endif - uint64_t filesize; - uint32_t file_type; - const uint16_t filename_length = data_length - head_length; + uint64_t filesize; + uint32_t file_type; + const uint16_t filename_length = data_length - head_length; - if (filename_length > MAX_FILENAME_LENGTH) { - break; - } + if (filename_length > MAX_FILENAME_LENGTH) { + return 0; + } - memcpy(&file_type, data + 1, sizeof(file_type)); - file_type = net_ntohl(file_type); + memcpy(&file_type, data + 1, sizeof(file_type)); + file_type = net_ntohl(file_type); - net_unpack_u64(data + 1 + sizeof(uint32_t), &filesize); - struct File_Transfers *ft = &m->friendlist[i].file_receiving[filenumber]; + net_unpack_u64(data + 1 + sizeof(uint32_t), &filesize); + struct File_Transfers *ft = &m->friendlist[i].file_receiving[filenumber]; - if (ft->status != FILESTATUS_NONE) { - break; - } + if (ft->status != FILESTATUS_NONE) { + return 0; + } - ft->status = FILESTATUS_NOT_ACCEPTED; - ft->size = filesize; - ft->transferred = 0; - ft->paused = FILE_PAUSE_NOT; - memcpy(ft->id, data + 1 + sizeof(uint32_t) + sizeof(uint64_t), FILE_ID_LENGTH); + ft->status = FILESTATUS_NOT_ACCEPTED; + ft->size = filesize; + ft->transferred = 0; + ft->paused = FILE_PAUSE_NOT; + memcpy(ft->id, data + 1 + sizeof(uint32_t) + sizeof(uint64_t), FILE_ID_LENGTH); - VLA(uint8_t, filename_terminated, filename_length + 1); - const uint8_t *filename = nullptr; + VLA(uint8_t, filename_terminated, filename_length + 1); + const uint8_t *filename = nullptr; - if (filename_length > 0) { - /* Force NULL terminate file name. */ - memcpy(filename_terminated, data + head_length, filename_length); - filename_terminated[filename_length] = 0; - filename = filename_terminated; - } + if (filename_length > 0) { + /* Force NULL terminate file name. */ + memcpy(filename_terminated, data + head_length, filename_length); + filename_terminated[filename_length] = 0; + filename = filename_terminated; + } - uint32_t real_filenumber = filenumber; - real_filenumber += 1; - real_filenumber <<= 16; + uint32_t real_filenumber = filenumber; + real_filenumber += 1; + real_filenumber <<= 16; - if (m->file_sendrequest != nullptr) { - m->file_sendrequest(m, i, real_filenumber, file_type, filesize, filename, filename_length, - userdata); - } + if (m->file_sendrequest != nullptr) { + m->file_sendrequest(m, i, real_filenumber, file_type, filesize, filename, filename_length, + userdata); + } - break; - } + return 0; +} - case PACKET_ID_FILE_CONTROL: { - if (data_length < 3) { - break; - } +non_null(1, 3) nullable(5) +static int m_handle_packet_file_control(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata) +{ + if (data_length < 3) { + return 0; + } - // On the other side, "outbound" is "inbound", i.e. if they send 1, - // that means "inbound" on their side, but we call it "outbound" - // here. - const bool outbound = data[0] == 1; - uint8_t filenumber = data[1]; - const uint8_t control_type = data[2]; + // On the other side, "outbound" is "inbound", i.e. if they send 1, + // that means "inbound" on their side, but we call it "outbound" + // here. + const bool outbound = data[0] == 1; + const uint8_t filenumber = data[1]; + const uint8_t control_type = data[2]; #if UINT8_MAX >= MAX_CONCURRENT_FILE_PIPES - if (filenumber >= MAX_CONCURRENT_FILE_PIPES) { - break; - } + if (filenumber >= MAX_CONCURRENT_FILE_PIPES) { + return 0; + } #endif - if (handle_filecontrol(m, i, outbound, filenumber, control_type, data + 3, data_length - 3, userdata) == -1) { - // TODO(iphydf): Do something different here? Right now, this - // check is pointless. - break; - } + if (handle_filecontrol(m, i, outbound, filenumber, control_type, data + 3, data_length - 3, userdata) == -1) { + // TODO(iphydf): Do something different here? Right now, this + // check is pointless. + return 0; + } - break; - } + return 0; +} - case PACKET_ID_FILE_DATA: { - if (data_length < 1) { - break; - } +non_null(1, 3) nullable(5) +static int m_handle_packet_file_data(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata) +{ + if (data_length < 1) { + return 0; + } - uint8_t filenumber = data[0]; + const uint8_t filenumber = data[0]; #if UINT8_MAX >= MAX_CONCURRENT_FILE_PIPES - if (filenumber >= MAX_CONCURRENT_FILE_PIPES) { - break; - } + if (filenumber >= MAX_CONCURRENT_FILE_PIPES) { + return 0; + } #endif - struct File_Transfers *ft = &m->friendlist[i].file_receiving[filenumber]; + struct File_Transfers *ft = &m->friendlist[i].file_receiving[filenumber]; - if (ft->status != FILESTATUS_TRANSFERRING) { - break; - } + if (ft->status != FILESTATUS_TRANSFERRING) { + return 0; + } - uint64_t position = ft->transferred; - uint32_t real_filenumber = filenumber; - real_filenumber += 1; - real_filenumber <<= 16; - uint16_t file_data_length = data_length - 1; - const uint8_t *file_data; + uint64_t position = ft->transferred; + uint32_t real_filenumber = filenumber; + real_filenumber += 1; + real_filenumber <<= 16; + uint16_t file_data_length = data_length - 1; + const uint8_t *file_data; - if (file_data_length == 0) { - file_data = nullptr; - } else { - file_data = data + 1; - } + if (file_data_length == 0) { + file_data = nullptr; + } else { + file_data = data + 1; + } - /* Prevent more data than the filesize from being passed to clients. */ - if ((ft->transferred + file_data_length) > ft->size) { - file_data_length = ft->size - ft->transferred; - } + /* Prevent more data than the filesize from being passed to clients. */ + if ((ft->transferred + file_data_length) > ft->size) { + file_data_length = ft->size - ft->transferred; + } - if (m->file_filedata != nullptr) { - m->file_filedata(m, i, real_filenumber, position, file_data, file_data_length, userdata); - } + if (m->file_filedata != nullptr) { + m->file_filedata(m, i, real_filenumber, position, file_data, file_data_length, userdata); + } - ft->transferred += file_data_length; + ft->transferred += file_data_length; - if (file_data_length > 0 && (ft->transferred >= ft->size || file_data_length != MAX_FILE_DATA_SIZE)) { - file_data_length = 0; - file_data = nullptr; - position = ft->transferred; + if (file_data_length > 0 && (ft->transferred >= ft->size || file_data_length != MAX_FILE_DATA_SIZE)) { + file_data_length = 0; + file_data = nullptr; + position = ft->transferred; - /* Full file received. */ - if (m->file_filedata != nullptr) { - m->file_filedata(m, i, real_filenumber, position, file_data, file_data_length, userdata); - } - } + /* Full file received. */ + if (m->file_filedata != nullptr) { + m->file_filedata(m, i, real_filenumber, position, file_data, file_data_length, userdata); + } + } - /* Data is zero, filetransfer is over. */ - if (file_data_length == 0) { - ft->status = FILESTATUS_NONE; - } + /* Data is zero, filetransfer is over. */ + if (file_data_length == 0) { + ft->status = FILESTATUS_NONE; + } - break; - } + return 0; +} - case PACKET_ID_MSI: { - if (data_length == 0) { - break; - } +non_null(1, 3) nullable(5) +static int m_handle_packet_msi(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata) +{ + if (data_length == 0) { + return 0; + } - if (m->msi_packet != nullptr) { - m->msi_packet(m, i, data, data_length, m->msi_packet_userdata); - } + if (m->msi_packet != nullptr) { + m->msi_packet(m, i, data, data_length, m->msi_packet_userdata); + } - break; - } + return 0; +} - default: { - handle_custom_lossless_packet(object, i, temp, len, userdata); - break; +non_null(1, 3) nullable(5) +static int m_handle_packet_invite_groupchat(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata) +{ +#ifndef VANILLA_NACL + + // first two bytes are messenger packet type and group invite type + if (data_length < 2 + GC_JOIN_DATA_LENGTH) { + return 0; + } + + const uint8_t invite_type = data[1]; + const uint8_t *join_data = data + 2; + const uint32_t join_data_len = data_length - 2; + + if (m->group_invite != nullptr && data[1] == GROUP_INVITE && data_length != 2 + GC_JOIN_DATA_LENGTH) { + if (group_not_added(m->group_handler, join_data, join_data_len)) { + m->group_invite(m, i, join_data, GC_JOIN_DATA_LENGTH, + join_data + GC_JOIN_DATA_LENGTH, join_data_len - GC_JOIN_DATA_LENGTH, userdata); } + } else if (invite_type == GROUP_INVITE_ACCEPTED) { + handle_gc_invite_accepted_packet(m->group_handler, i, join_data, join_data_len); + } else if (invite_type == GROUP_INVITE_CONFIRMATION) { + handle_gc_invite_confirmed_packet(m->group_handler, i, join_data, join_data_len); } +#endif // VANILLA_NACL + return 0; } +non_null(1, 3) nullable(5) +static int m_handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata) +{ + if (len == 0) { + return -1; + } + + Messenger *m = (Messenger *)object; + const uint8_t packet_id = temp[0]; + const uint8_t *data = temp + 1; + const uint16_t data_length = len - 1; + + if (m->friendlist[i].status != FRIEND_ONLINE) { + if (packet_id == PACKET_ID_ONLINE && len == 1) { + set_friend_status(m, i, FRIEND_ONLINE, userdata); + send_online_packet(m, m->friendlist[i].friendcon_id); + } else { + return -1; + } + } + + switch (packet_id) { + // TODO(Green-Sky): now all return 0 on error AND success, make errors errors? + case PACKET_ID_OFFLINE: + return m_handle_packet_offline(m, i, data, data_length, userdata); + case PACKET_ID_NICKNAME: + return m_handle_packet_nickname(m, i, data, data_length, userdata); + case PACKET_ID_STATUSMESSAGE: + return m_handle_packet_statusmessage(m, i, data, data_length, userdata); + case PACKET_ID_USERSTATUS: + return m_handle_packet_userstatus(m, i, data, data_length, userdata); + case PACKET_ID_TYPING: + return m_handle_packet_typing(m, i, data, data_length, userdata); + case PACKET_ID_MESSAGE: + return m_handle_packet_message(m, i, data, data_length, MESSAGE_NORMAL, userdata); + case PACKET_ID_ACTION: + return m_handle_packet_message(m, i, data, data_length, MESSAGE_ACTION, userdata); + case PACKET_ID_INVITE_CONFERENCE: + return m_handle_packet_invite_conference(m, i, data, data_length, userdata); + case PACKET_ID_FILE_SENDREQUEST: + return m_handle_packet_file_sendrequest(m, i, data, data_length, userdata); + case PACKET_ID_FILE_CONTROL: + return m_handle_packet_file_control(m, i, data, data_length, userdata); + case PACKET_ID_FILE_DATA: + return m_handle_packet_file_data(m, i, data, data_length, userdata); + case PACKET_ID_MSI: + return m_handle_packet_msi(m, i, data, data_length, userdata); + case PACKET_ID_INVITE_GROUPCHAT: + return m_handle_packet_invite_groupchat(m, i, data, data_length, userdata); + } + + return handle_custom_lossless_packet(object, i, temp, len, userdata); +} + non_null(1) nullable(2) static void do_friends(Messenger *m, void *userdata) { @@ -2370,6 +2528,89 @@ uint32_t messenger_run_interval(const Messenger *m) return crypto_interval; } +/** @brief Attempts to create a DHT announcement for a group chat with our connection info. An + * announcement can only be created if we either have a UDP or TCP connection to the network. + * + * @retval true if success. + */ +#ifndef VANILLA_NACL +non_null() +static bool self_announce_group(const Messenger *m, GC_Chat *chat, Onion_Friend *onion_friend) +{ + GC_Public_Announce announce = {{{{{0}}}}}; + + const bool ip_port_is_set = chat->self_udp_status != SELF_UDP_STATUS_NONE; + const int tcp_num = tcp_copy_connected_relays(chat->tcp_conn, announce.base_announce.tcp_relays, + GCA_MAX_ANNOUNCED_TCP_RELAYS); + + if (tcp_num == 0 && !ip_port_is_set) { + onion_friend_set_gc_data(onion_friend, nullptr, 0); + return false; + } + + announce.base_announce.tcp_relays_count = (uint8_t)tcp_num; + announce.base_announce.ip_port_is_set = (uint8_t)(ip_port_is_set ? 1 : 0); + + if (ip_port_is_set) { + memcpy(&announce.base_announce.ip_port, &chat->self_ip_port, sizeof(IP_Port)); + } + + memcpy(announce.base_announce.peer_public_key, chat->self_public_key, ENC_PUBLIC_KEY_SIZE); + memcpy(announce.chat_public_key, get_chat_id(chat->chat_public_key), ENC_PUBLIC_KEY_SIZE); + + uint8_t gc_data[GCA_MAX_DATA_LENGTH]; + const int length = gca_pack_public_announce(m->log, gc_data, GCA_MAX_DATA_LENGTH, &announce); + + if (length <= 0) { + onion_friend_set_gc_data(onion_friend, nullptr, 0); + return false; + } + + if (gca_add_announce(m->mono_time, m->group_announce, &announce) == nullptr) { + onion_friend_set_gc_data(onion_friend, nullptr, 0); + return false; + } + + onion_friend_set_gc_data(onion_friend, gc_data, (uint16_t)length); + chat->update_self_announces = false; + chat->last_time_self_announce = mono_time_get(chat->mono_time); + + if (tcp_num > 0) { + pk_copy(chat->announced_tcp_relay_pk, announce.base_announce.tcp_relays[0].public_key); + } else { + memset(chat->announced_tcp_relay_pk, 0, sizeof(chat->announced_tcp_relay_pk)); + } + + LOGGER_DEBUG(chat->log, "Published group announce. TCP relays: %d, UDP status: %d", tcp_num, + chat->self_udp_status); + return true; +} + +non_null() +static void do_gc_onion_friends(const Messenger *m) +{ + const uint16_t num_friends = onion_get_friend_count(m->onion_c); + + for (uint16_t i = 0; i < num_friends; ++i) { + Onion_Friend *onion_friend = onion_get_friend(m->onion_c, i); + + if (!onion_friend_is_groupchat(onion_friend)) { + continue; + } + + GC_Chat *chat = gc_get_group_by_public_key(m->group_handler, onion_friend_get_gc_public_key(onion_friend)); + + if (chat == nullptr) { + continue; + } + + if (chat->update_self_announces) { + self_announce_group(m, chat, onion_friend); + } + } +} +#endif // VANILLA_NACL + /** @brief The main loop that needs to be run at least 20 times per second. */ void do_messenger(Messenger *m, void *userdata) { @@ -2406,6 +2647,11 @@ void do_messenger(Messenger *m, void *userdata) do_onion_client(m->onion_c); do_friend_connections(m->fr_c, userdata); do_friends(m, userdata); +#ifndef VANILLA_NACL + do_gc(m->group_handler, userdata); + do_gca(m->mono_time, m->group_announce); + do_gc_onion_friends(m); +#endif m_connection_status_callback(m, userdata); if (mono_time_get(m->mono_time) > m->lastdump + DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS) { @@ -2886,6 +3132,101 @@ static State_Load_Status friends_list_load(Messenger *m, const uint8_t *data, ui return STATE_LOAD_STATUS_CONTINUE; } +#ifndef VANILLA_NACL +non_null() +static void pack_groupchats(const GC_Session *c, Bin_Pack *bp) +{ + assert(bp != nullptr && c != nullptr); + bin_pack_array(bp, gc_count_groups(c)); + + for (uint32_t i = 0; i < c->chats_index; ++i) { // this loop must match the one in gc_count_groups() + const GC_Chat *chat = &c->chats[i]; + + if (!gc_group_is_valid(chat)) { + continue; + } + + gc_group_save(chat, bp); + } +} + +non_null() +static bool pack_groupchats_handler(Bin_Pack *bp, const void *obj) +{ + pack_groupchats((const GC_Session *)obj, bp); + return true; // TODO(iphydf): Return bool from pack functions. +} + +non_null() +static uint32_t saved_groups_size(const Messenger *m) +{ + GC_Session *c = m->group_handler; + return bin_pack_obj_size(pack_groupchats_handler, c); +} + +non_null() +static uint8_t *groups_save(const Messenger *m, uint8_t *data) +{ + const GC_Session *c = m->group_handler; + + const uint32_t num_groups = gc_count_groups(c); + + if (num_groups == 0) { + return data; + } + + const uint32_t len = m_plugin_size(m, STATE_TYPE_GROUPS); + + if (len == 0) { + return data; + } + + data = state_write_section_header(data, STATE_COOKIE_TYPE, len, STATE_TYPE_GROUPS); + + if (!bin_pack_obj(pack_groupchats_handler, c, data, len)) { + LOGGER_FATAL(m->log, "failed to pack group chats into buffer of length %u", len); + return data; + } + + data += len; + + LOGGER_DEBUG(m->log, "Saved %u groups (length %u)", num_groups, len); + + return data; +} + +non_null() +static State_Load_Status groups_load(Messenger *m, const uint8_t *data, uint32_t length) +{ + Bin_Unpack *bu = bin_unpack_new(data, length); + if (bu == nullptr) { + LOGGER_ERROR(m->log, "failed to allocate binary unpacker"); + return STATE_LOAD_STATUS_ERROR; + } + + uint32_t num_groups; + if (!bin_unpack_array(bu, &num_groups)) { + LOGGER_ERROR(m->log, "msgpack failed to unpack groupchats array: expected array"); + bin_unpack_free(bu); + return STATE_LOAD_STATUS_ERROR; + } + + LOGGER_DEBUG(m->log, "Loading %u groups (length %u)", num_groups, length); + + for (uint32_t i = 0; i < num_groups; ++i) { + const int group_number = gc_group_load(m->group_handler, bu); + + if (group_number < 0) { + LOGGER_WARNING(m->log, "Failed to load group %u", i); + } + } + + bin_unpack_free(bu); + + return STATE_LOAD_STATUS_CONTINUE; +} +#endif /* VANILLA_NACL */ + // name state plugin non_null() static uint32_t name_size(const Messenger *m) @@ -3072,6 +3413,9 @@ static void m_register_default_plugins(Messenger *m) m_register_state_plugin(m, STATE_TYPE_STATUSMESSAGE, status_message_size, load_status_message, save_status_message); m_register_state_plugin(m, STATE_TYPE_STATUS, status_size, load_status, save_status); +#ifndef VANILLA_NACL + m_register_state_plugin(m, STATE_TYPE_GROUPS, saved_groups_size, groups_load, groups_save); +#endif m_register_state_plugin(m, STATE_TYPE_TCP_RELAY, tcp_relay_size, load_tcp_relays, save_tcp_relays); m_register_state_plugin(m, STATE_TYPE_PATH_NODE, path_node_size, load_path_nodes, save_path_nodes); } @@ -3244,6 +3588,21 @@ Messenger *new_messenger(Mono_Time *mono_time, const Random *rng, const Network return nullptr; } +#ifndef VANILLA_NACL + m->group_announce = new_gca_list(); + + if (m->group_announce == nullptr) { + kill_net_crypto(m->net_crypto); + kill_dht(m->dht); + kill_networking(m->net); + friendreq_kill(m->fr); + logger_kill(m->log); + free(m); + return nullptr; + } + +#endif /* VANILLA_NACL */ + if (options->dht_announcements_enabled) { m->forwarding = new_forwarding(m->log, m->rng, m->mono_time, m->dht); m->announce = new_announcements(m->log, m->rng, m->mono_time, m->forwarding); @@ -3259,10 +3618,35 @@ Messenger *new_messenger(Mono_Time *mono_time, const Random *rng, const Network if ((options->dht_announcements_enabled && (m->forwarding == nullptr || m->announce == nullptr)) || m->onion == nullptr || m->onion_a == nullptr || m->onion_c == nullptr || m->fr_c == nullptr) { + kill_onion(m->onion); + kill_onion_announce(m->onion_a); + kill_onion_client(m->onion_c); +#ifndef VANILLA_NACL + kill_gca(m->group_announce); +#endif /* VANILLA_NACL */ kill_friend_connections(m->fr_c); + kill_announcements(m->announce); + kill_forwarding(m->forwarding); + kill_net_crypto(m->net_crypto); + kill_dht(m->dht); + kill_networking(m->net); + friendreq_kill(m->fr); + logger_kill(m->log); + free(m); + return nullptr; + } + +#ifndef VANILLA_NACL + gca_onion_init(m->group_announce, m->onion_a); + + m->group_handler = new_dht_groupchats(m); + + if (m->group_handler == nullptr) { kill_onion(m->onion); kill_onion_announce(m->onion_a); kill_onion_client(m->onion_c); + kill_gca(m->group_announce); + kill_friend_connections(m->fr_c); kill_announcements(m->announce); kill_forwarding(m->forwarding); kill_net_crypto(m->net_crypto); @@ -3274,15 +3658,23 @@ Messenger *new_messenger(Mono_Time *mono_time, const Random *rng, const Network return nullptr; } +#endif /* VANILLA_NACL */ + if (options->tcp_server_port != 0) { m->tcp_server = new_TCP_server(m->log, m->rng, m->ns, options->ipv6enabled, 1, &options->tcp_server_port, dht_get_self_secret_key(m->dht), m->onion, m->forwarding); if (m->tcp_server == nullptr) { - kill_friend_connections(m->fr_c); kill_onion(m->onion); kill_onion_announce(m->onion_a); +#ifndef VANILLA_NACL + kill_dht_groupchats(m->group_handler); +#endif + kill_friend_connections(m->fr_c); kill_onion_client(m->onion_c); +#ifndef VANILLA_NACL + kill_gca(m->group_announce); +#endif kill_announcements(m->announce); kill_forwarding(m->forwarding); kill_net_crypto(m->net_crypto); @@ -3332,10 +3724,16 @@ void kill_messenger(Messenger *m) kill_TCP_server(m->tcp_server); } - kill_friend_connections(m->fr_c); kill_onion(m->onion); kill_onion_announce(m->onion_a); +#ifndef VANILLA_NACL + kill_dht_groupchats(m->group_handler); +#endif + kill_friend_connections(m->fr_c); kill_onion_client(m->onion_c); +#ifndef VANILLA_NACL + kill_gca(m->group_announce); +#endif kill_announcements(m->announce); kill_forwarding(m->forwarding); kill_net_crypto(m->net_crypto); diff --git a/protocols/Tox/libtox/src/toxcore/Messenger.h b/protocols/Tox/libtox/src/toxcore/Messenger.h index 4abd7905d0..8279815277 100644 --- a/protocols/Tox/libtox/src/toxcore/Messenger.h +++ b/protocols/Tox/libtox/src/toxcore/Messenger.h @@ -15,6 +15,8 @@ #include "forwarding.h" #include "friend_connection.h" #include "friend_requests.h" +#include "group_announce.h" +#include "group_common.h" #include "logger.h" #include "net_crypto.h" #include "state.h" @@ -35,7 +37,11 @@ typedef enum Message_Type { MESSAGE_ACTION, } Message_Type; +// TODO(Jfreegman, Iphy): Remove this before merge +#ifndef MESSENGER_DEFINED +#define MESSENGER_DEFINED typedef struct Messenger Messenger; +#endif // MESSENGER_DEFINED // Returns the size of the data typedef uint32_t m_state_size_cb(const Messenger *m); @@ -191,6 +197,8 @@ typedef void m_friend_connectionstatuschange_internal_cb(Messenger *m, uint32_t uint8_t connection_status, void *user_data); typedef void m_conference_invite_cb(Messenger *m, uint32_t friend_number, const uint8_t *cookie, uint16_t length, void *user_data); +typedef void m_group_invite_cb(const Messenger *m, uint32_t friendnumber, const uint8_t *data, size_t length, + const uint8_t *group_name, size_t group_name_length, void *userdata); typedef void m_msi_packet_cb(Messenger *m, uint32_t friend_number, const uint8_t *data, uint16_t length, void *user_data); typedef int m_lossy_rtp_packet_cb(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t len, void *object); @@ -269,6 +277,9 @@ struct Messenger { uint64_t lastdump; uint8_t is_receiving_file; + GC_Session *group_handler; + GC_Announces_List *group_announce; + bool has_added_relays; // If the first connection has occurred in do_messenger uint16_t num_loaded_relays; @@ -288,6 +299,8 @@ struct Messenger { struct Group_Chats *conferences_object; /* Set by new_groupchats()*/ m_conference_invite_cb *conference_invite; + m_group_invite_cb *group_invite; + m_file_recv_cb *file_sendrequest; m_file_recv_control_cb *file_filecontrol; m_file_recv_chunk_cb *file_filedata; @@ -306,6 +319,14 @@ struct Messenger { }; /** + * Determines if the friendnumber passed is valid in the Messenger object. + * + * @param friendnumber The index in the friend list. + */ +non_null() +bool friend_is_valid(const Messenger *m, int32_t friendnumber); + +/** * Format: `[real_pk (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]` * * @param[out] address FRIEND_ADDRESS_SIZE byte address to give to others. @@ -348,6 +369,19 @@ int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, u non_null() int32_t m_addfriend_norequest(Messenger *m, const uint8_t *real_pk); +/** @brief Initializes the friend connection and onion connection for a groupchat. + * + * @retval true on success. + */ +non_null() +bool m_create_group_connection(Messenger *m, GC_Chat *chat); + +/* + * Kills the friend connection for a groupchat. + */ +non_null() +void m_kill_group_connection(Messenger *m, const GC_Chat *chat); + /** @return the friend number associated to that public key. * @retval -1 if no such friend. */ @@ -589,6 +623,12 @@ non_null() void m_callback_core_connection(Messenger *m, m_self_connection_statu non_null(1) nullable(2) void m_callback_conference_invite(Messenger *m, m_conference_invite_cb *function); +/* Set the callback for group invites. + */ +non_null(1) nullable(2) +void m_callback_group_invite(Messenger *m, m_group_invite_cb *function); + + /** @brief Send a conference invite packet. * * return true on success @@ -597,6 +637,17 @@ void m_callback_conference_invite(Messenger *m, m_conference_invite_cb *function non_null() bool send_conference_invite_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint16_t length); +/* Send a group invite packet. + * + * WARNING: Return-value semantics are different than for + * send_conference_invite_packet(). + * + * return true on success + */ +non_null() +bool send_group_invite_packet(const Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length); + + /*** FILE SENDING */ @@ -678,7 +729,8 @@ int file_seek(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uin * @retval -7 if wrong position. */ non_null(1) nullable(5) -int send_file_data(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uint64_t position, const uint8_t *data, uint16_t length); +int send_file_data(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uint64_t position, + const uint8_t *data, uint16_t length); /*** A/V related */ diff --git a/protocols/Tox/libtox/src/toxcore/TCP_common.c b/protocols/Tox/libtox/src/toxcore/TCP_common.c index 349e35fda7..a42faced1a 100644 --- a/protocols/Tox/libtox/src/toxcore/TCP_common.c +++ b/protocols/Tox/libtox/src/toxcore/TCP_common.c @@ -278,7 +278,7 @@ int read_packet_TCP_secure_connection( return -1; } - VLA(uint8_t, data_encrypted, *next_packet_length); + VLA(uint8_t, data_encrypted, (int) *next_packet_length); const int len_packet = read_TCP_packet(logger, ns, sock, data_encrypted, *next_packet_length, ip_port); if (len_packet == -1) { @@ -286,7 +286,7 @@ int read_packet_TCP_secure_connection( } if (len_packet != *next_packet_length) { - LOGGER_ERROR(logger, "invalid packet length: %d, expected %d", len_packet, *next_packet_length); + LOGGER_WARNING(logger, "invalid packet length: %d, expected %d", len_packet, *next_packet_length); return 0; } diff --git a/protocols/Tox/libtox/src/toxcore/TCP_common.h b/protocols/Tox/libtox/src/toxcore/TCP_common.h index 88c0cb665a..78d1623d8a 100644 --- a/protocols/Tox/libtox/src/toxcore/TCP_common.h +++ b/protocols/Tox/libtox/src/toxcore/TCP_common.h @@ -23,6 +23,20 @@ void wipe_priority_list(TCP_Priority_List *p); #define NUM_RESERVED_PORTS 16 #define NUM_CLIENT_CONNECTIONS (256 - NUM_RESERVED_PORTS) +#ifdef USE_TEST_NETWORK +#define TCP_PACKET_FORWARD_REQUEST 11 +#define TCP_PACKET_FORWARDING 10 +#define TCP_PACKET_ROUTING_REQUEST 9 +#define TCP_PACKET_ROUTING_RESPONSE 8 +#define TCP_PACKET_CONNECTION_NOTIFICATION 7 +#define TCP_PACKET_DISCONNECT_NOTIFICATION 6 +#define TCP_PACKET_PING 5 +#define TCP_PACKET_PONG 4 +#define TCP_PACKET_OOB_SEND 3 +#define TCP_PACKET_OOB_RECV 2 +#define TCP_PACKET_ONION_REQUEST 1 +#define TCP_PACKET_ONION_RESPONSE 0 +#else #define TCP_PACKET_ROUTING_REQUEST 0 #define TCP_PACKET_ROUTING_RESPONSE 1 #define TCP_PACKET_CONNECTION_NOTIFICATION 2 @@ -35,6 +49,7 @@ void wipe_priority_list(TCP_Priority_List *p); #define TCP_PACKET_ONION_RESPONSE 9 #define TCP_PACKET_FORWARD_REQUEST 10 #define TCP_PACKET_FORWARDING 11 +#endif // test network #define TCP_HANDSHAKE_PLAIN_SIZE (CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE) #define TCP_SERVER_HANDSHAKE_SIZE (CRYPTO_NONCE_SIZE + TCP_HANDSHAKE_PLAIN_SIZE + CRYPTO_MAC_SIZE) diff --git a/protocols/Tox/libtox/src/toxcore/TCP_connection.c b/protocols/Tox/libtox/src/toxcore/TCP_connection.c index c67df1b2eb..4c71f366b3 100644 --- a/protocols/Tox/libtox/src/toxcore/TCP_connection.c +++ b/protocols/Tox/libtox/src/toxcore/TCP_connection.c @@ -277,7 +277,6 @@ static TCP_con *get_tcp_connection(const TCP_Connections *tcp_c, int tcp_connect return &tcp_c->tcp_connections[tcp_connections_number]; } -/** Returns the number of connected TCP relays */ uint32_t tcp_connected_relays_count(const TCP_Connections *tcp_c) { uint32_t count = 0; @@ -635,6 +634,11 @@ static int find_tcp_connection_relay(const TCP_Connections *tcp_c, const uint8_t return -1; } +bool tcp_relay_is_valid(const TCP_Connections *tcp_c, const uint8_t *relay_pk) +{ + return find_tcp_connection_relay(tcp_c, relay_pk) != -1; +} + /** @brief Create a new TCP connection to public_key. * * public_key must be the counterpart to the secret key that the other peer used with `new_tcp_connections()`. diff --git a/protocols/Tox/libtox/src/toxcore/TCP_connection.h b/protocols/Tox/libtox/src/toxcore/TCP_connection.h index 65ead4d87f..0434a73eb0 100644 --- a/protocols/Tox/libtox/src/toxcore/TCP_connection.h +++ b/protocols/Tox/libtox/src/toxcore/TCP_connection.h @@ -78,10 +78,14 @@ const uint8_t *tcp_connections_public_key(const TCP_Connections *tcp_c); non_null() uint32_t tcp_connections_count(const TCP_Connections *tcp_c); -/** Returns the number of connected TCP relays */ +/** @brief Returns the number of connected TCP relays. */ non_null() uint32_t tcp_connected_relays_count(const TCP_Connections *tcp_c); +/** @brief Returns true if we know of a valid TCP relay with the passed public key. */ +non_null() +bool tcp_relay_is_valid(const TCP_Connections *tcp_c, const uint8_t *relay_pk); + /** @brief Send a packet to the TCP connection. * * return -1 on failure. diff --git a/protocols/Tox/libtox/src/toxcore/TCP_server.c b/protocols/Tox/libtox/src/toxcore/TCP_server.c index f571a312d2..ecd557d1b2 100644 --- a/protocols/Tox/libtox/src/toxcore/TCP_server.c +++ b/protocols/Tox/libtox/src/toxcore/TCP_server.c @@ -166,7 +166,7 @@ static void free_accepted_connection_array(TCP_Server *tcp_server) tcp_server->size_accepted_connections = 0; } -/** +/** * @return index corresponding to connection with peer on success * @retval -1 on failure. */ @@ -388,7 +388,7 @@ non_null() static int send_routing_response(const Logger *logger, TCP_Secure_Connection *con, uint8_t rpid, const uint8_t *public_key) { - uint8_t data[1 + 1 + CRYPTO_PUBLIC_KEY_SIZE]; + uint8_t data[2 + CRYPTO_PUBLIC_KEY_SIZE]; data[0] = TCP_PACKET_ROUTING_RESPONSE; data[1] = rpid; memcpy(data + 2, public_key, CRYPTO_PUBLIC_KEY_SIZE); @@ -1033,12 +1033,15 @@ TCP_Server *new_TCP_server(const Logger *logger, const Random *rng, const Networ non_null() static void do_TCP_accept_new(TCP_Server *tcp_server) { - for (uint32_t i = 0; i < tcp_server->num_listening_socks; ++i) { - Socket sock; + for (uint32_t sock_idx = 0; sock_idx < tcp_server->num_listening_socks; ++sock_idx) { + + for (uint32_t connection_idx = 0; connection_idx < MAX_INCOMING_CONNECTIONS; ++connection_idx) { + const Socket sock = net_accept(tcp_server->ns, tcp_server->socks_listening[sock_idx]); - do { - sock = net_accept(tcp_server->ns, tcp_server->socks_listening[i]); - } while (accept_connection(tcp_server, sock) != -1); + if (accept_connection(tcp_server, sock) == -1) { + break; + } + } } } #endif diff --git a/protocols/Tox/libtox/src/toxcore/announce.c b/protocols/Tox/libtox/src/toxcore/announce.c index 7914d19615..647bd21ea3 100644 --- a/protocols/Tox/libtox/src/toxcore/announce.c +++ b/protocols/Tox/libtox/src/toxcore/announce.c @@ -14,9 +14,14 @@ #include "LAN_discovery.h" #include "ccompat.h" +#include "shared_key_cache.h" #include "timed_auth.h" #include "util.h" +// Settings for the shared key cache +#define MAX_KEYS_PER_SLOT 4 +#define KEYS_TIMEOUT 600 + uint8_t announce_response_of_request_type(uint8_t request_type) { switch (request_type) { @@ -53,7 +58,7 @@ struct Announcements { const uint8_t *public_key; const uint8_t *secret_key; - Shared_Keys shared_keys; + Shared_Key_Cache *shared_keys; uint8_t hmac_key[CRYPTO_HMAC_KEY_SIZE]; int32_t synch_offset; @@ -429,10 +434,13 @@ static int create_reply_plain_store_announce_request(Announcements *announce, } VLA(uint8_t, plain, plain_len); - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - get_shared_key(announce->mono_time, &announce->shared_keys, shared_key, - announce->secret_key, data_public_key); + const uint8_t* shared_key = shared_key_cache_lookup(announce->shared_keys, data_public_key); + + if (shared_key == nullptr) { + /* Error looking up/deriving the shared key */ + return -1; + } if (decrypt_data_symmetric(shared_key, data + CRYPTO_PUBLIC_KEY_SIZE, @@ -549,9 +557,7 @@ static int create_reply(Announcements *announce, const IP_Port *source, } VLA(uint8_t, plain, plain_len); - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - - dht_get_shared_key_recv(announce->dht, shared_key, data + 1); + const uint8_t *shared_key = dht_get_shared_key_recv(announce->dht, data + 1); if (decrypt_data_symmetric(shared_key, data + 1 + CRYPTO_PUBLIC_KEY_SIZE, @@ -652,6 +658,11 @@ Announcements *new_announcements(const Logger *log, const Random *rng, const Mon announce->public_key = dht_get_self_public_key(announce->dht); announce->secret_key = dht_get_self_secret_key(announce->dht); new_hmac_key(announce->rng, announce->hmac_key); + announce->shared_keys = shared_key_cache_new(mono_time, announce->secret_key, KEYS_TIMEOUT, MAX_KEYS_PER_SLOT); + if (announce->shared_keys == nullptr) { + free(announce); + return nullptr; + } announce->start_time = mono_time_get(announce->mono_time); @@ -677,7 +688,7 @@ void kill_announcements(Announcements *announce) networking_registerhandler(announce->net, NET_PACKET_STORE_ANNOUNCE_REQUEST, nullptr, nullptr); crypto_memzero(announce->hmac_key, CRYPTO_HMAC_KEY_SIZE); - crypto_memzero(&announce->shared_keys, sizeof(Shared_Keys)); + shared_key_cache_free(announce->shared_keys); for (uint32_t i = 0; i < ANNOUNCE_BUCKETS * ANNOUNCE_BUCKET_SIZE; ++i) { if (announce->entries[i].data != nullptr) { diff --git a/protocols/Tox/libtox/src/toxcore/bin_pack.c b/protocols/Tox/libtox/src/toxcore/bin_pack.c index ca8940ee44..3575803aed 100644 --- a/protocols/Tox/libtox/src/toxcore/bin_pack.c +++ b/protocols/Tox/libtox/src/toxcore/bin_pack.c @@ -127,6 +127,11 @@ bool bin_pack_bin(Bin_Pack *bp, const uint8_t *data, uint32_t length) return cmp_write_bin(&bp->ctx, data, length); } +bool bin_pack_nil(Bin_Pack *bp) +{ + return cmp_write_nil(&bp->ctx); +} + bool bin_pack_bin_marker(Bin_Pack *bp, uint32_t size) { return cmp_write_bin_marker(&bp->ctx, size); @@ -159,3 +164,4 @@ bool bin_pack_bin_b(Bin_Pack *bp, const uint8_t *data, uint32_t length) { return bp->ctx.write(&bp->ctx, data, length) == length; } + diff --git a/protocols/Tox/libtox/src/toxcore/bin_pack.h b/protocols/Tox/libtox/src/toxcore/bin_pack.h index 542f533b88..51646c088a 100644 --- a/protocols/Tox/libtox/src/toxcore/bin_pack.h +++ b/protocols/Tox/libtox/src/toxcore/bin_pack.h @@ -90,9 +90,10 @@ non_null() bool bin_pack_u16(Bin_Pack *bp, uint16_t val); non_null() bool bin_pack_u32(Bin_Pack *bp, uint32_t val); /** @brief Pack a `uint64_t` as MessagePack positive integer. */ non_null() bool bin_pack_u64(Bin_Pack *bp, uint64_t val); +/** @brief Pack an empty array member as a MessagePack nil value. */ +non_null() bool bin_pack_nil(Bin_Pack *bp); /** @brief Pack a byte array as MessagePack bin. */ non_null() bool bin_pack_bin(Bin_Pack *bp, const uint8_t *data, uint32_t length); - /** @brief Start packing a custom binary representation. * * A call to this function must be followed by exactly `size` bytes packed by functions below. diff --git a/protocols/Tox/libtox/src/toxcore/bin_unpack.c b/protocols/Tox/libtox/src/toxcore/bin_unpack.c index e4daec3a22..ff591ca87a 100644 --- a/protocols/Tox/libtox/src/toxcore/bin_unpack.c +++ b/protocols/Tox/libtox/src/toxcore/bin_unpack.c @@ -104,6 +104,11 @@ bool bin_unpack_u64(Bin_Unpack *bu, uint64_t *val) return cmp_read_ulong(&bu->ctx, val); } +bool bin_unpack_nil(Bin_Unpack *bu) +{ + return cmp_read_nil(&bu->ctx); +} + bool bin_unpack_bin(Bin_Unpack *bu, uint8_t **data_ptr, uint32_t *data_length_ptr) { uint32_t bin_size; diff --git a/protocols/Tox/libtox/src/toxcore/bin_unpack.h b/protocols/Tox/libtox/src/toxcore/bin_unpack.h index c6ead96e1b..bd4d8785c1 100644 --- a/protocols/Tox/libtox/src/toxcore/bin_unpack.h +++ b/protocols/Tox/libtox/src/toxcore/bin_unpack.h @@ -60,6 +60,9 @@ non_null() bool bin_unpack_u16(Bin_Unpack *bu, uint16_t *val); non_null() bool bin_unpack_u32(Bin_Unpack *bu, uint32_t *val); /** @brief Unpack a MessagePack positive int into a `uint64_t`. */ non_null() bool bin_unpack_u64(Bin_Unpack *bu, uint64_t *val); +/** @brief Unpack a Messagepack nil value. */ +non_null() bool bin_unpack_nil(Bin_Unpack *bu); + /** @brief Unpack a MessagePack bin into a newly allocated byte array. * * Allocates a new byte array and stores it into `data_ptr` with its length stored in diff --git a/protocols/Tox/libtox/src/toxcore/crypto_core.c b/protocols/Tox/libtox/src/toxcore/crypto_core.c index 1ec2cee5fd..14025252c4 100644 --- a/protocols/Tox/libtox/src/toxcore/crypto_core.c +++ b/protocols/Tox/libtox/src/toxcore/crypto_core.c @@ -176,7 +176,7 @@ bool crypto_memunlock(void *data, size_t length) #endif } -bool pk_equal(const uint8_t *pk1, const uint8_t *pk2) +bool pk_equal(const uint8_t pk1[CRYPTO_PUBLIC_KEY_SIZE], const uint8_t pk2[CRYPTO_PUBLIC_KEY_SIZE]) { #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION // Hope that this is better for the fuzzer @@ -186,7 +186,7 @@ bool pk_equal(const uint8_t *pk1, const uint8_t *pk2) #endif } -void pk_copy(uint8_t *dest, const uint8_t *src) +void pk_copy(uint8_t dest[CRYPTO_PUBLIC_KEY_SIZE], const uint8_t src[CRYPTO_PUBLIC_KEY_SIZE]) { memcpy(dest, src, CRYPTO_PUBLIC_KEY_SIZE); } @@ -472,7 +472,7 @@ int32_t crypto_new_keypair(const Random *rng, uint8_t *public_key, uint8_t *secr #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION random_bytes(rng, secret_key, CRYPTO_SECRET_KEY_SIZE); memset(public_key, 0, CRYPTO_PUBLIC_KEY_SIZE); // Make MSAN happy - crypto_scalarmult_curve25519_base(public_key, secret_key); + crypto_derive_public_key(public_key, secret_key); return 0; #else return crypto_box_keypair(public_key, secret_key); @@ -484,7 +484,7 @@ void crypto_derive_public_key(uint8_t *public_key, const uint8_t *secret_key) crypto_scalarmult_curve25519_base(public_key, secret_key); } -void new_hmac_key(const Random *rng, uint8_t *key) +void new_hmac_key(const Random *rng, uint8_t key[CRYPTO_HMAC_KEY_SIZE]) { random_bytes(rng, key, CRYPTO_HMAC_KEY_SIZE); } @@ -492,13 +492,22 @@ void new_hmac_key(const Random *rng, uint8_t *key) void crypto_hmac(uint8_t auth[CRYPTO_HMAC_SIZE], const uint8_t key[CRYPTO_HMAC_KEY_SIZE], const uint8_t *data, size_t length) { +#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION + memcpy(auth, key, 16); + memcpy(auth + 16, data, length < 16 ? length : 16); +#else crypto_auth(auth, data, length, key); +#endif } bool crypto_hmac_verify(const uint8_t auth[CRYPTO_HMAC_SIZE], const uint8_t key[CRYPTO_HMAC_KEY_SIZE], const uint8_t *data, size_t length) { +#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION + return memcmp(auth, key, 16) == 0 && memcmp(auth + 16, data, length < 16 ? length : 16) == 0; +#else return crypto_auth_verify(auth, data, length, key) == 0; +#endif } void crypto_sha256(uint8_t *hash, const uint8_t *data, size_t length) diff --git a/protocols/Tox/libtox/src/toxcore/crypto_core.h b/protocols/Tox/libtox/src/toxcore/crypto_core.h index 0aaadeacf1..3b9f27d677 100644 --- a/protocols/Tox/libtox/src/toxcore/crypto_core.h +++ b/protocols/Tox/libtox/src/toxcore/crypto_core.h @@ -358,7 +358,7 @@ int32_t decrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const /** * @brief Fast encrypt/decrypt operations. * - * Use if this is not a one-time communication. @ref encrypt_precompute does the + * Use if this is not a one-time communication. `encrypt_precompute` does the * shared-key generation once so it does not have to be performed on every * encrypt/decrypt. */ diff --git a/protocols/Tox/libtox/src/toxcore/friend_connection.c b/protocols/Tox/libtox/src/toxcore/friend_connection.c index 9e5dee7cbd..7b8537c720 100644 --- a/protocols/Tox/libtox/src/toxcore/friend_connection.c +++ b/protocols/Tox/libtox/src/toxcore/friend_connection.c @@ -31,7 +31,7 @@ struct Friend_Conn { uint8_t real_public_key[CRYPTO_PUBLIC_KEY_SIZE]; uint8_t dht_temp_pk[CRYPTO_PUBLIC_KEY_SIZE]; - uint16_t dht_lock; + uint32_t dht_lock_token; IP_Port dht_ip_port; uint64_t dht_pk_lastrecv; uint64_t dht_ip_port_lastrecv; @@ -197,7 +197,7 @@ Friend_Conn *get_conn(const Friend_Connections *fr_c, int friendcon_id) return &fr_c->conns[friendcon_id]; } -/** +/** * @return friendcon_id corresponding to the real public key on success. * @retval -1 on failure. */ @@ -377,16 +377,15 @@ static void change_dht_pk(Friend_Connections *fr_c, int friendcon_id, const uint friend_con->dht_pk_lastrecv = mono_time_get(fr_c->mono_time); - if (friend_con->dht_lock > 0) { - if (dht_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock) != 0) { + if (friend_con->dht_lock_token > 0) { + if (dht_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock_token) != 0) { LOGGER_ERROR(fr_c->logger, "a. Could not delete dht peer. Please report this."); return; } - - friend_con->dht_lock = 0; + friend_con->dht_lock_token = 0; } - dht_addfriend(fr_c->dht, dht_public_key, dht_ip_callback, fr_c, friendcon_id, &friend_con->dht_lock); + dht_addfriend(fr_c->dht, dht_public_key, dht_ip_callback, fr_c, friendcon_id, &friend_con->dht_lock_token); memcpy(friend_con->dht_temp_pk, dht_public_key, CRYPTO_PUBLIC_KEY_SIZE); } @@ -609,7 +608,7 @@ static int friend_new_connection(Friend_Connections *fr_c, int friendcon_id) } /* If dht_temp_pk does not contains a pk. */ - if (friend_con->dht_lock == 0) { + if (friend_con->dht_lock_token == 0) { return -1; } @@ -838,8 +837,9 @@ int kill_friend_connection(Friend_Connections *fr_c, int friendcon_id) onion_delfriend(fr_c->onion_c, friend_con->onion_friendnum); crypto_kill(fr_c->net_crypto, friend_con->crypt_connection_id); - if (friend_con->dht_lock > 0) { - dht_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock); + if (friend_con->dht_lock_token > 0) { + dht_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock_token); + friend_con->dht_lock_token = 0; } return wipe_friend_conn(fr_c, friendcon_id); @@ -882,7 +882,8 @@ int send_friend_request_packet(Friend_Connections *fr_c, int friendcon_id, uint3 if (friend_con->status == FRIENDCONN_STATUS_CONNECTED) { packet[0] = PACKET_ID_FRIEND_REQUESTS; - return write_cryptpacket(fr_c->net_crypto, friend_con->crypt_connection_id, packet, SIZEOF_VLA(packet), false) != -1 ? 1 : 0; + return write_cryptpacket(fr_c->net_crypto, friend_con->crypt_connection_id, packet, SIZEOF_VLA(packet), + false) != -1 ? 1 : 0; } packet[0] = CRYPTO_PACKET_FRIEND_REQ; @@ -967,9 +968,9 @@ void do_friend_connections(Friend_Connections *fr_c, void *userdata) if (friend_con != nullptr) { if (friend_con->status == FRIENDCONN_STATUS_CONNECTING) { if (friend_con->dht_pk_lastrecv + FRIEND_DHT_TIMEOUT < temp_time) { - if (friend_con->dht_lock > 0) { - dht_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock); - friend_con->dht_lock = 0; + if (friend_con->dht_lock_token > 0) { + dht_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock_token); + friend_con->dht_lock_token = 0; memset(friend_con->dht_temp_pk, 0, CRYPTO_PUBLIC_KEY_SIZE); } } @@ -978,7 +979,7 @@ void do_friend_connections(Friend_Connections *fr_c, void *userdata) friend_con->dht_ip_port.ip.family = net_family_unspec(); } - if (friend_con->dht_lock > 0) { + if (friend_con->dht_lock_token > 0) { if (friend_new_connection(fr_c, i) == 0) { set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, &friend_con->dht_ip_port, false); connect_to_saved_tcp_relays(fr_c, i, MAX_FRIEND_TCP_CONNECTIONS / 2); /* Only fill it half up. */ diff --git a/protocols/Tox/libtox/src/toxcore/group_announce.c b/protocols/Tox/libtox/src/toxcore/group_announce.c index 83dd3acf54..896b043dbd 100644 --- a/protocols/Tox/libtox/src/toxcore/group_announce.c +++ b/protocols/Tox/libtox/src/toxcore/group_announce.c @@ -186,7 +186,7 @@ static int gca_unpack_announce(const Logger *log, const uint8_t *data, uint16_t memcpy(announce->peer_public_key, data + offset, ENC_PUBLIC_KEY_SIZE); offset += ENC_PUBLIC_KEY_SIZE; - announce->ip_port_is_set = data[offset] == 1; + net_unpack_bool(&data[offset], &announce->ip_port_is_set); ++offset; announce->tcp_relays_count = data[offset]; diff --git a/protocols/Tox/libtox/src/toxcore/group_announce.h b/protocols/Tox/libtox/src/toxcore/group_announce.h index 11bba7d530..801363d6b2 100644 --- a/protocols/Tox/libtox/src/toxcore/group_announce.h +++ b/protocols/Tox/libtox/src/toxcore/group_announce.h @@ -20,7 +20,7 @@ extern "C" { /* The maximum number of announces to save for a particular group chat. */ #define GCA_MAX_SAVED_ANNOUNCES_PER_GC 16 -/* Maximum number of TCP relays that can be in an annoucne. */ +/* Maximum number of TCP relays that can be in an announce. */ #define GCA_MAX_ANNOUNCED_TCP_RELAYS 1 /* Maximum number of announces we can send in an announce response. */ diff --git a/protocols/Tox/libtox/src/toxcore/group_chats.c b/protocols/Tox/libtox/src/toxcore/group_chats.c new file mode 100644 index 0000000000..f9cb2d18fb --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/group_chats.c @@ -0,0 +1,8410 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Copyright © 2016-2020 The TokTok team. + * Copyright © 2015 Tox project. + */ + +/** + * An implementation of massive text only group chats. + */ + +#include "group_chats.h" + +#include <assert.h> + +#ifndef VANILLA_NACL +#include <sodium.h> +#endif + +#include <string.h> + +#include "DHT.h" +#include "LAN_discovery.h" +#include "Messenger.h" +#include "TCP_connection.h" +#include "ccompat.h" +#include "friend_connection.h" +#include "group_common.h" +#include "group_moderation.h" +#include "group_pack.h" +#include "mono_time.h" +#include "network.h" +#include "util.h" + +#ifndef VANILLA_NACL + +/* The minimum size of a plaintext group handshake packet */ +#define GC_MIN_HS_PACKET_PAYLOAD_SIZE (1 + ENC_PUBLIC_KEY_SIZE + SIG_PUBLIC_KEY_SIZE + 1 + 1) + +/* The minimum size of an encrypted group handshake packet. */ +#define GC_MIN_ENCRYPTED_HS_PAYLOAD_SIZE (1 + ENC_PUBLIC_KEY_SIZE + ENC_PUBLIC_KEY_SIZE +\ + GC_MIN_HS_PACKET_PAYLOAD_SIZE + CRYPTO_NONCE_SIZE + CRYPTO_MAC_SIZE) + +/* Size of a group's shared state in packed format */ +#define GC_PACKED_SHARED_STATE_SIZE (EXT_PUBLIC_KEY_SIZE + sizeof(uint16_t) + MAX_GC_GROUP_NAME_SIZE +\ + sizeof(uint16_t) + 1 + sizeof(uint16_t) + MAX_GC_PASSWORD_SIZE +\ + MOD_MODERATION_HASH_SIZE + sizeof(uint32_t) + sizeof(uint32_t) + 1) + +/* Minimum size of a topic packet; includes topic length, public signature key, topic version and checksum */ +#define GC_MIN_PACKED_TOPIC_INFO_SIZE (sizeof(uint16_t) + SIG_PUBLIC_KEY_SIZE + sizeof(uint32_t) + sizeof(uint16_t)) + +#define GC_SHARED_STATE_ENC_PACKET_SIZE (SIGNATURE_SIZE + GC_PACKED_SHARED_STATE_SIZE) + +/* Header information attached to all broadcast messages: broadcast_type */ +#define GC_BROADCAST_ENC_HEADER_SIZE 1 + +/* Size of a group packet message ID */ +#define GC_MESSAGE_ID_BYTES sizeof(uint64_t) + +/* Size of a lossless ack packet */ +#define GC_LOSSLESS_ACK_PACKET_SIZE (GC_MESSAGE_ID_BYTES + 1) + +/* Smallest possible size of an encrypted lossless payload. + * + * Data includes the message_id, group packet type, and the nonce and MAC for decryption. + */ +#define GC_MIN_LOSSLESS_PAYLOAD_SIZE (GC_MESSAGE_ID_BYTES + CRYPTO_NONCE_SIZE + 1 + CRYPTO_MAC_SIZE) + +/* Smallest possible size of a lossy group packet */ +#define GC_MIN_LOSSY_PAYLOAD_SIZE (GC_MIN_LOSSLESS_PAYLOAD_SIZE - GC_MESSAGE_ID_BYTES) + +/* Maximum number of bytes to pad packets with. + * + * Packets are padded with a random number of zero bytes between zero and this value in order to hide + * the true length of the message, which reduces the amount of metadata leaked through packet analysis. + * + * Note: This behaviour was copied from the toxcore encryption implementation in net_crypto.c. + */ +#define GC_MAX_PACKET_PADDING 8 + +/* Minimum size of a ping packet, which contains the peer count, peer list checksum, shared state version, + * sanctions list version, sanctions list checksum, topic version, and topic checksum + */ +#define GC_PING_PACKET_MIN_DATA_SIZE ((sizeof(uint16_t) * 4) + (sizeof(uint32_t) * 3)) + +/* How often in seconds we can send a group sync request packet */ +#define GC_SYNC_REQUEST_LIMIT (GC_PING_TIMEOUT + 1) + +/* How often in seconds we can send the peer list to any peer in the group in a sync response */ +#define GC_SYNC_RESPONSE_PEER_LIST_LIMIT 3 + +/* How often in seconds we try to handshake with an unconfirmed peer */ +#define GC_SEND_HANDSHAKE_INTERVAL 3 + +/* How often in seconds we rotate session encryption keys with a peer */ +#define GC_KEY_ROTATION_TIMEOUT (5 * 60) + +/* How often in seconds we try to reconnect to peers that recently timed out */ +#define GC_TIMED_OUT_RECONN_TIMEOUT (GC_UNCONFIRMED_PEER_TIMEOUT * 3) + +/* How long in seconds before we stop trying to reconnect with a timed out peer */ +#define GC_TIMED_OUT_STALE_TIMEOUT (60 * 15) + +/* The value the topic lock is set to when the topic lock is enabled. */ +#define GC_TOPIC_LOCK_ENABLED 0 + +static_assert(GCC_BUFFER_SIZE <= UINT16_MAX, + "GCC_BUFFER_SIZE must be <= UINT16_MAX)"); + +static_assert(MAX_GC_PACKET_CHUNK_SIZE < MAX_GC_PACKET_SIZE, + "MAX_GC_PACKET_CHUNK_SIZE must be < MAX_GC_PACKET_SIZE"); + +// size of a lossless handshake packet - lossless packets can't/shouldn't be split up +static_assert(MAX_GC_PACKET_CHUNK_SIZE >= 171, + "MAX_GC_PACKET_CHUNK_SIZE must be >= 171"); + +// group_moderation constants assume this is the max packet size. +static_assert(MAX_GC_PACKET_SIZE >= 50000, + "MAX_GC_PACKET_SIZE doesn't match constants in group_moderation.h"); + +static_assert(MAX_GC_PACKET_SIZE <= UINT16_MAX - MAX_GC_PACKET_CHUNK_SIZE, + "MAX_GC_PACKET_SIZE must be <= UINT16_MAX - MAX_GC_PACKET_CHUNK_SIZE"); + +/** Types of broadcast messages. */ +typedef enum Group_Message_Type { + GC_MESSAGE_TYPE_NORMAL = 0x00, + GC_MESSAGE_TYPE_ACTION = 0x01, +} Group_Message_Type; + +/** Types of handshake request packets. */ +typedef enum Group_Handshake_Packet_Type { + GH_REQUEST = 0x00, // Requests a handshake + GH_RESPONSE = 0x01, // Responds to a handshake request +} Group_Handshake_Packet_Type; + +/** Types of handshake requests (within a handshake request packet). */ +typedef enum Group_Handshake_Request_Type { + HS_INVITE_REQUEST = 0x00, // Requests an invite to the group + HS_PEER_INFO_EXCHANGE = 0x01, // Requests a peer info exchange +} Group_Handshake_Request_Type; + +/** These bitmasks determine what group state info a peer is requesting in a sync request */ +typedef enum Group_Sync_Flags { + GF_PEERS = (1 << 0), // 1 + GF_TOPIC = (1 << 1), // 2 + GF_STATE = (1 << 2), // 4 +} Group_Sync_Flags; + +non_null() static bool self_gc_is_founder(const GC_Chat *chat); +non_null() static bool group_number_valid(const GC_Session *c, int group_number); +non_null() static int peer_update(const GC_Chat *chat, const GC_Peer *peer, uint32_t peer_number); +non_null() static void group_delete(GC_Session *c, GC_Chat *chat); +non_null() static void group_cleanup(GC_Session *c, GC_Chat *chat); +non_null() static bool group_exists(const GC_Session *c, const uint8_t *chat_id); +non_null() static void add_tcp_relays_to_chat(const GC_Session *c, GC_Chat *chat); +non_null(1, 2) nullable(4) +static bool peer_delete(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, void *userdata); +non_null() static void create_gc_session_keypair(const Logger *log, const Random *rng, uint8_t *public_key, + uint8_t *secret_key); +non_null() static size_t load_gc_peers(GC_Chat *chat, const GC_SavedPeerInfo *addrs, uint16_t num_addrs); +non_null() static bool saved_peer_is_valid(const GC_SavedPeerInfo *saved_peer); + +static const GC_Chat empty_gc_chat = {nullptr}; + +non_null() +static void kill_group_friend_connection(const GC_Session *c, const GC_Chat *chat) +{ + if (chat->friend_connection_id != -1) { + m_kill_group_connection(c->messenger, chat); + } +} + +uint16_t gc_get_wrapped_packet_size(uint16_t length, Net_Packet_Type packet_type) +{ + assert(length <= MAX_GC_PACKET_CHUNK_SIZE); + + const uint16_t min_header_size = packet_type == NET_PACKET_GC_LOSSY + ? GC_MIN_LOSSY_PAYLOAD_SIZE + : GC_MIN_LOSSLESS_PAYLOAD_SIZE; + const uint16_t header_size = ENC_PUBLIC_KEY_SIZE + GC_MAX_PACKET_PADDING + min_header_size; + + assert(length <= UINT16_MAX - header_size); + + return length + header_size; +} + +/** Return true if `peer_number` is our own. */ +static bool peer_number_is_self(int peer_number) +{ + return peer_number == 0; +} + +bool gc_peer_number_is_valid(const GC_Chat *chat, int peer_number) +{ + return peer_number >= 0 && peer_number < (int)chat->numpeers; +} + +non_null() +static GC_Peer *get_gc_peer(const GC_Chat *chat, int peer_number) +{ + if (!gc_peer_number_is_valid(chat, peer_number)) { + return nullptr; + } + + return &chat->group[peer_number]; +} + +GC_Connection *get_gc_connection(const GC_Chat *chat, int peer_number) +{ + GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return nullptr; + } + + return &peer->gconn; +} + +/** Returns the amount of empty padding a packet of designated length should have. */ +static uint16_t group_packet_padding_length(uint16_t length) +{ + return (MAX_GC_PACKET_CHUNK_SIZE - length) % GC_MAX_PACKET_PADDING; +} + +void gc_get_self_nick(const GC_Chat *chat, uint8_t *nick) +{ + if (nick != nullptr) { + const GC_Peer *peer = get_gc_peer(chat, 0); + assert(peer != nullptr); + assert(peer->nick_length > 0); + + memcpy(nick, peer->nick, peer->nick_length); + } +} + +uint16_t gc_get_self_nick_size(const GC_Chat *chat) +{ + const GC_Peer *peer = get_gc_peer(chat, 0); + assert(peer != nullptr); + + return peer->nick_length; +} + +/** @brief Sets self nick to `nick`. + * + * Returns false if `nick` is null or `length` is greater than MAX_GC_NICK_SIZE. + */ +non_null() +static bool self_gc_set_nick(const GC_Chat *chat, const uint8_t *nick, uint16_t length) +{ + if (nick == nullptr || length > MAX_GC_NICK_SIZE) { + return false; + } + + GC_Peer *peer = get_gc_peer(chat, 0); + assert(peer != nullptr); + + memcpy(peer->nick, nick, length); + peer->nick_length = length; + + return true; +} + +Group_Role gc_get_self_role(const GC_Chat *chat) +{ + + const GC_Peer *peer = get_gc_peer(chat, 0); + assert(peer != nullptr); + + return peer->role; +} + +/** Sets self role. If role is invalid this function has no effect. */ +non_null() +static void self_gc_set_role(const GC_Chat *chat, Group_Role role) +{ + if (role <= GR_OBSERVER) { + GC_Peer *peer = get_gc_peer(chat, 0); + assert(peer != nullptr); + + peer->role = role; + } +} + +uint8_t gc_get_self_status(const GC_Chat *chat) +{ + const GC_Peer *peer = get_gc_peer(chat, 0); + assert(peer != nullptr); + + return peer->status; +} + +/** Sets self status. If status is invalid this function has no effect. */ +non_null() +static void self_gc_set_status(const GC_Chat *chat, Group_Peer_Status status) +{ + if (status == GS_NONE || status == GS_AWAY || status == GS_BUSY) { + GC_Peer *peer = get_gc_peer(chat, 0); + assert(peer != nullptr); + peer->status = status; + return; + } + + LOGGER_WARNING(chat->log, "Attempting to set user status with invalid status: %u", (uint8_t)status); +} + +uint32_t gc_get_self_peer_id(const GC_Chat *chat) +{ + const GC_Peer *peer = get_gc_peer(chat, 0); + assert(peer != nullptr); + + return peer->peer_id; +} + +/** Sets self confirmed status. */ +non_null() +static void self_gc_set_confirmed(const GC_Chat *chat, bool confirmed) +{ + GC_Connection *gconn = get_gc_connection(chat, 0); + assert(gconn != nullptr); + + gconn->confirmed = confirmed; +} + +/** Returns true if self has the founder role */ +non_null() +static bool self_gc_is_founder(const GC_Chat *chat) +{ + return gc_get_self_role(chat) == GR_FOUNDER; +} + +void gc_get_self_public_key(const GC_Chat *chat, uint8_t *public_key) +{ + if (public_key != nullptr) { + memcpy(public_key, chat->self_public_key, ENC_PUBLIC_KEY_SIZE); + } +} + +/** @brief Sets self extended public key to `ext_public_key`. + * + * If `ext_public_key` is null this function has no effect. + */ +non_null() +static void self_gc_set_ext_public_key(const GC_Chat *chat, const uint8_t *ext_public_key) +{ + if (ext_public_key != nullptr) { + GC_Connection *gconn = get_gc_connection(chat, 0); + assert(gconn != nullptr); + memcpy(gconn->addr.public_key, ext_public_key, EXT_PUBLIC_KEY_SIZE); + } +} + +/** + * Return true if `peer` has permission to speak according to the `voice_state`. + */ +non_null() +static bool peer_has_voice(const GC_Peer *peer, Group_Voice_State voice_state) +{ + const Group_Role role = peer->role; + + switch (voice_state) { + case GV_ALL: + return role <= GR_USER; + + case GV_MODS: + return role <= GR_MODERATOR; + + case GV_FOUNDER: + return role == GR_FOUNDER; + + default: + return false; + } +} + +int pack_gc_saved_peers(const GC_Chat *chat, uint8_t *data, uint16_t length, uint16_t *processed) +{ + uint16_t packed_len = 0; + uint16_t count = 0; + + for (uint32_t i = 0; i < GC_MAX_SAVED_PEERS; ++i) { + const GC_SavedPeerInfo *saved_peer = &chat->saved_peers[i]; + + if (!saved_peer_is_valid(saved_peer)) { + continue; + } + + int packed_ipp_len = 0; + int packed_tcp_len = 0; + + if (ipport_isset(&saved_peer->ip_port)) { + if (packed_len > length) { + return -1; + } + + packed_ipp_len = pack_ip_port(chat->log, data + packed_len, length - packed_len, &saved_peer->ip_port); + + if (packed_ipp_len > 0) { + packed_len += packed_ipp_len; + } + } + + if (ipport_isset(&saved_peer->tcp_relay.ip_port)) { + if (packed_len > length) { + return -1; + } + + packed_tcp_len = pack_nodes(chat->log, data + packed_len, length - packed_len, &saved_peer->tcp_relay, 1); + + if (packed_tcp_len > 0) { + packed_len += packed_tcp_len; + } + } + + if (packed_len + ENC_PUBLIC_KEY_SIZE > length) { + return -1; + } + + if (packed_tcp_len > 0 || packed_ipp_len > 0) { + memcpy(data + packed_len, chat->saved_peers[i].public_key, ENC_PUBLIC_KEY_SIZE); + packed_len += ENC_PUBLIC_KEY_SIZE; + ++count; + } else { + LOGGER_WARNING(chat->log, "Failed to pack saved peer"); + } + } + + if (processed != nullptr) { + *processed = packed_len; + } + + return count; +} + +int unpack_gc_saved_peers(GC_Chat *chat, const uint8_t *data, uint16_t length) +{ + uint16_t count = 0; + uint16_t unpacked_len = 0; + + for (size_t i = 0; unpacked_len < length; ++i) { + GC_SavedPeerInfo *saved_peer = &chat->saved_peers[i]; + + const int ipp_len = unpack_ip_port(&saved_peer->ip_port, data + unpacked_len, length - unpacked_len, false); + + if (ipp_len > 0) { + unpacked_len += ipp_len; + } + + if (unpacked_len > length) { + return -1; + } + + uint16_t tcp_len_processed = 0; + const int tcp_len = unpack_nodes(&saved_peer->tcp_relay, 1, &tcp_len_processed, data + unpacked_len, + length - unpacked_len, true); + + if (tcp_len == 1 && tcp_len_processed > 0) { + unpacked_len += tcp_len_processed; + } else if (ipp_len <= 0) { + LOGGER_WARNING(chat->log, "Failed to unpack saved peer: Invalid connection info."); + return -1; + } + + if (unpacked_len + ENC_PUBLIC_KEY_SIZE > length) { + return -1; + } + + if (tcp_len > 0 || ipp_len > 0) { + memcpy(saved_peer->public_key, data + unpacked_len, ENC_PUBLIC_KEY_SIZE); + unpacked_len += ENC_PUBLIC_KEY_SIZE; + ++count; + } else { + LOGGER_ERROR(chat->log, "Unpacked peer with bad connection info"); + return -1; + } + } + + return count; +} + +/** Returns true if chat privacy state is set to public. */ +non_null() +static bool is_public_chat(const GC_Chat *chat) +{ + return chat->shared_state.privacy_state == GI_PUBLIC; +} + +/** Returns true if group is password protected */ +non_null() +static bool chat_is_password_protected(const GC_Chat *chat) +{ + return chat->shared_state.password_length > 0; +} + +/** Returns true if `password` matches the current group password. */ +non_null() +static bool validate_password(const GC_Chat *chat, const uint8_t *password, uint16_t length) +{ + if (length > MAX_GC_PASSWORD_SIZE) { + return false; + } + + if (length != chat->shared_state.password_length) { + return false; + } + + return memcmp(chat->shared_state.password, password, length) == 0; +} + +/** @brief Returns the chat object that contains a peer with a public key equal to `id`. + * + * `id` must be at least ENC_PUBLIC_KEY_SIZE bytes in length. + */ +non_null() +static GC_Chat *get_chat_by_id(const GC_Session *c, const uint8_t *id) +{ + if (c == nullptr) { + return nullptr; + } + + for (uint32_t i = 0; i < c->chats_index; ++i) { + GC_Chat *chat = &c->chats[i]; + + if (chat->connection_state == CS_NONE) { + continue; + } + + if (memcmp(id, chat->self_public_key, ENC_PUBLIC_KEY_SIZE) == 0) { + return chat; + } + + if (get_peer_number_of_enc_pk(chat, id, false) != -1) { + return chat; + } + } + + return nullptr; +} + +/** @brief Returns the jenkins hash of a 32 byte public encryption key. */ +uint32_t gc_get_pk_jenkins_hash(const uint8_t *public_key) +{ + return jenkins_one_at_a_time_hash(public_key, ENC_PUBLIC_KEY_SIZE); +} + +/** @brief Sets the sum of the public_key_hash of all confirmed peers. + * + * Must be called every time a peer is confirmed or deleted. + */ +non_null() +static void set_gc_peerlist_checksum(GC_Chat *chat) +{ + uint16_t sum = 0; + + for (uint32_t i = 0; i < chat->numpeers; ++i) { + const GC_Connection *gconn = get_gc_connection(chat, i); + + assert(gconn != nullptr); + + if (gconn->confirmed) { + sum += gconn->public_key_hash; + } + } + + chat->peers_checksum = sum; +} + +/** Returns a checksum of the topic currently set in `topic_info`. */ +non_null() +static uint16_t get_gc_topic_checksum(const GC_TopicInfo *topic_info) +{ + return data_checksum(topic_info->topic, topic_info->length); +} + +int get_peer_number_of_enc_pk(const GC_Chat *chat, const uint8_t *public_enc_key, bool confirmed) +{ + for (uint32_t i = 0; i < chat->numpeers; ++i) { + const GC_Connection *gconn = get_gc_connection(chat, i); + + assert(gconn != nullptr); + + if (gconn->pending_delete) { + continue; + } + + if (confirmed && !gconn->confirmed) { + continue; + } + + if (memcmp(gconn->addr.public_key, public_enc_key, ENC_PUBLIC_KEY_SIZE) == 0) { + return i; + } + } + + return -1; +} + +/** @brief Check if peer associated with `public_sig_key` is in peer list. + * + * Returns the peer number if peer is in the peer list. + * Returns -1 if peer is not in the peer list. + */ +non_null() +static int get_peer_number_of_sig_pk(const GC_Chat *chat, const uint8_t *public_sig_key) +{ + for (uint32_t i = 0; i < chat->numpeers; ++i) { + const GC_Connection *gconn = get_gc_connection(chat, i); + + assert(gconn != nullptr); + + if (memcmp(get_sig_pk(gconn->addr.public_key), public_sig_key, SIG_PUBLIC_KEY_SIZE) == 0) { + return i; + } + } + + return -1; +} + +non_null() +static bool gc_get_enc_pk_from_sig_pk(const GC_Chat *chat, uint8_t *public_key, const uint8_t *public_sig_key) +{ + for (uint32_t i = 0; i < chat->numpeers; ++i) { + const GC_Connection *gconn = get_gc_connection(chat, i); + + assert(gconn != nullptr); + + const uint8_t *full_pk = gconn->addr.public_key; + + if (memcmp(public_sig_key, get_sig_pk(full_pk), SIG_PUBLIC_KEY_SIZE) == 0) { + memcpy(public_key, get_enc_key(full_pk), ENC_PUBLIC_KEY_SIZE); + return true; + } + } + + return false; +} + +non_null() +static GC_Connection *random_gc_connection(const GC_Chat *chat) +{ + if (chat->numpeers <= 1) { + return nullptr; + } + + const uint32_t base = random_range_u32(chat->rng, chat->numpeers - 1); + + for (uint32_t i = 0; i < chat->numpeers - 1; ++i) { + const uint32_t index = 1 + (base + i) % (chat->numpeers - 1); + GC_Connection *rand_gconn = get_gc_connection(chat, index); + + if (rand_gconn == nullptr) { + return nullptr; + } + + if (!rand_gconn->pending_delete && rand_gconn->confirmed) { + return rand_gconn; + } + } + + return nullptr; +} + +/** @brief Returns the peer number associated with peer_id. + * Returns -1 if peer_id is invalid. + */ +non_null() +static int get_peer_number_of_peer_id(const GC_Chat *chat, uint32_t peer_id) +{ + for (uint32_t i = 0; i < chat->numpeers; ++i) { + if (chat->group[i].peer_id == peer_id) { + return i; + } + } + + return -1; +} + +/** @brief Returns a unique peer ID. + * Returns UINT32_MAX if all possible peer ID's are taken. + * + * These ID's are permanently assigned to a peer when they join the group and should be + * considered arbitrary values. + */ +non_null() +static uint32_t get_new_peer_id(const GC_Chat *chat) +{ + for (uint32_t i = 0; i < UINT32_MAX - 1; ++i) { + if (get_peer_number_of_peer_id(chat, i) == -1) { + return i; + } + } + + return UINT32_MAX; +} + +/** @brief Sets the password for the group (locally only). + * + * Return true on success. + */ +non_null(1) nullable(2) +static bool set_gc_password_local(GC_Chat *chat, const uint8_t *passwd, uint16_t length) +{ + if (length > MAX_GC_PASSWORD_SIZE) { + return false; + } + + if (passwd == nullptr || length == 0) { + chat->shared_state.password_length = 0; + memset(chat->shared_state.password, 0, MAX_GC_PASSWORD_SIZE); + } else { + chat->shared_state.password_length = length; + crypto_memlock(chat->shared_state.password, sizeof(chat->shared_state.password)); + memcpy(chat->shared_state.password, passwd, length); + } + + return true; +} + +/** @brief Sets the local shared state to `version`. + * + * This should always be called instead of setting the variables manually. + */ +non_null() +static void set_gc_shared_state_version(GC_Chat *chat, uint32_t version) +{ + chat->shared_state.version = version; + chat->moderation.shared_state_version = version; +} + +/** @brief Expands the chat_id into the extended chat public key (encryption key + signature key). + * + * @param dest must have room for EXT_PUBLIC_KEY_SIZE bytes. + * + * Return true on success. + */ +non_null() +static bool expand_chat_id(uint8_t *dest, const uint8_t *chat_id) +{ + assert(dest != nullptr); + + const int ret = crypto_sign_ed25519_pk_to_curve25519(dest, chat_id); + memcpy(dest + ENC_PUBLIC_KEY_SIZE, chat_id, SIG_PUBLIC_KEY_SIZE); + + return ret != -1; +} + +/** Copies peer connect info from `gconn` to `addr`. */ +non_null() +static void copy_gc_saved_peer(const Random *rng, const GC_Connection *gconn, GC_SavedPeerInfo *addr) +{ + if (!gcc_copy_tcp_relay(rng, &addr->tcp_relay, gconn)) { + addr->tcp_relay = (Node_format) { + 0 + }; + } + + addr->ip_port = gconn->addr.ip_port; + memcpy(addr->public_key, gconn->addr.public_key, ENC_PUBLIC_KEY_SIZE); +} + +/** Return true if `saved_peer` has either a valid IP_Port or a valid TCP relay. */ +non_null() +static bool saved_peer_is_valid(const GC_SavedPeerInfo *saved_peer) +{ + return ipport_isset(&saved_peer->ip_port) || ipport_isset(&saved_peer->tcp_relay.ip_port); +} + +/** @brief Returns the index of the saved peers entry for `public_key`. + * Returns -1 if key is not found. + */ +non_null() +static int saved_peer_index(const GC_Chat *chat, const uint8_t *public_key) +{ + for (uint16_t i = 0; i < GC_MAX_SAVED_PEERS; ++i) { + const GC_SavedPeerInfo *saved_peer = &chat->saved_peers[i]; + + if (memcmp(saved_peer->public_key, public_key, ENC_PUBLIC_KEY_SIZE) == 0) { + return i; + } + } + + return -1; +} + +/** @brief Returns the index of the first vacant entry in saved peers list. + * + * If `public_key` is non-null and already exists in the list, its index will be returned. + * + * A vacant entry is an entry that does not have either an IP_port or tcp relay set (invalid), + * or an entry containing info on a peer that is not presently online (offline). + * + * Invalid entries are given priority over offline entries. + * + * Returns -1 if there are no vacant indices. + */ +non_null(1) nullable(2) +static int saved_peers_get_new_index(const GC_Chat *chat, const uint8_t *public_key) +{ + if (public_key != nullptr) { + const int idx = saved_peer_index(chat, public_key); + + if (idx != -1) { + return idx; + } + } + + // first check for invalid spots + for (uint16_t i = 0; i < GC_MAX_SAVED_PEERS; ++i) { + const GC_SavedPeerInfo *saved_peer = &chat->saved_peers[i]; + + if (!saved_peer_is_valid(saved_peer)) { + return i; + } + } + + // now look for entries with offline peers + for (uint16_t i = 0; i < GC_MAX_SAVED_PEERS; ++i) { + const GC_SavedPeerInfo *saved_peer = &chat->saved_peers[i]; + + const int peernumber = get_peer_number_of_enc_pk(chat, saved_peer->public_key, true); + + if (peernumber < 0) { + return i; + } + } + + return -1; +} + +/** @brief Attempts to add `gconn` to the saved peer list. + * + * If an entry already exists it will be updated. + * + * Older peers will only be overwritten if the peer is no longer + * present in the chat. This gives priority to more stable connections. + * + * This function should be called every time a new peer joins the group. + */ +non_null() +static void add_gc_saved_peers(GC_Chat *chat, const GC_Connection *gconn) +{ + const int idx = saved_peers_get_new_index(chat, gconn->addr.public_key); + + if (idx == -1) { + return; + } + + GC_SavedPeerInfo *saved_peer = &chat->saved_peers[idx]; + copy_gc_saved_peer(chat->rng, gconn, saved_peer); +} + +/** @brief Finds the first vacant spot in the saved peers list and fills it with a present + * peer who isn't already in the list. + * + * This function should be called after a confirmed peer exits the group. + */ +non_null() +static void refresh_gc_saved_peers(GC_Chat *chat) +{ + const int idx = saved_peers_get_new_index(chat, nullptr); + + if (idx == -1) { + return; + } + + for (uint32_t i = 1; i < chat->numpeers; ++i) { + const GC_Connection *gconn = get_gc_connection(chat, i); + + if (gconn == nullptr) { + continue; + } + + if (!gconn->confirmed) { + continue; + } + + if (saved_peer_index(chat, gconn->addr.public_key) == -1) { + GC_SavedPeerInfo *saved_peer = &chat->saved_peers[idx]; + copy_gc_saved_peer(chat->rng, gconn, saved_peer); + return; + } + } +} + +/** Returns the number of confirmed peers in peerlist. */ +non_null() +static uint16_t get_gc_confirmed_numpeers(const GC_Chat *chat) +{ + uint16_t count = 0; + + for (uint32_t i = 0; i < chat->numpeers; ++i) { + const GC_Connection *gconn = get_gc_connection(chat, i); + + assert(gconn != nullptr); + + if (gconn->confirmed) { + ++count; + } + } + + return count; +} + +non_null() static bool sign_gc_shared_state(GC_Chat *chat); +non_null() static bool broadcast_gc_mod_list(const GC_Chat *chat); +non_null() static bool broadcast_gc_shared_state(const GC_Chat *chat); +non_null() static bool update_gc_sanctions_list(GC_Chat *chat, const uint8_t *public_sig_key); +non_null() static bool update_gc_topic(GC_Chat *chat, const uint8_t *public_sig_key); +non_null() static bool send_gc_set_observer(const GC_Chat *chat, const uint8_t *target_ext_pk, + const uint8_t *sanction_data, uint16_t length, bool add_obs); + +/** Returns true if peer designated by `peer_number` is in the sanctions list as an observer. */ +non_null() +static bool peer_is_observer(const GC_Chat *chat, uint32_t peer_number) +{ + const GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return false; + } + + return sanctions_list_is_observer(&chat->moderation, get_enc_key(gconn->addr.public_key)); +} + +/** Returns true if peer designated by `peer_number` is the group founder. */ +non_null() +static bool peer_is_founder(const GC_Chat *chat, uint32_t peer_number) +{ + + const GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return false; + } + + return memcmp(chat->shared_state.founder_public_key, gconn->addr.public_key, ENC_PUBLIC_KEY_SIZE) == 0; +} + +/** Returns true if peer designated by `peer_number` is in the moderator list or is the founder. */ +non_null() +static bool peer_is_moderator(const GC_Chat *chat, uint32_t peer_number) +{ + const GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return false; + } + + if (peer_is_founder(chat, peer_number)) { + return false; + } + + return mod_list_verify_sig_pk(&chat->moderation, get_sig_pk(gconn->addr.public_key)); +} + +/** @brief Iterates through the peerlist and updates group roles according to the + * current group state. + * + * Also updates the roles checksum. If any role conflicts exist the shared state + * version is set to zero in order to force a sync update. + * + * This should be called every time the moderator list or sanctions list changes, + * and after a new peer is marked as confirmed. + */ +non_null() +static void update_gc_peer_roles(GC_Chat *chat) +{ + chat->roles_checksum = 0; + bool conflicts = false; + + for (uint32_t i = 0; i < chat->numpeers; ++i) { + const GC_Connection *gconn = get_gc_connection(chat, i); + + if (gconn == nullptr) { + continue; + } + + if (!gconn->confirmed) { + continue; + } + + const uint8_t first_byte = gconn->addr.public_key[0]; + const bool is_founder = peer_is_founder(chat, i); + + if (is_founder) { + chat->group[i].role = GR_FOUNDER; + chat->roles_checksum += GR_FOUNDER + first_byte; + continue; + } + + const bool is_observer = peer_is_observer(chat, i); + const bool is_moderator = peer_is_moderator(chat, i); + const bool is_user = !(is_founder || is_moderator || is_observer); + + if (is_observer && is_moderator) { + conflicts = true; + } + + if (is_user) { + chat->group[i].role = GR_USER; + chat->roles_checksum += GR_USER + first_byte; + continue; + } + + if (is_moderator) { + chat->group[i].role = GR_MODERATOR; + chat->roles_checksum += GR_MODERATOR + first_byte; + continue; + } + + if (is_observer) { + chat->group[i].role = GR_OBSERVER; + chat->roles_checksum += GR_OBSERVER + first_byte; + continue; + } + } + + if (conflicts && !self_gc_is_founder(chat)) { + set_gc_shared_state_version(chat, 0); // need a new shared state + } +} + +/** @brief Removes the first found offline mod from the mod list. + * + * Broadcasts the shared state and moderator list on success, as well as the updated + * sanctions list if necessary. + * + * TODO(Jfreegman): Make this smarter in who to remove (e.g. the mod who hasn't been seen online in the longest time) + * + * Returns false on failure. + */ +non_null() +static bool prune_gc_mod_list(GC_Chat *chat) +{ + if (chat->moderation.num_mods == 0) { + return true; + } + + uint8_t public_sig_key[SIG_PUBLIC_KEY_SIZE]; + bool pruned_mod = false; + + for (uint16_t i = 0; i < chat->moderation.num_mods; ++i) { + if (get_peer_number_of_sig_pk(chat, chat->moderation.mod_list[i]) == -1) { + memcpy(public_sig_key, chat->moderation.mod_list[i], SIG_PUBLIC_KEY_SIZE); + + if (!mod_list_remove_index(&chat->moderation, i)) { + continue; + } + + pruned_mod = true; + break; + } + } + + return pruned_mod + && mod_list_make_hash(&chat->moderation, chat->shared_state.mod_list_hash) + && sign_gc_shared_state(chat) + && broadcast_gc_shared_state(chat) + && broadcast_gc_mod_list(chat) + && update_gc_sanctions_list(chat, public_sig_key) + && update_gc_topic(chat, public_sig_key); +} + +/** @brief Removes the first found offline sanctioned peer from the sanctions list and sends the + * event to the rest of the group. + * + * @retval false on failure or if no presently sanctioned peer is offline. + */ +non_null() +static bool prune_gc_sanctions_list(GC_Chat *chat) +{ + if (chat->moderation.num_sanctions == 0) { + return true; + } + + const Mod_Sanction *sanction = nullptr; + uint8_t target_ext_pk[ENC_PUBLIC_KEY_SIZE + SIG_PUBLIC_KEY_SIZE]; + + for (uint16_t i = 0; i < chat->moderation.num_sanctions; ++i) { + const int peer_number = get_peer_number_of_enc_pk(chat, chat->moderation.sanctions[i].target_public_enc_key, true); + + if (peer_number == -1) { + sanction = &chat->moderation.sanctions[i]; + memcpy(target_ext_pk, sanction->target_public_enc_key, ENC_PUBLIC_KEY_SIZE); + memcpy(target_ext_pk + ENC_PUBLIC_KEY_SIZE, sanction->setter_public_sig_key, SIG_PUBLIC_KEY_SIZE); + break; + } + } + + if (sanction == nullptr) { + return false; + } + + if (!sanctions_list_remove_observer(&chat->moderation, sanction->target_public_enc_key, nullptr)) { + LOGGER_WARNING(chat->log, "Failed to remove entry from observer list"); + return false; + } + + sanction = nullptr; + + uint8_t data[MOD_SANCTIONS_CREDS_SIZE]; + const uint16_t length = sanctions_creds_pack(&chat->moderation.sanctions_creds, data); + + if (length != MOD_SANCTIONS_CREDS_SIZE) { + LOGGER_ERROR(chat->log, "Failed to pack credentials (invalid length: %u)", length); + return false; + } + + if (!send_gc_set_observer(chat, target_ext_pk, data, length, false)) { + LOGGER_WARNING(chat->log, "Failed to broadcast set observer"); + return false; + } + + return true; +} + +/** @brief Size of peer data that we pack for transfer (nick length must be accounted for separately). + * packed data consists of: nick length, nick, and status. + */ +#define PACKED_GC_PEER_SIZE (sizeof(uint16_t) + MAX_GC_NICK_SIZE + sizeof(uint8_t)) + +/** @brief Packs peer info into data of maxlength length. + * + * Return length of packed peer on success. + * Return -1 on failure. + */ +non_null() +static int pack_gc_peer(uint8_t *data, uint16_t length, const GC_Peer *peer) +{ + if (PACKED_GC_PEER_SIZE > length) { + return -1; + } + + uint32_t packed_len = 0; + + net_pack_u16(data + packed_len, peer->nick_length); + packed_len += sizeof(uint16_t); + memcpy(data + packed_len, peer->nick, MAX_GC_NICK_SIZE); + packed_len += MAX_GC_NICK_SIZE; + memcpy(data + packed_len, &peer->status, sizeof(uint8_t)); + packed_len += sizeof(uint8_t); + + return packed_len; +} + +/** @brief Unpacks peer info of size length into peer. + * + * Returns the length of processed data on success. + * Returns -1 on failure. + */ +non_null() +static int unpack_gc_peer(GC_Peer *peer, const uint8_t *data, uint16_t length) +{ + if (PACKED_GC_PEER_SIZE > length) { + return -1; + } + + uint16_t len_processed = 0; + + net_unpack_u16(data + len_processed, &peer->nick_length); + len_processed += sizeof(uint16_t); + peer->nick_length = min_u16(MAX_GC_NICK_SIZE, peer->nick_length); + memcpy(peer->nick, data + len_processed, MAX_GC_NICK_SIZE); + len_processed += MAX_GC_NICK_SIZE; + memcpy(&peer->status, data + len_processed, sizeof(uint8_t)); + len_processed += sizeof(uint8_t); + + return len_processed; +} + +/** @brief Packs shared_state into data. + * + * @param data must have room for at least GC_PACKED_SHARED_STATE_SIZE bytes. + * + * Returns packed data length. + */ +non_null() +static uint16_t pack_gc_shared_state(uint8_t *data, uint16_t length, const GC_SharedState *shared_state) +{ + if (length < GC_PACKED_SHARED_STATE_SIZE) { + return 0; + } + + const uint8_t privacy_state = shared_state->privacy_state; + const uint8_t voice_state = shared_state->voice_state; + + uint16_t packed_len = 0; + + // version is always first + net_pack_u32(data + packed_len, shared_state->version); + packed_len += sizeof(uint32_t); + + memcpy(data + packed_len, shared_state->founder_public_key, EXT_PUBLIC_KEY_SIZE); + packed_len += EXT_PUBLIC_KEY_SIZE; + net_pack_u16(data + packed_len, shared_state->maxpeers); + packed_len += sizeof(uint16_t); + net_pack_u16(data + packed_len, shared_state->group_name_len); + packed_len += sizeof(uint16_t); + memcpy(data + packed_len, shared_state->group_name, MAX_GC_GROUP_NAME_SIZE); + packed_len += MAX_GC_GROUP_NAME_SIZE; + memcpy(data + packed_len, &privacy_state, sizeof(uint8_t)); + packed_len += sizeof(uint8_t); + net_pack_u16(data + packed_len, shared_state->password_length); + packed_len += sizeof(uint16_t); + memcpy(data + packed_len, shared_state->password, MAX_GC_PASSWORD_SIZE); + packed_len += MAX_GC_PASSWORD_SIZE; + memcpy(data + packed_len, shared_state->mod_list_hash, MOD_MODERATION_HASH_SIZE); + packed_len += MOD_MODERATION_HASH_SIZE; + net_pack_u32(data + packed_len, shared_state->topic_lock); + packed_len += sizeof(uint32_t); + memcpy(data + packed_len, &voice_state, sizeof(uint8_t)); + packed_len += sizeof(uint8_t); + + return packed_len; +} + +/** @brief Unpacks shared state data into shared_state. + * + * @param data must contain at least GC_PACKED_SHARED_STATE_SIZE bytes. + * + * Returns the length of processed data. + */ +non_null() +static uint16_t unpack_gc_shared_state(GC_SharedState *shared_state, const uint8_t *data, uint16_t length) +{ + if (length < GC_PACKED_SHARED_STATE_SIZE) { + return 0; + } + + uint16_t len_processed = 0; + + // version is always first + net_unpack_u32(data + len_processed, &shared_state->version); + len_processed += sizeof(uint32_t); + + memcpy(shared_state->founder_public_key, data + len_processed, EXT_PUBLIC_KEY_SIZE); + len_processed += EXT_PUBLIC_KEY_SIZE; + net_unpack_u16(data + len_processed, &shared_state->maxpeers); + len_processed += sizeof(uint16_t); + net_unpack_u16(data + len_processed, &shared_state->group_name_len); + shared_state->group_name_len = min_u16(shared_state->group_name_len, MAX_GC_GROUP_NAME_SIZE); + len_processed += sizeof(uint16_t); + memcpy(shared_state->group_name, data + len_processed, MAX_GC_GROUP_NAME_SIZE); + len_processed += MAX_GC_GROUP_NAME_SIZE; + + uint8_t privacy_state; + memcpy(&privacy_state, data + len_processed, sizeof(uint8_t)); + len_processed += sizeof(uint8_t); + + net_unpack_u16(data + len_processed, &shared_state->password_length); + len_processed += sizeof(uint16_t); + memcpy(shared_state->password, data + len_processed, MAX_GC_PASSWORD_SIZE); + len_processed += MAX_GC_PASSWORD_SIZE; + memcpy(shared_state->mod_list_hash, data + len_processed, MOD_MODERATION_HASH_SIZE); + len_processed += MOD_MODERATION_HASH_SIZE; + net_unpack_u32(data + len_processed, &shared_state->topic_lock); + len_processed += sizeof(uint32_t); + + uint8_t voice_state; + memcpy(&voice_state, data + len_processed, sizeof(uint8_t)); + len_processed += sizeof(uint8_t); + + shared_state->voice_state = (Group_Voice_State)voice_state; + shared_state->privacy_state = (Group_Privacy_State)privacy_state; + + return len_processed; +} + +/** @brief Packs topic info into data. + * + * @param data must have room for at least topic length + GC_MIN_PACKED_TOPIC_INFO_SIZE bytes. + * + * Returns packed data length. + */ +non_null() +static uint16_t pack_gc_topic_info(uint8_t *data, uint16_t length, const GC_TopicInfo *topic_info) +{ + if (length < topic_info->length + GC_MIN_PACKED_TOPIC_INFO_SIZE) { + return 0; + } + + uint16_t packed_len = 0; + + net_pack_u32(data + packed_len, topic_info->version); + packed_len += sizeof(uint32_t); + net_pack_u16(data + packed_len, topic_info->checksum); + packed_len += sizeof(uint16_t); + net_pack_u16(data + packed_len, topic_info->length); + packed_len += sizeof(uint16_t); + memcpy(data + packed_len, topic_info->topic, topic_info->length); + packed_len += topic_info->length; + memcpy(data + packed_len, topic_info->public_sig_key, SIG_PUBLIC_KEY_SIZE); + packed_len += SIG_PUBLIC_KEY_SIZE; + + return packed_len; +} + +/** @brief Unpacks topic info into `topic_info`. + * + * Returns -1 on failure. + * Returns the length of the processed data on success. + */ +non_null() +static int unpack_gc_topic_info(GC_TopicInfo *topic_info, const uint8_t *data, uint16_t length) +{ + if (length < sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint32_t)) { + return -1; + } + + uint16_t len_processed = 0; + + net_unpack_u32(data + len_processed, &topic_info->version); + len_processed += sizeof(uint32_t); + net_unpack_u16(data + len_processed, &topic_info->checksum); + len_processed += sizeof(uint16_t); + net_unpack_u16(data + len_processed, &topic_info->length); + len_processed += sizeof(uint16_t); + + if (topic_info->length > MAX_GC_TOPIC_SIZE) { + topic_info->length = MAX_GC_TOPIC_SIZE; + } + + if (length - len_processed < topic_info->length + SIG_PUBLIC_KEY_SIZE) { + return -1; + } + + if (topic_info->length > 0) { + memcpy(topic_info->topic, data + len_processed, topic_info->length); + len_processed += topic_info->length; + } + + memcpy(topic_info->public_sig_key, data + len_processed, SIG_PUBLIC_KEY_SIZE); + len_processed += SIG_PUBLIC_KEY_SIZE; + + return len_processed; +} + +/** @brief Creates a shared state packet and puts it in data. + * Packet includes self pk hash, shared state signature, and packed shared state info. + * data must have room for at least GC_SHARED_STATE_ENC_PACKET_SIZE bytes. + * + * Returns packet length on success. + * Returns -1 on failure. + */ +non_null() +static int make_gc_shared_state_packet(const GC_Chat *chat, uint8_t *data, uint16_t length) +{ + if (length < GC_SHARED_STATE_ENC_PACKET_SIZE) { + return -1; + } + + memcpy(data, chat->shared_state_sig, SIGNATURE_SIZE); + const uint16_t header_len = SIGNATURE_SIZE; + + const uint16_t packed_len = pack_gc_shared_state(data + header_len, length - header_len, &chat->shared_state); + + if (packed_len != GC_PACKED_SHARED_STATE_SIZE) { + return -1; + } + + return (int)(header_len + packed_len); +} + +/** @brief Creates a signature for the group's shared state in packed form. + * + * This function only works for the Founder. + * + * Returns true on success and increments the shared state version. + */ +non_null() +static bool sign_gc_shared_state(GC_Chat *chat) +{ + if (!self_gc_is_founder(chat)) { + LOGGER_ERROR(chat->log, "Failed to sign shared state (invalid permission)"); + return false; + } + + if (chat->shared_state.version != UINT32_MAX) { + /* improbable, but an overflow would break everything */ + set_gc_shared_state_version(chat, chat->shared_state.version + 1); + } else { + LOGGER_WARNING(chat->log, "Shared state version wraparound"); + } + + uint8_t shared_state[GC_PACKED_SHARED_STATE_SIZE]; + const uint16_t packed_len = pack_gc_shared_state(shared_state, sizeof(shared_state), &chat->shared_state); + + if (packed_len != GC_PACKED_SHARED_STATE_SIZE) { + set_gc_shared_state_version(chat, chat->shared_state.version - 1); + LOGGER_ERROR(chat->log, "Failed to pack shared state"); + return false; + } + + const int ret = crypto_sign_detached(chat->shared_state_sig, nullptr, shared_state, packed_len, + get_sig_sk(chat->chat_secret_key)); + + if (ret != 0) { + set_gc_shared_state_version(chat, chat->shared_state.version - 1); + LOGGER_ERROR(chat->log, "Failed to sign shared state (%d)", ret); + return false; + } + + return true; +} + +/** @brief Decrypts data using the shared key associated with `gconn`. + * + * The packet payload should begin with a nonce. + * + * @param message_id should be set to NULL for lossy packets. + * + * Returns length of the plaintext data on success. + * Return -1 if encrypted payload length is invalid. + * Return -2 on decryption failure. + * Return -3 if plaintext payload length is invalid. + */ +non_null(1, 2, 3, 5, 6) nullable(4) +static int group_packet_unwrap(const Logger *log, const GC_Connection *gconn, uint8_t *data, uint64_t *message_id, + uint8_t *packet_type, const uint8_t *packet, uint16_t length) +{ + if (length <= CRYPTO_NONCE_SIZE) { + LOGGER_FATAL(log, "Invalid packet length: %u", length); + return -1; + } + + uint8_t *plain = (uint8_t *)malloc(length); + + if (plain == nullptr) { + LOGGER_ERROR(log, "Failed to allocate memory for plain data buffer"); + return -1; + } + + int plain_len = decrypt_data_symmetric(gconn->session_shared_key, packet, packet + CRYPTO_NONCE_SIZE, + length - CRYPTO_NONCE_SIZE, plain); + + if (plain_len <= 0) { + free(plain); + return plain_len == 0 ? -3 : -2; + } + + const int min_plain_len = message_id != nullptr ? 1 + GC_MESSAGE_ID_BYTES : 1; + + /* remove padding */ + const uint8_t *real_plain = plain; + + while (real_plain[0] == 0) { + ++real_plain; + --plain_len; + + if (plain_len < min_plain_len) { + free(plain); + return -3; + } + } + + uint32_t header_len = sizeof(uint8_t); + *packet_type = real_plain[0]; + plain_len -= sizeof(uint8_t); + + if (message_id != nullptr) { + net_unpack_u64(real_plain + sizeof(uint8_t), message_id); + plain_len -= GC_MESSAGE_ID_BYTES; + header_len += GC_MESSAGE_ID_BYTES; + } + + memcpy(data, real_plain + header_len, plain_len); + + free(plain); + + return plain_len; +} + +int group_packet_wrap( + const Logger *log, const Random *rng, const uint8_t *self_pk, const uint8_t *shared_key, uint8_t *packet, + uint16_t packet_size, const uint8_t *data, uint16_t length, uint64_t message_id, + uint8_t gp_packet_type, uint8_t net_packet_type) +{ + const uint16_t padding_len = group_packet_padding_length(length); + const uint16_t min_packet_size = net_packet_type == NET_PACKET_GC_LOSSLESS + ? length + padding_len + CRYPTO_MAC_SIZE + 1 + ENC_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + GC_MESSAGE_ID_BYTES + 1 + : length + padding_len + CRYPTO_MAC_SIZE + 1 + ENC_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + 1; + + if (min_packet_size > packet_size) { + LOGGER_ERROR(log, "Invalid packet buffer size: %u", packet_size); + return -1; + } + + if (length > MAX_GC_PACKET_CHUNK_SIZE) { + LOGGER_ERROR(log, "Packet payload size (%u) exceeds maximum (%u)", length, MAX_GC_PACKET_CHUNK_SIZE); + return -1; + } + + uint8_t *plain = (uint8_t *)malloc(packet_size); + + if (plain == nullptr) { + return -1; + } + + assert(padding_len < packet_size); + + memset(plain, 0, padding_len); + + uint16_t enc_header_len = sizeof(uint8_t); + plain[padding_len] = gp_packet_type; + + if (net_packet_type == NET_PACKET_GC_LOSSLESS) { + net_pack_u64(plain + padding_len + sizeof(uint8_t), message_id); + enc_header_len += GC_MESSAGE_ID_BYTES; + } + + if (length > 0 && data != nullptr) { + memcpy(plain + padding_len + enc_header_len, data, length); + } + + uint8_t nonce[CRYPTO_NONCE_SIZE]; + random_nonce(rng, nonce); + + const uint16_t plain_len = padding_len + enc_header_len + length; + const uint16_t encrypt_buf_size = plain_len + CRYPTO_MAC_SIZE; + + uint8_t *encrypt = (uint8_t *)malloc(encrypt_buf_size); + + if (encrypt == nullptr) { + free(plain); + return -2; + } + + const int enc_len = encrypt_data_symmetric(shared_key, nonce, plain, plain_len, encrypt); + + free(plain); + + if (enc_len != encrypt_buf_size) { + LOGGER_ERROR(log, "encryption failed. packet type: 0x%02x, enc_len: %d", gp_packet_type, enc_len); + free(encrypt); + return -3; + } + + packet[0] = net_packet_type; + memcpy(packet + 1, self_pk, ENC_PUBLIC_KEY_SIZE); + memcpy(packet + 1 + ENC_PUBLIC_KEY_SIZE, nonce, CRYPTO_NONCE_SIZE); + memcpy(packet + 1 + ENC_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE, encrypt, enc_len); + + free(encrypt); + + return 1 + ENC_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + enc_len; +} + +/** @brief Sends a lossy packet to peer_number in chat instance. + * + * Returns true on success. + */ +non_null() +static bool send_lossy_group_packet(const GC_Chat *chat, const GC_Connection *gconn, const uint8_t *data, + uint16_t length, uint8_t packet_type) +{ + assert(length <= MAX_GC_PACKET_CHUNK_SIZE); + + if (!gconn->handshaked || gconn->pending_delete) { + return false; + } + + if (data == nullptr || length == 0) { + return false; + } + + const uint16_t packet_size = gc_get_wrapped_packet_size(length, NET_PACKET_GC_LOSSY); + uint8_t *packet = (uint8_t *)malloc(packet_size); + + if (packet == nullptr) { + return false; + } + + const int len = group_packet_wrap( + chat->log, chat->rng, chat->self_public_key, gconn->session_shared_key, packet, + packet_size, data, length, 0, packet_type, NET_PACKET_GC_LOSSY); + + if (len < 0) { + LOGGER_ERROR(chat->log, "Failed to encrypt packet (type: 0x%02x, error: %d)", packet_type, len); + free(packet); + return false; + } + + const bool ret = gcc_send_packet(chat, gconn, packet, (uint16_t)len); + + free(packet); + + return ret; +} + +/** @brief Sends a lossless packet to peer_number in chat instance. + * + * Returns true on success. + */ +non_null(1, 2) nullable(3) +static bool send_lossless_group_packet(const GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, uint16_t length, + uint8_t packet_type) +{ + assert(length <= MAX_GC_PACKET_SIZE); + + if (!gconn->handshaked || gconn->pending_delete) { + return false; + } + + if (length > MAX_GC_PACKET_CHUNK_SIZE) { + return gcc_send_lossless_packet_fragments(chat, gconn, data, length, packet_type); + } + + return gcc_send_lossless_packet(chat, gconn, data, length, packet_type) == 0; +} + +/** @brief Sends a group sync request to peer. + * + * Returns true on success or if sync request timeout has not expired. + */ +non_null() +static bool send_gc_sync_request(GC_Chat *chat, GC_Connection *gconn, uint16_t sync_flags) +{ + if (!mono_time_is_timeout(chat->mono_time, chat->last_sync_request, GC_SYNC_REQUEST_LIMIT)) { + return true; + } + + chat->last_sync_request = mono_time_get(chat->mono_time); + + uint8_t data[(sizeof(uint16_t) * 2) + MAX_GC_PASSWORD_SIZE]; + uint16_t length = sizeof(uint16_t); + + net_pack_u16(data, sync_flags); + + if (chat_is_password_protected(chat)) { + net_pack_u16(data + length, chat->shared_state.password_length); + length += sizeof(uint16_t); + + memcpy(data + length, chat->shared_state.password, MAX_GC_PASSWORD_SIZE); + length += MAX_GC_PASSWORD_SIZE; + } + + return send_lossless_group_packet(chat, gconn, data, length, GP_SYNC_REQUEST); +} + +/** @brief Sends a sync response packet to peer designated by `gconn`. + * + * Return true on success. + */ +non_null(1, 2) nullable(3) +static bool send_gc_sync_response(const GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, uint16_t length) +{ + return send_lossless_group_packet(chat, gconn, data, length, GP_SYNC_RESPONSE); +} + +non_null() static bool send_gc_peer_exchange(const GC_Chat *chat, GC_Connection *gconn); +non_null() static bool send_gc_handshake_packet(const GC_Chat *chat, GC_Connection *gconn, uint8_t handshake_type, + uint8_t request_type, uint8_t join_type); +non_null() static bool send_gc_oob_handshake_request(const GC_Chat *chat, const GC_Connection *gconn); + +/** @brief Unpacks a sync announce. + * + * If the announced peer is not already in our peer list, we attempt to + * initiate a peer info exchange with them. + * + * Return true on success (whether or not the peer was added). + */ +non_null() +static bool unpack_gc_sync_announce(GC_Chat *chat, const uint8_t *data, const uint16_t length) +{ + GC_Announce announce = {0}; + + const int unpacked_announces = gca_unpack_announces_list(chat->log, data, length, &announce, 1); + + if (unpacked_announces <= 0) { + LOGGER_WARNING(chat->log, "Failed to unpack announces: %d", unpacked_announces); + return false; + } + + if (memcmp(announce.peer_public_key, chat->self_public_key, ENC_PUBLIC_KEY_SIZE) == 0) { + LOGGER_WARNING(chat->log, "Attempted to unpack our own announce"); + return true; + } + + if (!gca_is_valid_announce(&announce)) { + LOGGER_WARNING(chat->log, "got invalid announce"); + return false; + } + + const IP_Port *ip_port = announce.ip_port_is_set ? &announce.ip_port : nullptr; + const int new_peer_number = peer_add(chat, ip_port, announce.peer_public_key); + + if (new_peer_number == -1) { + LOGGER_ERROR(chat->log, "peer_add() failed"); + return false; + } + + if (new_peer_number == -2) { // peer already added + return true; + } + + if (new_peer_number > 0) { + GC_Connection *new_gconn = get_gc_connection(chat, new_peer_number); + + if (new_gconn == nullptr) { + return false; + } + + uint32_t added_tcp_relays = 0; + + for (uint8_t i = 0; i < announce.tcp_relays_count; ++i) { + const int add_tcp_result = add_tcp_relay_connection(chat->tcp_conn, new_gconn->tcp_connection_num, + &announce.tcp_relays[i].ip_port, + announce.tcp_relays[i].public_key); + + if (add_tcp_result == -1) { + continue; + } + + if (gcc_save_tcp_relay(chat->rng, new_gconn, &announce.tcp_relays[i]) == 0) { + ++added_tcp_relays; + } + } + + if (!announce.ip_port_is_set && added_tcp_relays == 0) { + gcc_mark_for_deletion(new_gconn, chat->tcp_conn, GC_EXIT_TYPE_DISCONNECTED, nullptr, 0); + LOGGER_ERROR(chat->log, "Sync error: Invalid peer connection info"); + return false; + } + + new_gconn->pending_handshake_type = HS_PEER_INFO_EXCHANGE; + + return true; + } + + LOGGER_FATAL(chat->log, "got impossible return value %d", new_peer_number); + + return false; +} + +/** @brief Handles a sync response packet. + * + * Note: This function may change peer numbers. + * + * Return 0 on success. + * Return -1 if the group is full or the peer failed to unpack. + * Return -2 if `peer_number` does not designate a valid peer. + */ +non_null(1, 2, 4) nullable(6) +static int handle_gc_sync_response(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, const uint8_t *data, + uint16_t length, void *userdata) +{ + if (chat->connection_state == CS_CONNECTED && get_gc_confirmed_numpeers(chat) >= chat->shared_state.maxpeers + && !peer_is_founder(chat, peer_number)) { + return -1; + } + + if (length > 0) { + if (!unpack_gc_sync_announce(chat, data, length)) { + return -1; + } + } + + chat->connection_state = CS_CONNECTED; + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return -2; + } + + if (!send_gc_peer_exchange(chat, gconn)) { + LOGGER_WARNING(chat->log, "Failed to send peer exchange on sync response"); + } + + if (c->self_join != nullptr && chat->time_connected == 0) { + c->self_join(c->messenger, chat->group_number, userdata); + chat->time_connected = mono_time_get(chat->mono_time); + } + + return 0; +} + +non_null() static int get_gc_peer_public_key(const GC_Chat *chat, uint32_t peer_number, uint8_t *public_key); +non_null() static bool send_peer_shared_state(const GC_Chat *chat, GC_Connection *gconn); +non_null() static bool send_peer_mod_list(const GC_Chat *chat, GC_Connection *gconn); +non_null() static bool send_peer_sanctions_list(const GC_Chat *chat, GC_Connection *gconn); +non_null() static bool send_peer_topic(const GC_Chat *chat, GC_Connection *gconn); + + +/** @brief Creates a sync announce for peer designated by `gconn` and puts it in `announce`, which + * must be zeroed by the caller. + * + * Returns true if announce was successfully created. + */ +non_null() +static bool create_sync_announce(const GC_Chat *chat, const GC_Connection *gconn, uint32_t peer_number, + GC_Announce *announce) +{ + if (chat == nullptr || gconn == nullptr) { + return false; + } + + if (gconn->tcp_relays_count > 0) { + if (gcc_copy_tcp_relay(chat->rng, &announce->tcp_relays[0], gconn)) { + announce->tcp_relays_count = 1; + } + } + + get_gc_peer_public_key(chat, peer_number, announce->peer_public_key); + + if (gcc_ip_port_is_set(gconn)) { + announce->ip_port = gconn->addr.ip_port; + announce->ip_port_is_set = true; + } + + return true; +} + +non_null() +static bool sync_response_send_peers(GC_Chat *chat, GC_Connection *gconn, uint32_t peer_number, bool first_sync) +{ + // Always respond to a peer's first sync request + if (!first_sync && !mono_time_is_timeout(chat->mono_time, + chat->last_sync_response_peer_list, + GC_SYNC_RESPONSE_PEER_LIST_LIMIT)) { + return true; + } + + uint8_t *response = (uint8_t *)malloc(MAX_GC_PACKET_CHUNK_SIZE); + + if (response == nullptr) { + return false; + } + + size_t num_announces = 0; + + for (uint32_t i = 1; i < chat->numpeers; ++i) { + const GC_Connection *peer_gconn = get_gc_connection(chat, i); + + if (peer_gconn == nullptr || !peer_gconn->confirmed) { + continue; + } + + if (peer_gconn->public_key_hash == gconn->public_key_hash || i == peer_number) { + continue; + } + + GC_Announce announce = {0}; + + if (!create_sync_announce(chat, peer_gconn, i, &announce)) { + continue; + } + + const int packed_length = gca_pack_announce(chat->log, response, MAX_GC_PACKET_CHUNK_SIZE, &announce); + + if (packed_length <= 0) { + LOGGER_WARNING(chat->log, "Failed to pack announce: %d", packed_length); + continue; + } + + if (!send_gc_sync_response(chat, gconn, response, packed_length)) { + LOGGER_WARNING(chat->log, "Failed to send peer announce info"); + continue; + } + + ++num_announces; + } + + free(response); + + if (num_announces == 0) { + // we send an empty sync response even if we didn't send any peers as an acknowledgement + if (!send_gc_sync_response(chat, gconn, nullptr, 0)) { + LOGGER_WARNING(chat->log, "Failed to send peer announce info"); + return false; + } + } else { + chat->last_sync_response_peer_list = mono_time_get(chat->mono_time); + } + + return true; +} + +/** @brief Sends group state specified by `sync_flags` peer designated by `peer_number`. + * + * Return true on success. + */ +non_null() +static bool sync_response_send_state(GC_Chat *chat, GC_Connection *gconn, uint32_t peer_number, + uint16_t sync_flags) +{ + const bool first_sync = gconn->last_sync_response == 0; + + // Do not change the order of these four send calls. See: https://toktok.ltd/spec.html#sync_request-0xf8 + if ((sync_flags & GF_STATE) > 0 && chat->shared_state.version > 0) { + if (!send_peer_shared_state(chat, gconn)) { + LOGGER_WARNING(chat->log, "Failed to send shared state"); + return false; + } + + if (!send_peer_mod_list(chat, gconn)) { + LOGGER_WARNING(chat->log, "Failed to send mod list"); + return false; + } + + if (!send_peer_sanctions_list(chat, gconn)) { + LOGGER_WARNING(chat->log, "Failed to send sanctions list"); + return false; + } + + gconn->last_sync_response = mono_time_get(chat->mono_time); + } + + if ((sync_flags & GF_TOPIC) > 0 && chat->time_connected > 0 && chat->topic_info.version > 0) { + if (!send_peer_topic(chat, gconn)) { + LOGGER_WARNING(chat->log, "Failed to send topic"); + return false; + } + + gconn->last_sync_response = mono_time_get(chat->mono_time); + } + + if ((sync_flags & GF_PEERS) > 0) { + if (!sync_response_send_peers(chat, gconn, peer_number, first_sync)) { + return false; + } + + gconn->last_sync_response = mono_time_get(chat->mono_time); + } + + return true; +} + +/** @brief Handles a sync request packet and sends a response containing the peer list. + * + * May send additional group info in separate packets, including the topic, shared state, mod list, + * and sanctions list, if respective sync flags are set. + * + * If the group is password protected the password in the request data must first be verified. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + * Return -2 if password is invalid. + * Return -3 if we fail to send a response packet. + * Return -4 if `peer_number` does not designate a valid peer. + */ +non_null() +static int handle_gc_sync_request(GC_Chat *chat, uint32_t peer_number, const uint8_t *data, uint16_t length) +{ + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return -4; + } + + if (length < sizeof(uint16_t)) { + return -1; + } + + if (chat->numpeers <= 1) { + return 0; + } + + if (chat->shared_state.version == 0) { + LOGGER_DEBUG(chat->log, "Got sync request with uninitialized state"); + return 0; + } + + if (!mono_time_is_timeout(chat->mono_time, gconn->last_sync_response, GC_PING_TIMEOUT)) { + LOGGER_DEBUG(chat->log, "sync request rate limit for peer %d", peer_number); + return 0; + } + + uint16_t sync_flags; + net_unpack_u16(data, &sync_flags); + + if (chat_is_password_protected(chat)) { + if (length < (sizeof(uint16_t) * 2) + MAX_GC_PASSWORD_SIZE) { + return -2; + } + + uint16_t password_length; + net_unpack_u16(data + sizeof(uint16_t), &password_length); + + const uint8_t *password = data + (sizeof(uint16_t) * 2); + + if (!validate_password(chat, password, password_length)) { + LOGGER_DEBUG(chat->log, "Invalid password"); + return -2; + } + } + + if (!sync_response_send_state(chat, gconn, peer_number, sync_flags)) { + return -3; + } + + return 0; +} + +non_null() static void copy_self(const GC_Chat *chat, GC_Peer *peer); +non_null() static bool send_gc_peer_info_request(const GC_Chat *chat, GC_Connection *gconn); + + +/** @brief Shares our TCP relays with peer and adds shared relays to our connection with them. + * + * Returns true on success or if we're not connected to any TCP relays. + */ +non_null() +static bool send_gc_tcp_relays(const GC_Chat *chat, GC_Connection *gconn) +{ + + Node_format tcp_relays[GCC_MAX_TCP_SHARED_RELAYS]; + uint8_t data[GCC_MAX_TCP_SHARED_RELAYS * PACKED_NODE_SIZE_IP6]; + + const uint32_t n = tcp_copy_connected_relays_index(chat->tcp_conn, tcp_relays, GCC_MAX_TCP_SHARED_RELAYS, + gconn->tcp_relay_share_index); + + if (n == 0) { + return true; + } + + gconn->tcp_relay_share_index += GCC_MAX_TCP_SHARED_RELAYS; + + for (uint32_t i = 0; i < n; ++i) { + add_tcp_relay_connection(chat->tcp_conn, gconn->tcp_connection_num, &tcp_relays[i].ip_port, + tcp_relays[i].public_key); + } + + const int nodes_len = pack_nodes(chat->log, data, sizeof(data), tcp_relays, n); + + if (nodes_len <= 0 || (uint32_t)nodes_len > sizeof(data)) { + LOGGER_ERROR(chat->log, "Failed to pack tcp relays (nodes_len: %d)", nodes_len); + return false; + } + + if (!send_lossless_group_packet(chat, gconn, data, (uint16_t)nodes_len, GP_TCP_RELAYS)) { + LOGGER_ERROR(chat->log, "Failed to send tcp relays"); + return false; + } + + return true; +} + +/** @brief Adds a peer's shared TCP relays to our connection with them. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + * Return -2 if packet contains invalid data. + */ +non_null() +static int handle_gc_tcp_relays(GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, uint16_t length) +{ + if (length == 0) { + return -1; + } + + Node_format tcp_relays[GCC_MAX_TCP_SHARED_RELAYS]; + const int num_nodes = unpack_nodes(tcp_relays, GCC_MAX_TCP_SHARED_RELAYS, nullptr, data, length, true); + + if (num_nodes <= 0) { + return -2; + } + + for (int i = 0; i < num_nodes; ++i) { + const Node_format *tcp_node = &tcp_relays[i]; + + if (add_tcp_relay_connection(chat->tcp_conn, gconn->tcp_connection_num, &tcp_node->ip_port, + tcp_node->public_key) == 0) { + gcc_save_tcp_relay(chat->rng, gconn, tcp_node); + + if (gconn->tcp_relays_count == 1) { + add_gc_saved_peers(chat, gconn); // make sure we save at least one tcp relay + } + } + } + + return 0; +} + +/** @brief Send invite request to peer_number. + * + * If the group requires a password, the packet will + * contain the password supplied by the invite requestor. + * + * Return true on success. + */ +non_null() +static bool send_gc_invite_request(const GC_Chat *chat, GC_Connection *gconn) +{ + uint16_t length = 0; + uint8_t data[sizeof(uint16_t) + MAX_GC_PASSWORD_SIZE]; + + if (chat_is_password_protected(chat)) { + net_pack_u16(data, chat->shared_state.password_length); + length += sizeof(uint16_t); + + memcpy(data + length, chat->shared_state.password, MAX_GC_PASSWORD_SIZE); + length += MAX_GC_PASSWORD_SIZE; + } + + return send_lossless_group_packet(chat, gconn, data, length, GP_INVITE_REQUEST); +} + +non_null() +static bool send_gc_invite_response(const GC_Chat *chat, GC_Connection *gconn) +{ + return send_lossless_group_packet(chat, gconn, nullptr, 0, GP_INVITE_RESPONSE); +} + +/** @brief Handles an invite response packet. + * + * Return 0 if packet is correctly handled. + * Return -1 if we fail to send a sync request. + */ +non_null() +static int handle_gc_invite_response(GC_Chat *chat, GC_Connection *gconn) +{ + const uint16_t flags = GF_PEERS | GF_TOPIC | GF_STATE; + + if (!send_gc_sync_request(chat, gconn, flags)) { + return -1; + } + + return 0; +} + +/** + * @brief Handles an invite response reject packet. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + */ +non_null(1, 2, 3) nullable(5) +static int handle_gc_invite_response_reject(const GC_Session *c, GC_Chat *chat, const uint8_t *data, uint16_t length, + void *userdata) +{ + if (length < sizeof(uint8_t)) { + return -1; + } + + if (chat->connection_state == CS_CONNECTED) { + return 0; + } + + if (gc_get_self_role(chat) == GR_FOUNDER) { + return 0; + } + + uint8_t type = data[0]; + + if (type >= GJ_INVALID) { + type = GJ_INVITE_FAILED; + } + + chat->connection_state = CS_DISCONNECTED; + + if (c->rejected != nullptr) { + c->rejected(c->messenger, chat->group_number, type, userdata); + } + + return 0; +} + +/** @brief Sends an invite response rejection packet to peer designated by `gconn`. + * + * Return true on success. + */ +non_null() +static bool send_gc_invite_response_reject(const GC_Chat *chat, const GC_Connection *gconn, uint8_t type) +{ + if (type >= GJ_INVALID) { + type = GJ_INVITE_FAILED; + } + + uint8_t data[1]; + data[0] = type; + const uint16_t length = 1; + + return send_lossy_group_packet(chat, gconn, data, length, GP_INVITE_RESPONSE_REJECT); +} + +/** @brief Handles an invite request and verifies that the correct password has been supplied + * if the group is password protected. + * + * Return 0 if invite request is successfully handled. + * Return -1 if the group is full. + * Return -2 if the supplied password is invalid. + * Return -3 if we fail to send an invite response. + * Return -4 if peer_number does not designate a valid peer. + */ +non_null() +static int handle_gc_invite_request(GC_Chat *chat, uint32_t peer_number, const uint8_t *data, uint16_t length) +{ + if (chat->shared_state.version == 0) { // we aren't synced yet; ignore request + return 0; + } + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return -4; + } + + int ret = -1; + + uint8_t invite_error; + + if (get_gc_confirmed_numpeers(chat) >= chat->shared_state.maxpeers && !peer_is_founder(chat, peer_number)) { + invite_error = GJ_GROUP_FULL; + goto FAILED_INVITE; + } + + if (chat_is_password_protected(chat)) { + invite_error = GJ_INVALID_PASSWORD; + ret = -2; + + if (length < sizeof(uint16_t) + MAX_GC_PASSWORD_SIZE) { + goto FAILED_INVITE; + } + + uint16_t password_length; + net_unpack_u16(data, &password_length); + + const uint8_t *password = data + sizeof(uint16_t); + + if (!validate_password(chat, password, password_length)) { + goto FAILED_INVITE; + } + } + + if (!send_gc_invite_response(chat, gconn)) { + return -3; + } + + return 0; + +FAILED_INVITE: + send_gc_invite_response_reject(chat, gconn, invite_error); + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_DISCONNECTED, nullptr, 0); + + return ret; +} + +/** @brief Sends a lossless packet of type and length to all confirmed peers. */ +non_null() +static void send_gc_lossless_packet_all_peers(const GC_Chat *chat, const uint8_t *data, uint16_t length, uint8_t type) +{ + for (uint32_t i = 1; i < chat->numpeers; ++i) { + GC_Connection *gconn = get_gc_connection(chat, i); + + assert(gconn != nullptr); + + if (gconn->confirmed) { + send_lossless_group_packet(chat, gconn, data, length, type); + } + } +} + +/** @brief Sends a lossy packet of type and length to all confirmed peers. */ +non_null() +static void send_gc_lossy_packet_all_peers(const GC_Chat *chat, const uint8_t *data, uint16_t length, uint8_t type) +{ + for (uint32_t i = 1; i < chat->numpeers; ++i) { + const GC_Connection *gconn = get_gc_connection(chat, i); + + assert(gconn != nullptr); + + if (gconn->confirmed) { + send_lossy_group_packet(chat, gconn, data, length, type); + } + } +} + +/** @brief Creates packet with broadcast header info followed by data of length. + * + * Returns length of packet including header. + */ +non_null(3) nullable(1) +static uint16_t make_gc_broadcast_header(const uint8_t *data, uint16_t length, uint8_t *packet, uint8_t bc_type) +{ + packet[0] = bc_type; + const uint16_t header_len = sizeof(uint8_t); + + if (data != nullptr && length > 0) { + memcpy(packet + header_len, data, length); + } + + return length + header_len; +} + +/** @brief sends a group broadcast packet to all confirmed peers. + * + * Returns true on success. + */ +non_null(1) nullable(2) +static bool send_gc_broadcast_message(const GC_Chat *chat, const uint8_t *data, uint16_t length, uint8_t bc_type) +{ + if (length + GC_BROADCAST_ENC_HEADER_SIZE > MAX_GC_PACKET_SIZE) { + LOGGER_ERROR(chat->log, "Failed to broadcast message: invalid length %u", length); + return false; + } + + uint8_t *packet = (uint8_t *)malloc(length + GC_BROADCAST_ENC_HEADER_SIZE); + + if (packet == nullptr) { + return false; + } + + const uint16_t packet_len = make_gc_broadcast_header(data, length, packet, bc_type); + + send_gc_lossless_packet_all_peers(chat, packet, packet_len, GP_BROADCAST); + + free(packet); + + return true; +} + +non_null() +static bool group_topic_lock_enabled(const GC_Chat *chat); + +/** @brief Compares the supplied values with our own state and returns the appropriate + * sync flags for a sync request. + */ +non_null() +static uint16_t get_sync_flags(const GC_Chat *chat, uint16_t peers_checksum, uint16_t peer_count, + uint32_t sstate_version, uint32_t screds_version, uint16_t roles_checksum, + uint32_t topic_version, uint16_t topic_checksum) +{ + uint16_t sync_flags = 0; + + if (peers_checksum != chat->peers_checksum && peer_count >= get_gc_confirmed_numpeers(chat)) { + sync_flags |= GF_PEERS; + } + + if (sstate_version > 0) { + const uint16_t self_roles_checksum = chat->moderation.sanctions_creds.checksum + chat->roles_checksum; + + if ((sstate_version > chat->shared_state.version || screds_version > chat->moderation.sanctions_creds.version) + || (screds_version == chat->moderation.sanctions_creds.version + && roles_checksum != self_roles_checksum)) { + sync_flags |= GF_STATE; + } + } + + if (group_topic_lock_enabled(chat)) { + if (topic_version > chat->topic_info.version || + (topic_version == chat->topic_info.version && topic_checksum > chat->topic_info.checksum)) { + sync_flags |= GF_TOPIC; + } + } else if (topic_checksum > chat->topic_info.checksum) { + sync_flags |= GF_TOPIC; + } + + return sync_flags; +} + +/** @brief Compares a peer's group sync info that we received in a ping packet to our own. + * + * If their info appears to be more recent than ours we send them a sync request. + * + * This function should only be called from `handle_gc_ping()`. + * + * Returns true if a sync request packet is successfully sent. + */ +non_null() +static bool do_gc_peer_state_sync(GC_Chat *chat, GC_Connection *gconn, const uint8_t *sync_data, + const uint16_t length) +{ + if (length < GC_PING_PACKET_MIN_DATA_SIZE) { + return false; + } + + uint16_t peers_checksum; + uint16_t peer_count; + uint32_t sstate_version; + uint32_t screds_version; + uint16_t roles_checksum; + uint32_t topic_version; + uint16_t topic_checksum; + + size_t unpacked_len = 0; + + net_unpack_u16(sync_data, &peers_checksum); + unpacked_len += sizeof(uint16_t); + + net_unpack_u16(sync_data + unpacked_len, &peer_count); + unpacked_len += sizeof(uint16_t); + + net_unpack_u32(sync_data + unpacked_len, &sstate_version); + unpacked_len += sizeof(uint32_t); + + net_unpack_u32(sync_data + unpacked_len, &screds_version); + unpacked_len += sizeof(uint32_t); + + net_unpack_u16(sync_data + unpacked_len, &roles_checksum); + unpacked_len += sizeof(uint16_t); + + net_unpack_u32(sync_data + unpacked_len, &topic_version); + unpacked_len += sizeof(uint32_t); + + net_unpack_u16(sync_data + unpacked_len, &topic_checksum); + unpacked_len += sizeof(uint16_t); + + if (unpacked_len != GC_PING_PACKET_MIN_DATA_SIZE) { + LOGGER_FATAL(chat->log, "Unpacked length is impossible (%zu)", unpacked_len); + return false; + } + + const uint16_t sync_flags = get_sync_flags(chat, peers_checksum, peer_count, sstate_version, screds_version, + roles_checksum, topic_version, topic_checksum); + + if (sync_flags > 0) { + return send_gc_sync_request(chat, gconn, sync_flags); + } + + return false; +} + +/** @brief Handles a ping packet. + * + * The packet contains sync information including peer's peer list checksum, + * shared state version, topic version, and sanction credentials version. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size or peer is not confirmed. + */ +non_null() +static int handle_gc_ping(GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, uint16_t length) +{ + if (length < GC_PING_PACKET_MIN_DATA_SIZE) { + return -1; + } + + if (!gconn->confirmed) { + return -1; + } + + do_gc_peer_state_sync(chat, gconn, data, length); + + if (length > GC_PING_PACKET_MIN_DATA_SIZE) { + IP_Port ip_port; + memset(&ip_port, 0, sizeof(IP_Port)); + + if (unpack_ip_port(&ip_port, data + GC_PING_PACKET_MIN_DATA_SIZE, + length - GC_PING_PACKET_MIN_DATA_SIZE, false) > 0) { + gcc_set_ip_port(gconn, &ip_port); + add_gc_saved_peers(chat, gconn); + } + } + + return 0; +} + +int gc_set_self_status(const Messenger *m, int group_number, Group_Peer_Status status) +{ + const GC_Session *c = m->group_handler; + const GC_Chat *chat = gc_get_group(c, group_number); + + if (chat == nullptr) { + return -1; + } + + self_gc_set_status(chat, status); + + uint8_t data[1]; + data[0] = gc_get_self_status(chat); + + if (!send_gc_broadcast_message(chat, data, 1, GM_STATUS)) { + return -2; + } + + return 0; +} + +/** @brief Handles a status broadcast from `peer`. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid length. + */ +non_null(1, 2, 3, 4) nullable(6) +static int handle_gc_status(const GC_Session *c, const GC_Chat *chat, GC_Peer *peer, const uint8_t *data, + uint16_t length, void *userdata) +{ + if (length < sizeof(uint8_t)) { + return -1; + } + + const Group_Peer_Status status = (Group_Peer_Status)data[0]; + + if (status > GS_BUSY) { + LOGGER_WARNING(chat->log, "Received invalid status %u", status); + return 0; + } + + peer->status = status; + + if (c->status_change != nullptr) { + c->status_change(c->messenger, chat->group_number, peer->peer_id, status, userdata); + } + + return 0; +} + +uint8_t gc_get_status(const GC_Chat *chat, uint32_t peer_id) +{ + const int peer_number = get_peer_number_of_peer_id(chat, peer_id); + + const GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return UINT8_MAX; + } + + return peer->status; +} + +uint8_t gc_get_role(const GC_Chat *chat, uint32_t peer_id) +{ + const int peer_number = get_peer_number_of_peer_id(chat, peer_id); + + const GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return UINT8_MAX; + } + + return peer->role; +} + +void gc_get_chat_id(const GC_Chat *chat, uint8_t *dest) +{ + if (dest != nullptr) { + memcpy(dest, get_chat_id(chat->chat_public_key), CHAT_ID_SIZE); + } +} + +/** @brief Sends self peer info to `gconn`. + * + * If the group is password protected the request will contain the group + * password, which the recipient will validate in the respective + * group message handler. + * + * Returns true on success. + */ +non_null() +static bool send_self_to_peer(const GC_Chat *chat, GC_Connection *gconn) +{ + GC_Peer *self = (GC_Peer *)calloc(1, sizeof(GC_Peer)); + + if (self == nullptr) { + return false; + } + + copy_self(chat, self); + + const uint16_t data_size = PACKED_GC_PEER_SIZE + sizeof(uint16_t) + MAX_GC_PASSWORD_SIZE; + uint8_t *data = (uint8_t *)malloc(data_size); + + if (data == nullptr) { + free(self); + return false; + } + + uint16_t length = 0; + + if (chat_is_password_protected(chat)) { + net_pack_u16(data, chat->shared_state.password_length); + length += sizeof(uint16_t); + + memcpy(data + sizeof(uint16_t), chat->shared_state.password, MAX_GC_PASSWORD_SIZE); + length += MAX_GC_PASSWORD_SIZE; + } + + const int packed_len = pack_gc_peer(data + length, data_size - length, self); + length += packed_len; + + free(self); + + if (packed_len <= 0) { + LOGGER_DEBUG(chat->log, "pack_gc_peer failed in handle_gc_peer_info_request_request %d", packed_len); + free(data); + return false; + } + + const bool ret = send_lossless_group_packet(chat, gconn, data, length, GP_PEER_INFO_RESPONSE); + + free(data); + + return ret; +} + +/** @brief Handles a peer info request packet. + * + * Return 0 on success. + * Return -1 if unconfirmed peer is trying to join a full group. + * Return -2 if response fails. + * Return -3 if `peer_number` does not designate a valid peer. + */ +non_null() +static int handle_gc_peer_info_request(const GC_Chat *chat, uint32_t peer_number) +{ + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return -3; + } + + if (!gconn->confirmed && get_gc_confirmed_numpeers(chat) >= chat->shared_state.maxpeers + && !peer_is_founder(chat, peer_number)) { + return -1; + } + + if (!send_self_to_peer(chat, gconn)) { + return -2; + } + + return 0; +} + +/** @brief Sends a peer info request to peer designated by `gconn`. + * + * Return true on success. + */ +non_null() +static bool send_gc_peer_info_request(const GC_Chat *chat, GC_Connection *gconn) +{ + return send_lossless_group_packet(chat, gconn, nullptr, 0, GP_PEER_INFO_REQUEST); +} + +/** @brief Do peer info exchange with peer designated by `gconn`. + * + * This function sends two packets to a peer. The first packet is a peer info response containing our own info, + * and the second packet is a peer info request. + * + * Return false if either packet fails to send. + */ +static bool send_gc_peer_exchange(const GC_Chat *chat, GC_Connection *gconn) +{ + return send_self_to_peer(chat, gconn) && send_gc_peer_info_request(chat, gconn); +} + +/** @brief Updates peer's info, validates their group role, and sets them as a confirmed peer. + * If the group is password protected the password must first be validated. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + * Return -2 if group number is invalid. + * Return -3 if peer number is invalid. + * Return -4 if unconfirmed peer is trying to join a full group. + * Return -5 if supplied group password is invalid. + * Return -6 if we fail to add the peer to the peer list. + * Return -7 if peer's role cannot be validated. + * Return -8 if malloc fails. + */ +non_null(1, 2, 4) nullable(6) +static int handle_gc_peer_info_response(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, + const uint8_t *data, uint16_t length, void *userdata) +{ + if (length < PACKED_GC_PEER_SIZE) { + return -1; + } + + GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return -3; + } + + GC_Connection *gconn = &peer->gconn; + + if (!gconn->confirmed && get_gc_confirmed_numpeers(chat) >= chat->shared_state.maxpeers + && !peer_is_founder(chat, peer_number)) { + return -4; + } + + uint16_t unpacked_len = 0; + + if (chat_is_password_protected(chat)) { + if (length < sizeof(uint16_t) + MAX_GC_PASSWORD_SIZE) { + return -5; + } + + uint16_t password_length; + net_unpack_u16(data, &password_length); + unpacked_len += sizeof(uint16_t); + + if (!validate_password(chat, data + unpacked_len, password_length)) { + return -5; + } + + unpacked_len += MAX_GC_PASSWORD_SIZE; + } + + if (length <= unpacked_len) { + return -1; + } + + GC_Peer *peer_info = (GC_Peer *)calloc(1, sizeof(GC_Peer)); + + if (peer_info == nullptr) { + return -8; + } + + if (unpack_gc_peer(peer_info, data + unpacked_len, length - unpacked_len) == -1) { + LOGGER_ERROR(chat->log, "unpack_gc_peer() failed"); + free(peer_info); + return -6; + } + + if (peer_update(chat, peer_info, peer_number) == -1) { + LOGGER_WARNING(chat->log, "peer_update() failed"); + free(peer_info); + return -6; + } + + free(peer_info); + + const bool was_confirmed = gconn->confirmed; + gconn->confirmed = true; + + update_gc_peer_roles(chat); + + add_gc_saved_peers(chat, gconn); + + set_gc_peerlist_checksum(chat); + + if (c->peer_join != nullptr && !was_confirmed) { + c->peer_join(c->messenger, chat->group_number, peer->peer_id, userdata); + } + + return 0; +} + +/** @brief Sends the group shared state and its signature to peer_number. + * + * Returns true on success. + */ +non_null() +static bool send_peer_shared_state(const GC_Chat *chat, GC_Connection *gconn) +{ + if (chat->shared_state.version == 0) { + return false; + } + + uint8_t packet[GC_SHARED_STATE_ENC_PACKET_SIZE]; + const int length = make_gc_shared_state_packet(chat, packet, sizeof(packet)); + + if (length != GC_SHARED_STATE_ENC_PACKET_SIZE) { + return false; + } + + return send_lossless_group_packet(chat, gconn, packet, (uint16_t)length, GP_SHARED_STATE); +} + +/** @brief Sends the group shared state and signature to all confirmed peers. + * + * Returns true on success. + */ +non_null() +static bool broadcast_gc_shared_state(const GC_Chat *chat) +{ + uint8_t packet[GC_SHARED_STATE_ENC_PACKET_SIZE]; + const int packet_len = make_gc_shared_state_packet(chat, packet, sizeof(packet)); + + if (packet_len != GC_SHARED_STATE_ENC_PACKET_SIZE) { + return false; + } + + send_gc_lossless_packet_all_peers(chat, packet, (uint16_t)packet_len, GP_SHARED_STATE); + + return true; +} + +/** @brief Helper function for `do_gc_shared_state_changes()`. + * + * If the privacy state has been set to private, we kill our group's connection to the DHT. + * Otherwise, we create a new connection with the DHT and flag an announcement. + */ +non_null(1, 2) nullable(3) +static void do_privacy_state_change(const GC_Session *c, GC_Chat *chat, void *userdata) +{ + if (is_public_chat(chat)) { + if (!m_create_group_connection(c->messenger, chat)) { + LOGGER_ERROR(chat->log, "Failed to initialize group friend connection"); + } else { + chat->update_self_announces = true; + chat->join_type = HJ_PUBLIC; + } + } else { + kill_group_friend_connection(c, chat); + cleanup_gca(c->announces_list, get_chat_id(chat->chat_public_key)); + chat->join_type = HJ_PRIVATE; + } + + if (c->privacy_state != nullptr) { + c->privacy_state(c->messenger, chat->group_number, chat->shared_state.privacy_state, userdata); + } +} + +/** + * Compares old_shared_state with the chat instance's current shared state and triggers the + * appropriate callbacks depending on what pieces of state information changed. Also + * handles DHT announcement/removal if the privacy state changed. + * + * The initial retrieval of the shared state on group join will be ignored by this function. + */ +non_null(1, 2, 3) nullable(4) +static void do_gc_shared_state_changes(const GC_Session *c, GC_Chat *chat, const GC_SharedState *old_shared_state, + void *userdata) +{ + /* Max peers changed */ + if (chat->shared_state.maxpeers != old_shared_state->maxpeers && c->peer_limit != nullptr) { + c->peer_limit(c->messenger, chat->group_number, chat->shared_state.maxpeers, userdata); + } + + /* privacy state changed */ + if (chat->shared_state.privacy_state != old_shared_state->privacy_state) { + do_privacy_state_change(c, chat, userdata); + } + + /* password changed */ + if (chat->shared_state.password_length != old_shared_state->password_length + || memcmp(chat->shared_state.password, old_shared_state->password, old_shared_state->password_length) != 0) { + + if (c->password != nullptr) { + c->password(c->messenger, chat->group_number, chat->shared_state.password, + chat->shared_state.password_length, userdata); + } + } + + /* topic lock state changed */ + if (chat->shared_state.topic_lock != old_shared_state->topic_lock && c->topic_lock != nullptr) { + const Group_Topic_Lock lock_state = group_topic_lock_enabled(chat) ? TL_ENABLED : TL_DISABLED; + c->topic_lock(c->messenger, chat->group_number, lock_state, userdata); + } + + /* voice state changed */ + if (chat->shared_state.voice_state != old_shared_state->voice_state && c->voice_state != nullptr) { + c->voice_state(c->messenger, chat->group_number, chat->shared_state.voice_state, userdata); + } +} + +/** @brief Sends a sync request to a random peer in the group with the specificed sync flags. + * + * Return true on success. + */ +non_null() +static bool send_gc_random_sync_request(GC_Chat *chat, uint16_t sync_flags) +{ + GC_Connection *rand_gconn = random_gc_connection(chat); + + if (rand_gconn == nullptr) { + return false; + } + + return send_gc_sync_request(chat, rand_gconn, sync_flags); +} + +/** @brief Returns true if all shared state values are legal. */ +non_null() +static bool validate_gc_shared_state(const GC_SharedState *state) +{ + return state->maxpeers > 0 + && state->password_length <= MAX_GC_PASSWORD_SIZE + && state->group_name_len > 0 + && state->group_name_len <= MAX_GC_GROUP_NAME_SIZE + && state->privacy_state <= GI_PRIVATE + && state->voice_state <= GV_FOUNDER; +} + +/** @brief Handles a shared state error and attempts to send a sync request to a random peer. + * + * Return 0 if error is currectly handled. + * Return -1 on failure. + */ +non_null() +static int handle_gc_shared_state_error(GC_Chat *chat, GC_Connection *gconn) +{ + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_SYNC_ERR, nullptr, 0); + + if (chat->shared_state.version == 0) { + chat->connection_state = CS_CONNECTING; + return 0; + } + + if (chat->numpeers <= 1) { + return 0; + } + + if (!send_gc_random_sync_request(chat, GF_STATE)) { + return -1; + } + + return 0; +} + +/** @brief Handles a shared state packet and validates the new shared state. + * + * Return 0 if packet is successfully handled. + * Return -1 if packet is invalid and this is not successfully handled. + */ +non_null(1, 2, 3, 4) nullable(6) +static int handle_gc_shared_state(const GC_Session *c, GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, + uint16_t length, void *userdata) +{ + if (length < GC_SHARED_STATE_ENC_PACKET_SIZE) { + return handle_gc_shared_state_error(chat, gconn); + } + + const uint8_t *signature = data; + const uint8_t *ss_data = data + SIGNATURE_SIZE; + const uint16_t ss_length = length - SIGNATURE_SIZE; + + if (crypto_sign_verify_detached(signature, ss_data, GC_PACKED_SHARED_STATE_SIZE, + get_sig_pk(chat->chat_public_key)) == -1) { + LOGGER_DEBUG(chat->log, "Failed to validate shared state signature"); + return handle_gc_shared_state_error(chat, gconn); + } + + uint32_t version; + net_unpack_u32(ss_data, &version); // version is the first 4 bytes of shared state data payload + + if (version == 0 || version < chat->shared_state.version) { + LOGGER_DEBUG(chat->log, "Invalid shared state version (got %u, expected >= %u)", + version, chat->shared_state.version); + return 0; + } + + GC_SharedState old_shared_state = chat->shared_state; + GC_SharedState new_shared_state; + + if (unpack_gc_shared_state(&new_shared_state, ss_data, ss_length) == 0) { + LOGGER_WARNING(chat->log, "Failed to unpack shared state"); + return 0; + } + + if (!validate_gc_shared_state(&new_shared_state)) { + LOGGER_WARNING(chat->log, "Failed to validate shared state"); + return 0; + } + + if (chat->shared_state.version == 0) { // init founder public sig key in moderation object + memcpy(chat->moderation.founder_public_sig_key, + get_sig_pk(new_shared_state.founder_public_key), SIG_PUBLIC_KEY_SIZE); + } + + chat->shared_state = new_shared_state; + + memcpy(chat->shared_state_sig, signature, sizeof(chat->shared_state_sig)); + + set_gc_shared_state_version(chat, chat->shared_state.version); + + do_gc_shared_state_changes(c, chat, &old_shared_state, userdata); + + return 0; +} + +/** @brief Validates `data` containing a moderation list and unpacks it into the + * shared state of `chat`. + * + * Return 1 if data is valid but mod list doesn't match shared state. + * Return 0 if data is valid. + * Return -1 if data is invalid. + */ +non_null() +static int validate_unpack_mod_list(GC_Chat *chat, const uint8_t *data, uint16_t length, uint16_t num_mods) +{ + if (num_mods > MOD_MAX_NUM_MODERATORS) { + return -1; + } + + uint8_t mod_list_hash[MOD_MODERATION_HASH_SIZE] = {0}; + + if (length > 0) { + mod_list_get_data_hash(mod_list_hash, data, length); + } + + // we make sure that this mod list's hash matches the one we got in our last shared state update + if (chat->shared_state.version > 0 + && memcmp(mod_list_hash, chat->shared_state.mod_list_hash, MOD_MODERATION_HASH_SIZE) != 0) { + LOGGER_WARNING(chat->log, "failed to validate mod list hash"); + return 1; + } + + if (mod_list_unpack(&chat->moderation, data, length, num_mods) == -1) { + LOGGER_WARNING(chat->log, "failed to unpack mod list"); + return -1; + } + + return 0; +} + +/** @brief Handles new mod_list and compares its hash against the mod_list_hash in the shared state. + * + * If the new list fails validation, we attempt to send a sync request to a random peer. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + * Return -2 if packet contained invalid data or validation failed. + */ +non_null(1, 2, 3) nullable(5) +static int handle_gc_mod_list(const GC_Session *c, GC_Chat *chat, const uint8_t *data, uint16_t length, void *userdata) +{ + if (length < sizeof(uint16_t)) { + return -1; + } + + // only the founder can modify the list; the founder can never be out of sync + if (self_gc_is_founder(chat)) { + return 0; + } + + uint16_t num_mods; + net_unpack_u16(data, &num_mods); + + const int unpack_ret = validate_unpack_mod_list(chat, data + sizeof(uint16_t), length - sizeof(uint16_t), num_mods); + + if (unpack_ret == 0) { + update_gc_peer_roles(chat); + + if (chat->connection_state == CS_CONNECTED && c->moderation != nullptr) { + c->moderation(c->messenger, chat->group_number, (uint32_t) -1, (uint32_t) -1, MV_MOD, userdata); + } + + return 0; + } + + if (unpack_ret == 1) { + return 0; + } + + // unpack/validation failed: handle error + + if (chat->shared_state.version == 0) { + chat->connection_state = CS_CONNECTING; + return -2; + } + + if (chat->numpeers <= 1) { + return 0; + } + + send_gc_random_sync_request(chat, GF_STATE); + + return 0; +} + +/** @brief Handles a sanctions list validation error and attempts to send a sync request to a random peer. + * + * Return 0 on success. + * Return -1 on failure. + */ +non_null() +static int handle_gc_sanctions_list_error(GC_Chat *chat) +{ + if (chat->moderation.sanctions_creds.version > 0) { + return 0; + } + + if (chat->shared_state.version == 0) { + chat->connection_state = CS_CONNECTING; + return 0; + } + + if (chat->numpeers <= 1) { + return 0; + } + + if (!send_gc_random_sync_request(chat, GF_STATE)) { + return -1; + } + + return 0; +} + +/** @brief Handles a sanctions list packet. + * + * Return 0 if packet is handled correctly. + * Return -1 if we failed to gracefully handle a sanctions list error. + * Return -2 if packet has invalid size. + */ +non_null(1, 2, 3) nullable(5) +static int handle_gc_sanctions_list(const GC_Session *c, GC_Chat *chat, const uint8_t *data, uint16_t length, + void *userdata) +{ + if (length < sizeof(uint16_t)) { + return -2; + } + + uint16_t num_sanctions; + net_unpack_u16(data, &num_sanctions); + + if (num_sanctions > MOD_MAX_NUM_SANCTIONS) { + LOGGER_DEBUG(chat->log, "num_sanctions: %u exceeds maximum", num_sanctions); + return handle_gc_sanctions_list_error(chat); + } + + Mod_Sanction_Creds creds; + + Mod_Sanction *sanctions = (Mod_Sanction *)calloc(num_sanctions, sizeof(Mod_Sanction)); + + if (sanctions == nullptr) { + return -1; + } + + const int unpacked_num = sanctions_list_unpack(sanctions, &creds, num_sanctions, data + sizeof(uint16_t), + length - sizeof(uint16_t), nullptr); + + if (unpacked_num != num_sanctions) { + LOGGER_WARNING(chat->log, "Failed to unpack sanctions list: %d", unpacked_num); + free(sanctions); + return handle_gc_sanctions_list_error(chat); + } + + if (!sanctions_list_check_integrity(&chat->moderation, &creds, sanctions, num_sanctions)) { + LOGGER_WARNING(chat->log, "Sanctions list failed integrity check"); + free(sanctions); + return handle_gc_sanctions_list_error(chat); + } + + if (creds.version < chat->moderation.sanctions_creds.version) { + free(sanctions); + return 0; + } + + // this may occur if two mods change the sanctions list at the exact same time + if (creds.version == chat->moderation.sanctions_creds.version + && creds.checksum <= chat->moderation.sanctions_creds.checksum) { + free(sanctions); + return 0; + } + + sanctions_list_cleanup(&chat->moderation); + + chat->moderation.sanctions_creds = creds; + chat->moderation.sanctions = sanctions; + chat->moderation.num_sanctions = num_sanctions; + + update_gc_peer_roles(chat); + + if (chat->connection_state == CS_CONNECTED) { + if (c->moderation != nullptr) { + c->moderation(c->messenger, chat->group_number, (uint32_t) -1, (uint32_t) -1, MV_OBSERVER, userdata); + } + } + + return 0; +} + +/** @brief Makes a mod_list packet. + * + * Returns length of packet data on success. + * Returns -1 on failure. + */ +non_null() +static int make_gc_mod_list_packet(const GC_Chat *chat, uint8_t *data, uint32_t maxlen, uint16_t mod_list_size) +{ + if (maxlen < sizeof(uint16_t) + mod_list_size) { + return -1; + } + + net_pack_u16(data, chat->moderation.num_mods); + const uint16_t length = sizeof(uint16_t) + mod_list_size; + + if (mod_list_size > 0) { + uint8_t *packed_mod_list = (uint8_t *)malloc(mod_list_size); + + if (packed_mod_list == nullptr) { + return -1; + } + + mod_list_pack(&chat->moderation, packed_mod_list); + memcpy(data + sizeof(uint16_t), packed_mod_list, mod_list_size); + + free(packed_mod_list); + } + + return length; +} + +/** @brief Sends the moderator list to peer. + * + * Return true on success. + */ +non_null() +static bool send_peer_mod_list(const GC_Chat *chat, GC_Connection *gconn) +{ + const uint16_t mod_list_size = chat->moderation.num_mods * MOD_LIST_ENTRY_SIZE; + const uint16_t length = sizeof(uint16_t) + mod_list_size; + uint8_t *packet = (uint8_t *)malloc(length); + + if (packet == nullptr) { + return false; + } + + const int packet_len = make_gc_mod_list_packet(chat, packet, length, mod_list_size); + + if (packet_len != length) { + free(packet); + return false; + } + + const bool ret = send_lossless_group_packet(chat, gconn, packet, length, GP_MOD_LIST); + + free(packet); + + return ret; +} + +/** @brief Makes a sanctions list packet. + * + * Returns packet length on success. + * Returns -1 on failure. + */ +non_null() +static int make_gc_sanctions_list_packet(const GC_Chat *chat, uint8_t *data, uint16_t maxlen) +{ + if (maxlen < sizeof(uint16_t)) { + return -1; + } + + net_pack_u16(data, chat->moderation.num_sanctions); + const uint16_t length = sizeof(uint16_t); + + const int packed_len = sanctions_list_pack(data + length, maxlen - length, chat->moderation.sanctions, + chat->moderation.num_sanctions, &chat->moderation.sanctions_creds); + + if (packed_len < 0) { + return -1; + } + + return (int)(length + packed_len); +} + +/** @brief Sends the sanctions list to peer. + * + * Returns true on success. + */ +non_null() +static bool send_peer_sanctions_list(const GC_Chat *chat, GC_Connection *gconn) +{ + if (chat->moderation.sanctions_creds.version == 0) { + return true; + } + + const uint16_t packet_size = MOD_SANCTION_PACKED_SIZE * chat->moderation.num_sanctions + + sizeof(uint16_t) + MOD_SANCTIONS_CREDS_SIZE; + + uint8_t *packet = (uint8_t *)malloc(packet_size); + + if (packet == nullptr) { + return false; + } + + const int packet_len = make_gc_sanctions_list_packet(chat, packet, packet_size); + + if (packet_len == -1) { + free(packet); + return false; + } + + const bool ret = send_lossless_group_packet(chat, gconn, packet, (uint16_t)packet_len, GP_SANCTIONS_LIST); + + free(packet); + + return ret; +} + +/** @brief Sends the sanctions list to all peers in group. + * + * Returns true on success. + */ +non_null() +static bool broadcast_gc_sanctions_list(const GC_Chat *chat) +{ + const uint16_t packet_size = MOD_SANCTION_PACKED_SIZE * chat->moderation.num_sanctions + + sizeof(uint16_t) + MOD_SANCTIONS_CREDS_SIZE; + + uint8_t *packet = (uint8_t *)malloc(packet_size); + + if (packet == nullptr) { + return false; + } + + const int packet_len = make_gc_sanctions_list_packet(chat, packet, packet_size); + + if (packet_len == -1) { + free(packet); + return false; + } + + send_gc_lossless_packet_all_peers(chat, packet, (uint16_t)packet_len, GP_SANCTIONS_LIST); + + free(packet); + + return true; +} + +/** @brief Re-signs all sanctions list entries signed by public_sig_key and broadcasts + * the updated sanctions list to all group peers. + * + * Returns true on success. + */ +non_null() +static bool update_gc_sanctions_list(GC_Chat *chat, const uint8_t *public_sig_key) +{ + const uint16_t num_replaced = sanctions_list_replace_sig(&chat->moderation, public_sig_key); + + if (num_replaced == 0) { + return true; + } + + return broadcast_gc_sanctions_list(chat); +} + +/** @brief Sends mod_list to all peers in group. + * + * Returns true on success. + */ +non_null() +static bool broadcast_gc_mod_list(const GC_Chat *chat) +{ + const uint16_t mod_list_size = chat->moderation.num_mods * MOD_LIST_ENTRY_SIZE; + const uint16_t length = sizeof(uint16_t) + mod_list_size; + uint8_t *packet = (uint8_t *)malloc(length); + + if (packet == nullptr) { + return false; + } + + const int packet_len = make_gc_mod_list_packet(chat, packet, length, mod_list_size); + + if (packet_len != length) { + free(packet); + return false; + } + + send_gc_lossless_packet_all_peers(chat, packet, length, GP_MOD_LIST); + + free(packet); + + return true; +} + +/** @brief Sends a parting signal to the group. + * + * Returns 0 on success. + * Returns -1 if the message is too long. + * Returns -2 if the packet failed to send. + */ +non_null(1) nullable(2) +static int send_gc_self_exit(const GC_Chat *chat, const uint8_t *partmessage, uint16_t length) +{ + if (length > MAX_GC_PART_MESSAGE_SIZE) { + return -1; + } + + if (!send_gc_broadcast_message(chat, partmessage, length, GM_PEER_EXIT)) { + return -2; + } + + return 0; +} + +/** @brief Handles a peer exit broadcast. */ +non_null(1, 2) nullable(3) +static void handle_gc_peer_exit(const GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, uint16_t length) +{ + if (length > MAX_GC_PART_MESSAGE_SIZE) { + length = MAX_GC_PART_MESSAGE_SIZE; + } + + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_QUIT, data, length); +} + +int gc_set_self_nick(const Messenger *m, int group_number, const uint8_t *nick, uint16_t length) +{ + const GC_Session *c = m->group_handler; + const GC_Chat *chat = gc_get_group(c, group_number); + + if (chat == nullptr) { + return -1; + } + + if (length > MAX_GC_NICK_SIZE) { + return -2; + } + + if (length == 0 || nick == nullptr) { + return -3; + } + + if (!self_gc_set_nick(chat, nick, length)) { + return -2; + } + + if (!send_gc_broadcast_message(chat, nick, length, GM_NICK)) { + return -4; + } + + return 0; +} + +bool gc_get_peer_nick(const GC_Chat *chat, uint32_t peer_id, uint8_t *name) +{ + const int peer_number = get_peer_number_of_peer_id(chat, peer_id); + + const GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return false; + } + + if (name != nullptr) { + memcpy(name, peer->nick, peer->nick_length); + } + + return true; +} + +int gc_get_peer_nick_size(const GC_Chat *chat, uint32_t peer_id) +{ + const int peer_number = get_peer_number_of_peer_id(chat, peer_id); + + const GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return -1; + } + + return peer->nick_length; +} + +/** @brief Handles a nick change broadcast. + * + * Return 0 if packet is handled correctly. + * Return -1 on failure. + */ +non_null(1, 2, 3, 4) nullable(6) +static int handle_gc_nick(const GC_Session *c, GC_Chat *chat, GC_Peer *peer, const uint8_t *nick, + uint16_t length, void *userdata) +{ + /* If this happens malicious behaviour is highly suspect */ + if (length == 0 || length > MAX_GC_NICK_SIZE) { + GC_Connection *gconn = &peer->gconn; + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_SYNC_ERR, nullptr, 0); + LOGGER_WARNING(chat->log, "Invalid nick length for nick: %s (%u)", nick, length); + return -1; + } + + memcpy(peer->nick, nick, length); + peer->nick_length = length; + + if (c->nick_change != nullptr) { + c->nick_change(c->messenger, chat->group_number, peer->peer_id, nick, length, userdata); + } + + return 0; +} + +/** @brief Copies peer_number's public key to `public_key`. + * + * Returns 0 on success. + * Returns -1 if peer_number is invalid. + * Returns -2 if `public_key` is null. + */ +non_null() +static int get_gc_peer_public_key(const GC_Chat *chat, uint32_t peer_number, uint8_t *public_key) +{ + const GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return -1; + } + + if (public_key == nullptr) { + return -2; + } + + memcpy(public_key, gconn->addr.public_key, ENC_PUBLIC_KEY_SIZE); + + return 0; +} + +int gc_get_peer_public_key_by_peer_id(const GC_Chat *chat, uint32_t peer_id, uint8_t *public_key) +{ + const int peer_number = get_peer_number_of_peer_id(chat, peer_id); + + const GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return -1; + } + + if (public_key == nullptr) { + return -2; + } + + memcpy(public_key, gconn->addr.public_key, ENC_PUBLIC_KEY_SIZE); + + return 0; +} + +unsigned int gc_get_peer_connection_status(const GC_Chat *chat, uint32_t peer_id) +{ + const int peer_number = get_peer_number_of_peer_id(chat, peer_id); + + if (peer_number_is_self(peer_number)) { // we cannot have a connection with ourselves + return 0; + } + + const GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return 0; + } + + if (gcc_conn_is_direct(chat->mono_time, gconn)) { + return 2; + } + + return 1; +} + +/** @brief Creates a topic packet and puts it in data. + * + * Packet includes the topic, topic length, public signature key of the + * setter, topic version, and the signature. + * + * Returns packet length on success. + * Returns -1 on failure. + */ +non_null() +static int make_gc_topic_packet(const GC_Chat *chat, uint8_t *data, uint16_t length) +{ + if (length < SIGNATURE_SIZE + chat->topic_info.length + GC_MIN_PACKED_TOPIC_INFO_SIZE) { + return -1; + } + + memcpy(data, chat->topic_sig, SIGNATURE_SIZE); + uint16_t data_length = SIGNATURE_SIZE; + + const uint16_t packed_len = pack_gc_topic_info(data + data_length, length - data_length, &chat->topic_info); + data_length += packed_len; + + if (packed_len != chat->topic_info.length + GC_MIN_PACKED_TOPIC_INFO_SIZE) { + return -1; + } + + return data_length; +} + +/** @brief Sends the group topic to peer. + * + * Returns true on success. + */ +non_null() +static bool send_peer_topic(const GC_Chat *chat, GC_Connection *gconn) +{ + const uint16_t packet_buf_size = SIGNATURE_SIZE + chat->topic_info.length + GC_MIN_PACKED_TOPIC_INFO_SIZE; + uint8_t *packet = (uint8_t *)malloc(packet_buf_size); + + if (packet == nullptr) { + return false; + } + + const int packet_len = make_gc_topic_packet(chat, packet, packet_buf_size); + + if (packet_len != packet_buf_size) { + free(packet); + return false; + } + + if (!send_lossless_group_packet(chat, gconn, packet, packet_buf_size, GP_TOPIC)) { + free(packet); + return false; + } + + free(packet); + + return true; +} + +/** + * @brief Initiates a session key rotation with peer designated by `gconn`. + * + * Return true on success. + */ +non_null() +static bool send_peer_key_rotation_request(const GC_Chat *chat, GC_Connection *gconn) +{ + // Only the peer closest to the chat_id sends requests. This is to prevent both peers from sending + // requests at the same time and ending up with a different resulting shared key + if (!gconn->self_is_closer) { + // if this peer hasn't sent us a rotation request in a reasonable timeframe we drop their connection + if (mono_time_is_timeout(chat->mono_time, gconn->last_key_rotation, GC_KEY_ROTATION_TIMEOUT + GC_PING_TIMEOUT)) { + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_TIMEOUT, nullptr, 0); + } + + return true; + } + + uint8_t packet[1 + ENC_PUBLIC_KEY_SIZE]; + + net_pack_bool(&packet[0], false); // request type + + create_gc_session_keypair(chat->log, chat->rng, gconn->session_public_key, gconn->session_secret_key); + + // copy new session public key to packet + memcpy(packet + 1, gconn->session_public_key, ENC_PUBLIC_KEY_SIZE); + + if (!send_lossless_group_packet(chat, gconn, packet, sizeof(packet), GP_KEY_ROTATION)) { + return false; + } + + gconn->pending_key_rotation_request = true; + + return true; +} + +/** @brief Sends the group topic to all group members. + * + * Returns true on success. + */ +non_null() +static bool broadcast_gc_topic(const GC_Chat *chat) +{ + const uint16_t packet_buf_size = SIGNATURE_SIZE + chat->topic_info.length + GC_MIN_PACKED_TOPIC_INFO_SIZE; + uint8_t *packet = (uint8_t *)malloc(packet_buf_size); + + if (packet == nullptr) { + return false; + } + + const int packet_len = make_gc_topic_packet(chat, packet, packet_buf_size); + + if (packet_len != packet_buf_size) { + free(packet); + return false; + } + + send_gc_lossless_packet_all_peers(chat, packet, packet_buf_size, GP_TOPIC); + + free(packet); + + return true; +} + +int gc_set_topic(GC_Chat *chat, const uint8_t *topic, uint16_t length) +{ + if (length > MAX_GC_TOPIC_SIZE) { + return -1; + } + + const bool topic_lock_enabled = group_topic_lock_enabled(chat); + + if (topic_lock_enabled && gc_get_self_role(chat) > GR_MODERATOR) { + return -2; + } + + if (gc_get_self_role(chat) > GR_USER) { + return -2; + } + + const GC_TopicInfo old_topic_info = chat->topic_info; + + uint8_t old_topic_sig[SIGNATURE_SIZE]; + memcpy(old_topic_sig, chat->topic_sig, SIGNATURE_SIZE); + + // TODO(jfreegman): improbable, but an overflow would break topic setting + if (chat->topic_info.version == UINT32_MAX) { + return -3; + } + + // only increment topic version when lock is enabled + if (topic_lock_enabled) { + ++chat->topic_info.version; + } + + chat->topic_info.length = length; + + if (length > 0) { + assert(topic != nullptr); + memcpy(chat->topic_info.topic, topic, length); + } else { + memset(chat->topic_info.topic, 0, sizeof(chat->topic_info.topic)); + } + + memcpy(chat->topic_info.public_sig_key, get_sig_pk(chat->self_public_key), SIG_PUBLIC_KEY_SIZE); + + chat->topic_info.checksum = get_gc_topic_checksum(&chat->topic_info); + + const uint16_t packet_buf_size = length + GC_MIN_PACKED_TOPIC_INFO_SIZE; + uint8_t *packed_topic = (uint8_t *)malloc(packet_buf_size); + + if (packed_topic == nullptr) { + return -3; + } + + int err = -3; + + const uint16_t packed_len = pack_gc_topic_info(packed_topic, packet_buf_size, &chat->topic_info); + + if (packed_len != packet_buf_size) { + goto ON_ERROR; + } + + if (crypto_sign_detached(chat->topic_sig, nullptr, packed_topic, packet_buf_size, + get_sig_sk(chat->self_secret_key)) == -1) { + goto ON_ERROR; + } + + if (!broadcast_gc_topic(chat)) { + err = -4; + goto ON_ERROR; + } + + chat->topic_prev_checksum = old_topic_info.checksum; + chat->topic_time_set = mono_time_get(chat->mono_time); + + free(packed_topic); + return 0; + +ON_ERROR: + chat->topic_info = old_topic_info; + memcpy(chat->topic_sig, old_topic_sig, SIGNATURE_SIZE); + free(packed_topic); + return err; +} + +void gc_get_topic(const GC_Chat *chat, uint8_t *topic) +{ + if (topic != nullptr) { + memcpy(topic, chat->topic_info.topic, chat->topic_info.length); + } +} + +uint16_t gc_get_topic_size(const GC_Chat *chat) +{ + return chat->topic_info.length; +} + +/** + * If public_sig_key is equal to the key of the topic setter, replaces topic credentials + * and re-broadcasts the updated topic info to the group. + * + * Returns true on success + */ +non_null() +static bool update_gc_topic(GC_Chat *chat, const uint8_t *public_sig_key) +{ + if (memcmp(public_sig_key, chat->topic_info.public_sig_key, SIG_PUBLIC_KEY_SIZE) != 0) { + return true; + } + + return gc_set_topic(chat, chat->topic_info.topic, chat->topic_info.length) == 0; +} + +/** @brief Validates `topic_info`. + * + * Return true if topic info is valid. + */ +non_null() +static bool handle_gc_topic_validate(const GC_Chat *chat, const GC_Peer *peer, const GC_TopicInfo *topic_info, + bool topic_lock_enabled) +{ + if (topic_info->checksum != get_gc_topic_checksum(topic_info)) { + LOGGER_WARNING(chat->log, "received invalid topic checksum"); + return false; + } + + if (topic_lock_enabled) { + if (!mod_list_verify_sig_pk(&chat->moderation, topic_info->public_sig_key)) { + LOGGER_DEBUG(chat->log, "Invalid topic signature (bad credentials)"); + return false; + } + + if (topic_info->version < chat->topic_info.version) { + return false; + } + } else { + uint8_t public_enc_key[ENC_PUBLIC_KEY_SIZE]; + + if (gc_get_enc_pk_from_sig_pk(chat, public_enc_key, topic_info->public_sig_key)) { + if (sanctions_list_is_observer(&chat->moderation, public_enc_key)) { + LOGGER_DEBUG(chat->log, "Invalid topic signature (sanctioned peer attempted to change topic)"); + return false; + } + } + + if (topic_info->version == chat->shared_state.topic_lock) { + // always accept topic on initial connection + if (!mono_time_is_timeout(chat->mono_time, chat->time_connected, GC_PING_TIMEOUT)) { + return true; + } + + if (chat->topic_prev_checksum == topic_info->checksum && + !mono_time_is_timeout(chat->mono_time, chat->topic_time_set, GC_CONFIRMED_PEER_TIMEOUT)) { + LOGGER_DEBUG(chat->log, "Topic reversion (probable sync error)"); + return false; + } + + return true; + } + + // the topic version should never change when the topic lock is disabled except when + // the founder changes the topic prior to enabling the lock + if (!(peer->role == GR_FOUNDER && topic_info->version == chat->shared_state.topic_lock + 1)) { + LOGGER_ERROR(chat->log, "topic version %u differs from topic lock %u", topic_info->version, + chat->shared_state.topic_lock); + return false; + } + } + + return true; +} + +/** @brief Handles a topic packet. + * + * Return 0 if packet is correctly handled. + * Return -1 if packet has invalid size. + */ +non_null(1, 2, 3, 4) nullable(6) +static int handle_gc_topic(const GC_Session *c, GC_Chat *chat, const GC_Peer *peer, const uint8_t *data, + uint16_t length, void *userdata) +{ + if (length < SIGNATURE_SIZE + GC_MIN_PACKED_TOPIC_INFO_SIZE) { + return -1; + } + + const uint16_t old_checksum = chat->topic_info.checksum; + + GC_TopicInfo topic_info; + + if (unpack_gc_topic_info(&topic_info, data + SIGNATURE_SIZE, length - SIGNATURE_SIZE) == -1) { + LOGGER_WARNING(chat->log, "failed to unpack topic"); + return 0; + } + + const uint8_t *signature = data; + + if (crypto_sign_verify_detached(signature, data + SIGNATURE_SIZE, length - SIGNATURE_SIZE, + topic_info.public_sig_key) == -1) { + LOGGER_WARNING(chat->log, "failed to verify topic signature"); + return 0; + } + + const bool topic_lock_enabled = group_topic_lock_enabled(chat); + + if (!handle_gc_topic_validate(chat, peer, &topic_info, topic_lock_enabled)) { + return 0; + } + + // prevents sync issues from triggering the callback needlessly + const bool skip_callback = chat->topic_info.length == topic_info.length + && memcmp(chat->topic_info.topic, topic_info.topic, topic_info.length) == 0; + + chat->topic_prev_checksum = old_checksum; + chat->topic_time_set = mono_time_get(chat->mono_time); + chat->topic_info = topic_info; + memcpy(chat->topic_sig, signature, SIGNATURE_SIZE); + + if (!skip_callback && chat->connection_state == CS_CONNECTED && c->topic_change != nullptr) { + const int setter_peer_number = get_peer_number_of_sig_pk(chat, topic_info.public_sig_key); + const uint32_t peer_id = setter_peer_number >= 0 ? chat->group[setter_peer_number].peer_id : 0; + + c->topic_change(c->messenger, chat->group_number, peer_id, topic_info.topic, topic_info.length, userdata); + } + + return 0; +} + +/** @brief Handles a key exchange packet. + * + * Return 0 if packet is handled correctly. + * Return -1 if length is invalid. + * Return -2 if we fail to create a new session keypair. + * Return -3 if response packet fails to send. + */ +non_null() +static int handle_gc_key_exchange(const GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, uint16_t length) +{ + if (length < 1 + ENC_PUBLIC_KEY_SIZE) { + return -1; + } + + bool is_response; + net_unpack_bool(&data[0], &is_response); + + const uint8_t *sender_public_session_key = data + 1; + + if (is_response) { + if (!gconn->pending_key_rotation_request) { + LOGGER_WARNING(chat->log, "got unsolicited key rotation response from peer %u", gconn->public_key_hash); + return 0; + } + + // now that we have response we can compute our new shared key and begin using it + gcc_make_session_shared_key(gconn, sender_public_session_key); + + gconn->pending_key_rotation_request = false; + + return 0; + } + + // key generation is pretty cpu intensive so we make sure a peer can't DOS us by spamming requests + if (!mono_time_is_timeout(chat->mono_time, gconn->last_key_rotation, GC_KEY_ROTATION_TIMEOUT / 2)) { + return 0; + } + + uint8_t response[1 + ENC_PUBLIC_KEY_SIZE]; + uint8_t new_session_pk[ENC_PUBLIC_KEY_SIZE]; + uint8_t new_session_sk[ENC_SECRET_KEY_SIZE]; + + net_pack_bool(&response[0], true); + + crypto_memlock(new_session_sk, sizeof(new_session_sk)); + + create_gc_session_keypair(chat->log, chat->rng, new_session_pk, new_session_sk); + + memcpy(response + 1, new_session_pk, ENC_PUBLIC_KEY_SIZE); + + if (!send_lossless_group_packet(chat, gconn, response, sizeof(response), GP_KEY_ROTATION)) { + return -3; + } + + // save new keys and compute new shared key AFTER sending response packet with old key + memcpy(gconn->session_public_key, new_session_pk, sizeof(gconn->session_public_key)); + memcpy(gconn->session_secret_key, new_session_sk, sizeof(gconn->session_secret_key)); + + gcc_make_session_shared_key(gconn, sender_public_session_key); + + crypto_memunlock(new_session_sk, sizeof(new_session_sk)); + + gconn->last_key_rotation = mono_time_get(chat->mono_time); + + return 0; +} + +void gc_get_group_name(const GC_Chat *chat, uint8_t *group_name) +{ + if (group_name != nullptr) { + memcpy(group_name, chat->shared_state.group_name, chat->shared_state.group_name_len); + } +} + +uint16_t gc_get_group_name_size(const GC_Chat *chat) +{ + return chat->shared_state.group_name_len; +} + +void gc_get_password(const GC_Chat *chat, uint8_t *password) +{ + if (password != nullptr) { + memcpy(password, chat->shared_state.password, chat->shared_state.password_length); + } +} + +uint16_t gc_get_password_size(const GC_Chat *chat) +{ + return chat->shared_state.password_length; +} + +int gc_founder_set_password(GC_Chat *chat, const uint8_t *password, uint16_t password_length) +{ + if (!self_gc_is_founder(chat)) { + return -1; + } + + uint8_t *oldpasswd = nullptr; + const uint16_t oldlen = chat->shared_state.password_length; + + if (oldlen > 0) { + oldpasswd = (uint8_t *)malloc(oldlen); + + if (oldpasswd == nullptr) { + return -4; + } + + memcpy(oldpasswd, chat->shared_state.password, oldlen); + } + + if (!set_gc_password_local(chat, password, password_length)) { + free(oldpasswd); + return -2; + } + + if (!sign_gc_shared_state(chat)) { + set_gc_password_local(chat, oldpasswd, oldlen); + free(oldpasswd); + return -2; + } + + free(oldpasswd); + + if (!broadcast_gc_shared_state(chat)) { + return -3; + } + + return 0; +} + +/** @brief Validates change to moderator list and either adds or removes peer from our moderator list. + * + * Return target's peer number on success. + * Return -1 on packet handle failure. + * Return -2 if target peer is not online. + * Return -3 if target peer is not a valid role (probably indicates sync issues). + * Return -4 on validation failure. + */ +non_null() +static int validate_unpack_gc_set_mod(GC_Chat *chat, uint32_t peer_number, const uint8_t *data, uint16_t length, + bool add_mod) +{ + int target_peer_number; + uint8_t mod_data[MOD_LIST_ENTRY_SIZE]; + + if (add_mod) { + if (length < 1 + MOD_LIST_ENTRY_SIZE) { + return -1; + } + + memcpy(mod_data, data + 1, MOD_MODERATION_HASH_SIZE); + target_peer_number = get_peer_number_of_sig_pk(chat, mod_data); + + if (!gc_peer_number_is_valid(chat, target_peer_number)) { + return -2; + } + + const Group_Role target_role = chat->group[target_peer_number].role; + + if (target_role != GR_USER) { + return -3; + } + + if (!mod_list_add_entry(&chat->moderation, mod_data)) { + return -4; + } + } else { + memcpy(mod_data, data + 1, SIG_PUBLIC_KEY_SIZE); + target_peer_number = get_peer_number_of_sig_pk(chat, mod_data); + + if (!gc_peer_number_is_valid(chat, target_peer_number)) { + return -2; + } + + const Group_Role target_role = chat->group[target_peer_number].role; + + if (target_role != GR_MODERATOR) { + return -3; + } + + if (!mod_list_remove_entry(&chat->moderation, mod_data)) { + return -4; + } + } + + update_gc_peer_roles(chat); + + return target_peer_number; +} + +/** @brief Handles a moderator set broadcast. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + * Return -2 if the packet contains invalid data. + * Return -3 if `peer_number` does not designate a valid peer. + */ +non_null(1, 2, 4) nullable(6) +static int handle_gc_set_mod(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, const uint8_t *data, + uint16_t length, void *userdata) +{ + if (length < 1 + SIG_PUBLIC_KEY_SIZE) { + return -1; + } + + const GC_Peer *setter_peer = get_gc_peer(chat, peer_number); + + if (setter_peer == nullptr) { + return -3; + } + + if (setter_peer->role != GR_FOUNDER) { + return 0; + } + + bool add_mod; + net_unpack_bool(&data[0], &add_mod); + + const int target_peer_number = validate_unpack_gc_set_mod(chat, peer_number, data, length, add_mod); + + if (target_peer_number == -1) { + return -2; + } + + const GC_Peer *target_peer = get_gc_peer(chat, target_peer_number); + + if (target_peer == nullptr) { + return 0; + } + + if (c->moderation != nullptr) { + c->moderation(c->messenger, chat->group_number, setter_peer->peer_id, target_peer->peer_id, + add_mod ? MV_MOD : MV_USER, userdata); + } + + return 0; +} + +/** @brief Sends a set mod broadcast to the group. + * + * Return true on success. + */ +non_null() +static bool send_gc_set_mod(const GC_Chat *chat, const GC_Connection *gconn, bool add_mod) +{ + const uint16_t length = 1 + SIG_PUBLIC_KEY_SIZE; + uint8_t *data = (uint8_t *)malloc(length); + + if (data == nullptr) { + return false; + } + + net_pack_bool(&data[0], add_mod); + + memcpy(data + 1, get_sig_pk(gconn->addr.public_key), SIG_PUBLIC_KEY_SIZE); + + if (!send_gc_broadcast_message(chat, data, length, GM_SET_MOD)) { + free(data); + return false; + } + + free(data); + + return true; +} + +/** + * Adds or removes the peer designated by gconn from moderator list if `add_mod` is true or false respectively. + * Re-signs and re-distributes an updated mod_list hash. + * + * Returns true on success. + */ +non_null() +static bool founder_gc_set_moderator(GC_Chat *chat, const GC_Connection *gconn, bool add_mod) +{ + if (!self_gc_is_founder(chat)) { + return false; + } + + if (add_mod) { + if (chat->moderation.num_mods >= MOD_MAX_NUM_MODERATORS) { + if (!prune_gc_mod_list(chat)) { + return false; + } + } + + if (!mod_list_add_entry(&chat->moderation, get_sig_pk(gconn->addr.public_key))) { + return false; + } + } else { + if (!mod_list_remove_entry(&chat->moderation, get_sig_pk(gconn->addr.public_key))) { + return false; + } + + if (!update_gc_sanctions_list(chat, get_sig_pk(gconn->addr.public_key)) + || !update_gc_topic(chat, get_sig_pk(gconn->addr.public_key))) { + return false; + } + } + + uint8_t old_hash[MOD_MODERATION_HASH_SIZE]; + memcpy(old_hash, chat->shared_state.mod_list_hash, MOD_MODERATION_HASH_SIZE); + + if (!mod_list_make_hash(&chat->moderation, chat->shared_state.mod_list_hash)) { + return false; + } + + if (!sign_gc_shared_state(chat) || !broadcast_gc_shared_state(chat)) { + memcpy(chat->shared_state.mod_list_hash, old_hash, MOD_MODERATION_HASH_SIZE); + return false; + } + + return send_gc_set_mod(chat, gconn, add_mod); +} + +/** @brief Validates `data` containing a change for the sanction list and unpacks it + * into the sanctions list for `chat`. + * + * if `add_obs` is true we're adding an observer to the list. + * + * Return 1 if sanctions list is not modified. + * Return 0 if data is valid and sanctions list is successfully modified. + * Return -1 if data is invalid format. + */ +non_null() +static int validate_unpack_observer_entry(GC_Chat *chat, const uint8_t *data, uint16_t length, + const uint8_t *public_key, bool add_obs) +{ + Mod_Sanction_Creds creds; + + if (add_obs) { + Mod_Sanction sanction; + + if (sanctions_list_unpack(&sanction, &creds, 1, data, length, nullptr) != 1) { + return -1; + } + + // this may occur if two mods change the sanctions list at the exact same time + if (creds.version == chat->moderation.sanctions_creds.version + && creds.checksum <= chat->moderation.sanctions_creds.checksum) { + return 1; + } + + if (sanctions_list_entry_exists(&chat->moderation, &sanction) + || !sanctions_list_add_entry(&chat->moderation, &sanction, &creds)) { + return -1; + } + } else { + if (length < MOD_SANCTIONS_CREDS_SIZE) { + return -1; + } + + if (sanctions_creds_unpack(&creds, data) != MOD_SANCTIONS_CREDS_SIZE) { + return -1; + } + + if (creds.version == chat->moderation.sanctions_creds.version + && creds.checksum <= chat->moderation.sanctions_creds.checksum) { + return 1; + } + + if (!sanctions_list_is_observer(&chat->moderation, public_key) + || !sanctions_list_remove_observer(&chat->moderation, public_key, &creds)) { + return 1; + } + } + + return 0; +} + +/** @brief Handles a set observer broadcast. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + * Return -2 if the packet contains invalid data. + * Return -3 if `peer_number` does not designate a valid peer. + */ +non_null(1, 2, 4) nullable(6) +static int handle_gc_set_observer(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, const uint8_t *data, + uint16_t length, void *userdata) +{ + if (length <= 1 + EXT_PUBLIC_KEY_SIZE) { + return -1; + } + + const GC_Peer *setter_peer = get_gc_peer(chat, peer_number); + + if (setter_peer == nullptr) { + return -3; + } + + if (setter_peer->role > GR_MODERATOR) { + LOGGER_DEBUG(chat->log, "peer with insufficient permissions tried to modify sanctions list"); + return 0; + } + + bool add_obs; + net_unpack_bool(&data[0], &add_obs); + + const uint8_t *public_key = data + 1; + + const int target_peer_number = get_peer_number_of_enc_pk(chat, public_key, false); + + if (target_peer_number >= 0 && (uint32_t)target_peer_number == peer_number) { + return -2; + } + + const GC_Peer *target_peer = get_gc_peer(chat, target_peer_number); + + if (target_peer != nullptr) { + if ((add_obs && target_peer->role != GR_USER) || (!add_obs && target_peer->role != GR_OBSERVER)) { + return 0; + } + } + + const int ret = validate_unpack_observer_entry(chat, + data + 1 + EXT_PUBLIC_KEY_SIZE, + length - 1 - EXT_PUBLIC_KEY_SIZE, + public_key, add_obs); + + if (ret == -1) { + return -2; + } + + + if (ret == 1) { + return 0; + } + + update_gc_peer_roles(chat); + + if (target_peer != nullptr) { + if (c->moderation != nullptr) { + c->moderation(c->messenger, chat->group_number, setter_peer->peer_id, target_peer->peer_id, + add_obs ? MV_OBSERVER : MV_USER, userdata); + } + } + + return 0; +} + +/** @brief Broadcasts observer role data to the group. + * + * Returns true on success. + */ +non_null() +static bool send_gc_set_observer(const GC_Chat *chat, const uint8_t *target_ext_pk, const uint8_t *sanction_data, + uint16_t length, bool add_obs) +{ + const uint16_t packet_len = 1 + EXT_PUBLIC_KEY_SIZE + length; + uint8_t *packet = (uint8_t *)malloc(packet_len); + + if (packet == nullptr) { + return false; + } + + net_pack_bool(&packet[0], add_obs); + + memcpy(packet + 1, target_ext_pk, EXT_PUBLIC_KEY_SIZE); + memcpy(packet + 1 + EXT_PUBLIC_KEY_SIZE, sanction_data, length); + + if (!send_gc_broadcast_message(chat, packet, packet_len, GM_SET_OBSERVER)) { + free(packet); + return false; + } + + free(packet); + + return true; +} + +/** @brief Adds or removes peer_number from the observer list if add_obs is true or false respectively. + * Broadcasts this change to the entire group. + * + * Returns true on success. + */ +non_null() +static bool mod_gc_set_observer(GC_Chat *chat, uint32_t peer_number, bool add_obs) +{ + const GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return false; + } + + if (gc_get_self_role(chat) >= GR_USER) { + return false; + } + + uint8_t sanction_data[MOD_SANCTION_PACKED_SIZE + MOD_SANCTIONS_CREDS_SIZE]; + uint16_t length = 0; + + if (add_obs) { + if (chat->moderation.num_sanctions >= MOD_MAX_NUM_SANCTIONS) { + if (!prune_gc_sanctions_list(chat)) { + return false; + } + } + + // if sanctioned peer set the topic we need to overwrite his signature and redistribute + // topic info + const int setter_peer_number = get_peer_number_of_sig_pk(chat, chat->topic_info.public_sig_key); + + if (setter_peer_number >= 0 && (uint32_t)setter_peer_number == peer_number) { + if (gc_set_topic(chat, chat->topic_info.topic, chat->topic_info.length) != 0) { + return false; + } + } + + Mod_Sanction sanction; + + if (!sanctions_list_make_entry(&chat->moderation, gconn->addr.public_key, &sanction, SA_OBSERVER)) { + LOGGER_WARNING(chat->log, "sanctions_list_make_entry failed in mod_gc_set_observer"); + return false; + } + + const int packed_len = sanctions_list_pack(sanction_data, sizeof(sanction_data), &sanction, 1, + &chat->moderation.sanctions_creds); + + if (packed_len == -1) { + return false; + } + + length += packed_len; + } else { + if (!sanctions_list_remove_observer(&chat->moderation, gconn->addr.public_key, nullptr)) { + LOGGER_WARNING(chat->log, "failed to remove sanction"); + return false; + } + + const uint16_t packed_len = sanctions_creds_pack(&chat->moderation.sanctions_creds, sanction_data); + + if (packed_len != MOD_SANCTIONS_CREDS_SIZE) { + return false; + } + + length += packed_len; + } + + if (length > sizeof(sanction_data)) { + LOGGER_FATAL(chat->log, "Invalid sanction data length: %u", length); + return false; + } + + update_gc_peer_roles(chat); + + return send_gc_set_observer(chat, gconn->addr.public_key, sanction_data, length, add_obs); +} + +/** @brief Sets the role of `peer_number` to `new_role`. If necessary this function will first + * remove the peer's current role before applying the new one. + * + * Return true on success. + */ +non_null() +static bool apply_new_gc_role(GC_Chat *chat, uint32_t peer_number, Group_Role current_role, Group_Role new_role) +{ + const GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return false; + } + + switch (current_role) { + case GR_MODERATOR: { + if (!founder_gc_set_moderator(chat, gconn, false)) { + return false; + } + + update_gc_peer_roles(chat); + + if (new_role == GR_OBSERVER) { + return mod_gc_set_observer(chat, peer_number, true); + } + + break; + } + + case GR_OBSERVER: { + if (!mod_gc_set_observer(chat, peer_number, false)) { + return false; + } + + update_gc_peer_roles(chat); + + if (new_role == GR_MODERATOR) { + return founder_gc_set_moderator(chat, gconn, true); + } + + break; + } + + case GR_USER: { + if (new_role == GR_MODERATOR) { + return founder_gc_set_moderator(chat, gconn, true); + } else if (new_role == GR_OBSERVER) { + return mod_gc_set_observer(chat, peer_number, true); + } + + break; + } + + case GR_FOUNDER: + + // Intentional fallthrough + default: { + return false; + } + } + + return true; +} + +int gc_set_peer_role(const Messenger *m, int group_number, uint32_t peer_id, Group_Role new_role) +{ + const GC_Session *c = m->group_handler; + GC_Chat *chat = gc_get_group(c, group_number); + + if (chat == nullptr) { + return -1; + } + + const int peer_number = get_peer_number_of_peer_id(chat, peer_id); + + const GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return -2; + } + + const GC_Connection *gconn = &peer->gconn; + + if (!gconn->confirmed) { + return -2; + } + + const Group_Role current_role = peer->role; + + if (new_role == GR_FOUNDER || peer->role == new_role) { + return -4; + } + + if (peer_number_is_self(peer_number)) { + return -6; + } + + if (current_role == GR_FOUNDER || gc_get_self_role(chat) >= GR_USER) { + return -3; + } + + // moderators can't demote moderators or promote peers to moderator + if (!self_gc_is_founder(chat) && (new_role == GR_MODERATOR || current_role == GR_MODERATOR)) { + return -3; + } + + if (!apply_new_gc_role(chat, peer_number, current_role, new_role)) { + return -5; + } + + update_gc_peer_roles(chat); + + return 0; +} + +/** @brief Return true if topic lock is enabled */ +non_null() +static bool group_topic_lock_enabled(const GC_Chat *chat) +{ + return chat->shared_state.topic_lock == GC_TOPIC_LOCK_ENABLED; +} + +Group_Privacy_State gc_get_privacy_state(const GC_Chat *chat) +{ + return chat->shared_state.privacy_state; +} + +Group_Topic_Lock gc_get_topic_lock_state(const GC_Chat *chat) +{ + return group_topic_lock_enabled(chat) ? TL_ENABLED : TL_DISABLED; +} + +Group_Voice_State gc_get_voice_state(const GC_Chat *chat) +{ + return chat->shared_state.voice_state; +} + +int gc_founder_set_topic_lock(const Messenger *m, int group_number, Group_Topic_Lock new_lock_state) +{ + const GC_Session *c = m->group_handler; + GC_Chat *chat = gc_get_group(c, group_number); + + if (chat == nullptr) { + return -1; + } + + if (new_lock_state > TL_DISABLED) { + return -2; + } + + if (!self_gc_is_founder(chat)) { + return -3; + } + + if (chat->connection_state <= CS_DISCONNECTED) { + return -4; + } + + const Group_Topic_Lock old_lock_state = gc_get_topic_lock_state(chat); + + if (new_lock_state == old_lock_state) { + return 0; + } + + const uint32_t old_topic_lock = chat->shared_state.topic_lock; + + // If we're enabling the lock the founder needs to sign the current topic and re-broadcast + // it with a new version. This needs to happen before we re-broadcast the shared state because + // if it fails we don't want to enable the topic lock with an invalid topic signature or version. + if (new_lock_state == TL_ENABLED) { + chat->shared_state.topic_lock = GC_TOPIC_LOCK_ENABLED; + + if (gc_set_topic(chat, chat->topic_info.topic, chat->topic_info.length) != 0) { + chat->shared_state.topic_lock = old_topic_lock; + return -6; + } + } else { + chat->shared_state.topic_lock = chat->topic_info.version; + } + + if (!sign_gc_shared_state(chat)) { + chat->shared_state.topic_lock = old_topic_lock; + return -5; + } + + if (!broadcast_gc_shared_state(chat)) { + return -6; + } + + return 0; +} + +int gc_founder_set_voice_state(const Messenger *m, int group_number, Group_Voice_State new_voice_state) +{ + const GC_Session *c = m->group_handler; + GC_Chat *chat = gc_get_group(c, group_number); + + if (chat == nullptr) { + return -1; + } + + if (!self_gc_is_founder(chat)) { + return -2; + } + + if (chat->connection_state == CS_DISCONNECTED || chat->connection_state == CS_NONE) { + return -3; + } + + const Group_Voice_State old_voice_state = chat->shared_state.voice_state; + + if (new_voice_state == old_voice_state) { + return 0; + } + + chat->shared_state.voice_state = new_voice_state; + + if (!sign_gc_shared_state(chat)) { + chat->shared_state.voice_state = old_voice_state; + return -4; + } + + if (!broadcast_gc_shared_state(chat)) { + return -5; + } + + return 0; +} + +int gc_founder_set_privacy_state(const Messenger *m, int group_number, Group_Privacy_State new_privacy_state) +{ + const GC_Session *c = m->group_handler; + GC_Chat *chat = gc_get_group(c, group_number); + + if (chat == nullptr) { + return -1; + } + + if (!self_gc_is_founder(chat)) { + return -2; + } + + if (chat->connection_state == CS_DISCONNECTED || chat->connection_state == CS_NONE) { + return -3; + } + + const Group_Privacy_State old_privacy_state = chat->shared_state.privacy_state; + + if (new_privacy_state == old_privacy_state) { + return 0; + } + + chat->shared_state.privacy_state = new_privacy_state; + + if (!sign_gc_shared_state(chat)) { + chat->shared_state.privacy_state = old_privacy_state; + return -4; + } + + if (new_privacy_state == GI_PRIVATE) { + cleanup_gca(c->announces_list, get_chat_id(chat->chat_public_key)); + kill_group_friend_connection(c, chat); + chat->join_type = HJ_PRIVATE; + } else { + if (!m_create_group_connection(c->messenger, chat)) { + LOGGER_ERROR(chat->log, "Failed to initialize group friend connection"); + } else { + chat->update_self_announces = true; + chat->join_type = HJ_PUBLIC; + } + } + + if (!broadcast_gc_shared_state(chat)) { + return -5; + } + + return 0; +} + +uint16_t gc_get_max_peers(const GC_Chat *chat) +{ + return chat->shared_state.maxpeers; +} + +int gc_founder_set_max_peers(GC_Chat *chat, uint16_t max_peers) +{ + if (!self_gc_is_founder(chat)) { + return -1; + } + + const uint16_t old_maxpeers = chat->shared_state.maxpeers; + + if (max_peers == chat->shared_state.maxpeers) { + return 0; + } + + chat->shared_state.maxpeers = max_peers; + + if (!sign_gc_shared_state(chat)) { + chat->shared_state.maxpeers = old_maxpeers; + return -2; + } + + if (!broadcast_gc_shared_state(chat)) { + return -3; + } + + return 0; +} + +int gc_send_message(const GC_Chat *chat, const uint8_t *message, uint16_t length, uint8_t type, uint32_t *message_id) +{ + if (length > MAX_GC_MESSAGE_SIZE) { + return -1; + } + + if (message == nullptr || length == 0) { + return -2; + } + + if (type != GC_MESSAGE_TYPE_NORMAL && type != GC_MESSAGE_TYPE_ACTION) { + return -3; + } + + const GC_Peer *self = get_gc_peer(chat, 0); + assert(self != nullptr); + + if (gc_get_self_role(chat) >= GR_OBSERVER || !peer_has_voice(self, chat->shared_state.voice_state)) { + return -4; + } + + const uint8_t packet_type = type == GC_MESSAGE_TYPE_NORMAL ? GM_PLAIN_MESSAGE : GM_ACTION_MESSAGE; + + const uint16_t length_raw = length + GC_MESSAGE_PSEUDO_ID_SIZE; + uint8_t *message_raw = (uint8_t *)malloc(length_raw); + + if (message_raw == nullptr) { + return -5; + } + + const uint32_t pseudo_msg_id = random_u32(chat->rng); + + net_pack_u32(message_raw, pseudo_msg_id); + memcpy(message_raw + GC_MESSAGE_PSEUDO_ID_SIZE, message, length); + + if (!send_gc_broadcast_message(chat, message_raw, length_raw, packet_type)) { + free(message_raw); + return -5; + } + + if (message_id != nullptr) { + *message_id = pseudo_msg_id; + } + + free(message_raw); + return 0; +} + +/** @brief Handles a message broadcast. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + */ +non_null(1, 2, 3, 4) nullable(7) +static int handle_gc_message(const GC_Session *c, const GC_Chat *chat, const GC_Peer *peer, const uint8_t *data, + uint16_t length, uint8_t type, void *userdata) +{ + if (data == nullptr || length > MAX_GC_MESSAGE_RAW_SIZE || length <= GC_MESSAGE_PSEUDO_ID_SIZE) { + return -1; + } + + if (peer->ignore || peer->role >= GR_OBSERVER || !peer_has_voice(peer, chat->shared_state.voice_state)) { + return 0; + } + + if (type != GM_PLAIN_MESSAGE && type != GM_ACTION_MESSAGE) { + LOGGER_WARNING(chat->log, "received invalid message type: %u", type); + return 0; + } + + const uint8_t cb_type = (type == GM_PLAIN_MESSAGE) ? MESSAGE_NORMAL : MESSAGE_ACTION; + + uint32_t pseudo_msg_id; + net_unpack_u32(data, &pseudo_msg_id); + + if (c->message != nullptr) { + c->message(c->messenger, chat->group_number, peer->peer_id, cb_type, data + GC_MESSAGE_PSEUDO_ID_SIZE, + length - GC_MESSAGE_PSEUDO_ID_SIZE, pseudo_msg_id, userdata); + } + + return 0; +} + +int gc_send_private_message(const GC_Chat *chat, uint32_t peer_id, uint8_t type, const uint8_t *message, + uint16_t length) +{ + if (length > MAX_GC_MESSAGE_SIZE) { + return -1; + } + + if (message == nullptr || length == 0) { + return -2; + } + + const int peer_number = get_peer_number_of_peer_id(chat, peer_id); + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return -3; + } + + if (type > MESSAGE_ACTION) { + return -4; + } + + if (gc_get_self_role(chat) >= GR_OBSERVER) { + return -5; + } + + uint8_t *message_with_type = (uint8_t *)malloc(length + 1); + + if (message_with_type == nullptr) { + return -6; + } + + message_with_type[0] = type; + memcpy(message_with_type + 1, message, length); + + uint8_t *packet = (uint8_t *)malloc(length + 1 + GC_BROADCAST_ENC_HEADER_SIZE); + + if (packet == nullptr) { + free(message_with_type); + return -6; + } + + const uint16_t packet_len = make_gc_broadcast_header(message_with_type, length + 1, packet, GM_PRIVATE_MESSAGE); + + free(message_with_type); + + if (!send_lossless_group_packet(chat, gconn, packet, packet_len, GP_BROADCAST)) { + free(packet); + return -6; + } + + free(packet); + + return 0; +} + +/** @brief Handles a private message. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + */ +non_null(1, 2, 3, 4) nullable(6) +static int handle_gc_private_message(const GC_Session *c, const GC_Chat *chat, const GC_Peer *peer, const uint8_t *data, + uint16_t length, void *userdata) +{ + if (data == nullptr || length > MAX_GC_MESSAGE_SIZE || length <= 1) { + return -1; + } + + if (peer->ignore || peer->role >= GR_OBSERVER) { + return 0; + } + + const uint8_t message_type = data[0]; + + if (message_type > MESSAGE_ACTION) { + LOGGER_WARNING(chat->log, "Received invalid private message type: %u", message_type); + return 0; + } + + if (c->private_message != nullptr) { + c->private_message(c->messenger, chat->group_number, peer->peer_id, message_type, data + 1, length - 1, userdata); + } + + return 0; +} + +/** @brief Returns false if a custom packet is too large. */ +static bool custom_gc_packet_length_is_valid(uint16_t length, bool lossless) +{ + if (lossless) { + if (length > MAX_GC_CUSTOM_LOSSLESS_PACKET_SIZE) { + return false; + } + } else { + if (length > MAX_GC_CUSTOM_LOSSY_PACKET_SIZE) { + return false; + } + } + + return true; +} + +int gc_send_custom_private_packet(const GC_Chat *chat, bool lossless, uint32_t peer_id, const uint8_t *message, + uint16_t length) +{ + if (!custom_gc_packet_length_is_valid(length, lossless)) { + return -1; + } + + if (message == nullptr || length == 0) { + return -2; + } + + const int peer_number = get_peer_number_of_peer_id(chat, peer_id); + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return -3; + } + + if (gc_get_self_role(chat) >= GR_OBSERVER) { + return -4; + } + + bool ret; + + if (lossless) { + ret = send_lossless_group_packet(chat, gconn, message, length, GP_CUSTOM_PRIVATE_PACKET); + } else { + ret = send_lossy_group_packet(chat, gconn, message, length, GP_CUSTOM_PRIVATE_PACKET); + } + + return ret ? 0 : -5; +} + + + +/** @brief Handles a custom private packet. + * + * @retval 0 if packet is handled correctly. + * @retval -1 if packet has invalid size. + */ +non_null(1, 2, 3, 4) nullable(7) +static int handle_gc_custom_private_packet(const GC_Session *c, const GC_Chat *chat, const GC_Peer *peer, + const uint8_t *data, uint16_t length, bool lossless, void *userdata) +{ + if (!custom_gc_packet_length_is_valid(length, lossless)) { + return -1; + } + + if (data == nullptr || length == 0) { + return -1; + } + + if (peer->ignore || peer->role >= GR_OBSERVER) { + return 0; + } + + if (c->custom_private_packet != nullptr) { + c->custom_private_packet(c->messenger, chat->group_number, peer->peer_id, data, length, userdata); + } + + return 0; +} + +int gc_send_custom_packet(const GC_Chat *chat, bool lossless, const uint8_t *data, uint16_t length) +{ + if (!custom_gc_packet_length_is_valid(length, lossless)) { + return -1; + } + + if (data == nullptr || length == 0) { + return -2; + } + + if (gc_get_self_role(chat) >= GR_OBSERVER) { + return -3; + } + + if (lossless) { + send_gc_lossless_packet_all_peers(chat, data, length, GP_CUSTOM_PACKET); + } else { + send_gc_lossy_packet_all_peers(chat, data, length, GP_CUSTOM_PACKET); + } + + return 0; +} + +/** @brief Handles a custom packet. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + */ +non_null(1, 2, 3, 4) nullable(7) +static int handle_gc_custom_packet(const GC_Session *c, const GC_Chat *chat, const GC_Peer *peer, const uint8_t *data, + uint16_t length, bool lossless, void *userdata) +{ + if (!custom_gc_packet_length_is_valid(length, lossless)) { + return -1; + } + + if (data == nullptr || length == 0) { + return -1; + } + + if (peer->ignore || peer->role >= GR_OBSERVER) { + return 0; + } + + if (c->custom_packet != nullptr) { + c->custom_packet(c->messenger, chat->group_number, peer->peer_id, data, length, userdata); + } + + return 0; +} + +/** @brief Handles a peer kick broadcast. + * + * Return 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + */ +non_null(1, 2, 3, 4) nullable(6) +static int handle_gc_kick_peer(const GC_Session *c, GC_Chat *chat, const GC_Peer *setter_peer, const uint8_t *data, + uint16_t length, void *userdata) +{ + if (length < ENC_PUBLIC_KEY_SIZE) { + return -1; + } + + if (setter_peer->role >= GR_USER) { + return 0; + } + + const uint8_t *target_pk = data; + + const int target_peer_number = get_peer_number_of_enc_pk(chat, target_pk, false); + GC_Peer *target_peer = get_gc_peer(chat, target_peer_number); + + if (target_peer != nullptr) { + if (target_peer->role != GR_USER) { + return 0; + } + } + + if (peer_number_is_self(target_peer_number)) { + assert(target_peer != nullptr); + + for (uint32_t i = 1; i < chat->numpeers; ++i) { + GC_Connection *gconn = get_gc_connection(chat, i); + assert(gconn != nullptr); + + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_SELF_DISCONNECTED, nullptr, 0); + } + + chat->connection_state = CS_DISCONNECTED; + + if (c->moderation != nullptr) { + c->moderation(c->messenger, chat->group_number, setter_peer->peer_id, target_peer->peer_id, + MV_KICK, userdata); + } + + return 0; + } + + if (target_peer == nullptr) { /** we don't need to/can't kick a peer that isn't in our peerlist */ + return 0; + } + + gcc_mark_for_deletion(&target_peer->gconn, chat->tcp_conn, GC_EXIT_TYPE_KICKED, nullptr, 0); + + if (c->moderation != nullptr) { + c->moderation(c->messenger, chat->group_number, setter_peer->peer_id, target_peer->peer_id, MV_KICK, userdata); + } + + return 0; +} + +/** @brief Sends a packet to instruct all peers to remove gconn from their peerlist. + * + * Returns true on success. + */ +non_null() +static bool send_gc_kick_peer(const GC_Chat *chat, const GC_Connection *gconn) +{ + uint8_t packet[ENC_PUBLIC_KEY_SIZE]; + memcpy(packet, gconn->addr.public_key, ENC_PUBLIC_KEY_SIZE); + + return send_gc_broadcast_message(chat, packet, ENC_PUBLIC_KEY_SIZE, GM_KICK_PEER); +} + +int gc_kick_peer(const Messenger *m, int group_number, uint32_t peer_id) +{ + const GC_Session *c = m->group_handler; + GC_Chat *chat = gc_get_group(c, group_number); + + if (chat == nullptr) { + return -1; + } + + const int peer_number = get_peer_number_of_peer_id(chat, peer_id); + + if (peer_number_is_self(peer_number)) { + return -6; + } + + GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return -2; + } + + if (gc_get_self_role(chat) >= GR_USER || peer->role == GR_FOUNDER) { + return -3; + } + + if (!self_gc_is_founder(chat) && peer->role == GR_MODERATOR) { + return -3; + } + + if (peer->role == GR_MODERATOR || peer->role == GR_OBSERVER) { + // this first removes peer from any lists they're on and broadcasts new lists to group + if (gc_set_peer_role(c->messenger, chat->group_number, peer_id, GR_USER) < 0) { + return -4; + } + } + + if (!send_gc_kick_peer(chat, &peer->gconn)) { + return -5; + } + + gcc_mark_for_deletion(&peer->gconn, chat->tcp_conn, GC_EXIT_TYPE_NO_CALLBACK, nullptr, 0); + + return 0; +} + +bool gc_send_message_ack(const GC_Chat *chat, GC_Connection *gconn, uint64_t message_id, Group_Message_Ack_Type type) +{ + if (gconn->pending_delete) { + return true; + } + + if (type == GR_ACK_REQ) { + const uint64_t tm = mono_time_get(chat->mono_time); + + if (gconn->last_requested_packet_time == tm) { + return true; + } + + gconn->last_requested_packet_time = tm; + } else if (type != GR_ACK_RECV) { + return false; + } + + uint8_t data[GC_LOSSLESS_ACK_PACKET_SIZE]; + data[0] = (uint8_t) type; + net_pack_u64(data + 1, message_id); + + return send_lossy_group_packet(chat, gconn, data, GC_LOSSLESS_ACK_PACKET_SIZE, GP_MESSAGE_ACK); +} + +/** @brief Handles a lossless message acknowledgement. + * + * If the type is GR_ACK_RECV we remove the packet from our + * send array. If the type is GR_ACK_REQ we re-send the packet + * associated with the requested message_id. + * + * Returns 0 if packet is handled correctly. + * Return -1 if packet has invalid size. + * Return -2 if we failed to handle the ack (may be caused by connection issues). + * Return -3 if we failed to re-send a requested packet. + */ +non_null() +static int handle_gc_message_ack(const GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, uint16_t length) +{ + if (length < GC_LOSSLESS_ACK_PACKET_SIZE) { + return -1; + } + + uint64_t message_id; + net_unpack_u64(data + 1, &message_id); + + const Group_Message_Ack_Type type = (Group_Message_Ack_Type) data[0]; + + if (type == GR_ACK_RECV) { + if (!gcc_handle_ack(chat->log, gconn, message_id)) { + return -2; + } + + return 0; + } + + if (type != GR_ACK_REQ) { + return 0; + } + + const uint64_t tm = mono_time_get(chat->mono_time); + const uint16_t idx = gcc_get_array_index(message_id); + + /* re-send requested packet */ + if (gconn->send_array[idx].message_id == message_id) { + if (gcc_encrypt_and_send_lossless_packet(chat, gconn, gconn->send_array[idx].data, + gconn->send_array[idx].data_length, + gconn->send_array[idx].message_id, + gconn->send_array[idx].packet_type)) { + gconn->send_array[idx].last_send_try = tm; + LOGGER_DEBUG(chat->log, "Re-sent requested packet %llu", (unsigned long long)message_id); + } else { + return -3; + } + } + + return 0; +} + +/** @brief Sends a handshake response ack to peer. + * + * Return true on success. + */ +non_null() +static bool send_gc_hs_response_ack(const GC_Chat *chat, GC_Connection *gconn) +{ + return send_lossless_group_packet(chat, gconn, nullptr, 0, GP_HS_RESPONSE_ACK); +} + +/** @brief Handles a handshake response ack. + * + * Return 0 if packet is handled correctly. + * Return -1 if we failed to respond with an invite request. + */ +non_null() +static int handle_gc_hs_response_ack(const GC_Chat *chat, GC_Connection *gconn) +{ + gconn->handshaked = true; // has to be true before we can send a lossless packet + + if (!send_gc_invite_request(chat, gconn)) { + gconn->handshaked = false; + return -1; + } + + return 0; +} + +int gc_set_ignore(const GC_Chat *chat, uint32_t peer_id, bool ignore) +{ + const int peer_number = get_peer_number_of_peer_id(chat, peer_id); + + GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return -1; + } + + if (peer_number_is_self(peer_number)) { + return -2; + } + + peer->ignore = ignore; + + return 0; +} + +/** @brief Handles a broadcast packet. + * + * Returns 0 if packet is handled correctly. + * Returns -1 on failure. + */ +non_null(1, 2, 4) nullable(6) +static int handle_gc_broadcast(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, const uint8_t *data, + uint16_t length, void *userdata) +{ + if (length < GC_BROADCAST_ENC_HEADER_SIZE) { + return -1; + } + + GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return -1; + } + + GC_Connection *gconn = &peer->gconn; + + if (!gconn->confirmed) { + return -1; + } + + const uint8_t broadcast_type = data[0]; + + const uint16_t m_len = length - 1; + const uint8_t *message = data + 1; + + int ret = 0; + + switch (broadcast_type) { + case GM_STATUS: { + ret = handle_gc_status(c, chat, peer, message, m_len, userdata); + break; + } + + case GM_NICK: { + ret = handle_gc_nick(c, chat, peer, message, m_len, userdata); + break; + } + + case GM_ACTION_MESSAGE: + + // intentional fallthrough + case GM_PLAIN_MESSAGE: { + ret = handle_gc_message(c, chat, peer, message, m_len, broadcast_type, userdata); + break; + } + + case GM_PRIVATE_MESSAGE: { + ret = handle_gc_private_message(c, chat, peer, message, m_len, userdata); + break; + } + + case GM_PEER_EXIT: { + handle_gc_peer_exit(chat, gconn, message, m_len); + ret = 0; + break; + } + + case GM_KICK_PEER: { + ret = handle_gc_kick_peer(c, chat, peer, message, m_len, userdata); + break; + } + + case GM_SET_MOD: { + ret = handle_gc_set_mod(c, chat, peer_number, message, m_len, userdata); + break; + } + + case GM_SET_OBSERVER: { + ret = handle_gc_set_observer(c, chat, peer_number, message, m_len, userdata); + break; + } + + default: { + LOGGER_DEBUG(chat->log, "Received an invalid broadcast type 0x%02x", broadcast_type); + break; + } + } + + if (ret < 0) { + LOGGER_DEBUG(chat->log, "Broadcast handle error %d: type: 0x%02x, peernumber: %u", + ret, broadcast_type, peer_number); + return -1; + } + + return 0; +} + +/** @brief Decrypts data of size `length` using self secret key and sender's public key. + * + * The packet payload should begin with a nonce. + * + * Returns length of plaintext data on success. + * Return -1 if length is invalid. + * Return -2 if decryption fails. + */ +non_null() +static int unwrap_group_handshake_packet(const Logger *log, const uint8_t *self_sk, const uint8_t *sender_pk, + uint8_t *plain, size_t plain_size, const uint8_t *packet, uint16_t length) +{ + if (length <= CRYPTO_NONCE_SIZE) { + LOGGER_FATAL(log, "Invalid handshake packet length %u", length); + return -1; + } + + const int plain_len = decrypt_data(sender_pk, self_sk, packet, packet + CRYPTO_NONCE_SIZE, + length - CRYPTO_NONCE_SIZE, plain); + + if (plain_len < 0 || (uint32_t)plain_len != plain_size) { + LOGGER_DEBUG(log, "decrypt handshake request failed: len: %d, size: %zu", plain_len, plain_size); + return -2; + } + + return plain_len; +} + +/** @brief Encrypts data of length using the peer's shared key a new nonce. + * + * Adds plaintext header consisting of: packet identifier, target public encryption key, + * self public encryption key, nonce. + * + * Return length of encrypted packet on success. + * Return -1 if packet size is invalid. + * Return -2 on malloc failure. + * Return -3 if encryption fails. + */ +non_null() +static int wrap_group_handshake_packet( + const Logger *log, const Random *rng, const uint8_t *self_pk, const uint8_t *self_sk, + const uint8_t *target_pk, uint8_t *packet, uint32_t packet_size, + const uint8_t *data, uint16_t length) +{ + if (packet_size != GC_MIN_ENCRYPTED_HS_PAYLOAD_SIZE + sizeof(Node_format)) { + LOGGER_FATAL(log, "Invalid packet size: %u", packet_size); + return -1; + } + + uint8_t nonce[CRYPTO_NONCE_SIZE]; + random_nonce(rng, nonce); + + const size_t encrypt_buf_size = length + CRYPTO_MAC_SIZE; + uint8_t *encrypt = (uint8_t *)malloc(encrypt_buf_size); + + if (encrypt == nullptr) { + return -2; + } + + const int enc_len = encrypt_data(target_pk, self_sk, nonce, data, length, encrypt); + + if (enc_len < 0 || (size_t)enc_len != encrypt_buf_size) { + LOGGER_ERROR(log, "Failed to encrypt group handshake packet (len: %d)", enc_len); + free(encrypt); + return -3; + } + + packet[0] = NET_PACKET_GC_HANDSHAKE; + memcpy(packet + 1, self_pk, ENC_PUBLIC_KEY_SIZE); + memcpy(packet + 1 + ENC_PUBLIC_KEY_SIZE, target_pk, ENC_PUBLIC_KEY_SIZE); + memcpy(packet + 1 + ENC_PUBLIC_KEY_SIZE + ENC_PUBLIC_KEY_SIZE, nonce, CRYPTO_NONCE_SIZE); + memcpy(packet + 1 + ENC_PUBLIC_KEY_SIZE + ENC_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE, encrypt, enc_len); + + free(encrypt); + + return 1 + ENC_PUBLIC_KEY_SIZE + ENC_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + enc_len; +} + +/** @brief Makes, wraps and encrypts a group handshake packet (both request and response are the same format). + * + * Packet contains the packet header, handshake type, self public encryption key, self public signature key, + * request type, and a single TCP relay node. + * + * Returns length of encrypted packet on success. + * Returns -1 on failure. + */ +non_null() +static int make_gc_handshake_packet(const GC_Chat *chat, const GC_Connection *gconn, uint8_t handshake_type, + uint8_t request_type, uint8_t join_type, uint8_t *packet, size_t packet_size, + const Node_format *node) +{ + if (packet_size != GC_MIN_ENCRYPTED_HS_PAYLOAD_SIZE + sizeof(Node_format)) { + LOGGER_FATAL(chat->log, "invalid packet size: %zu", packet_size); + return -1; + } + + if (chat == nullptr || gconn == nullptr || node == nullptr) { + return -1; + } + + uint8_t data[GC_MIN_HS_PACKET_PAYLOAD_SIZE + sizeof(Node_format)]; + + uint16_t length = sizeof(uint8_t); + + data[0] = handshake_type; + memcpy(data + length, gconn->session_public_key, ENC_PUBLIC_KEY_SIZE); + length += ENC_PUBLIC_KEY_SIZE; + memcpy(data + length, get_sig_pk(chat->self_public_key), SIG_PUBLIC_KEY_SIZE); + length += SIG_PUBLIC_KEY_SIZE; + memcpy(data + length, &request_type, sizeof(uint8_t)); + length += sizeof(uint8_t); + memcpy(data + length, &join_type, sizeof(uint8_t)); + length += sizeof(uint8_t); + + int nodes_size = pack_nodes(chat->log, data + length, sizeof(Node_format), node, MAX_SENT_GC_NODES); + + if (nodes_size > 0) { + length += nodes_size; + } else { + nodes_size = 0; + } + + const int enc_len = wrap_group_handshake_packet( + chat->log, chat->rng, chat->self_public_key, chat->self_secret_key, + gconn->addr.public_key, packet, (uint16_t)packet_size, data, length); + + if (enc_len != GC_MIN_ENCRYPTED_HS_PAYLOAD_SIZE + nodes_size) { + LOGGER_WARNING(chat->log, "Failed to wrap handshake packet: %d", enc_len); + return -1; + } + + return enc_len; +} + +/** @brief Sends a handshake packet to `gconn`. + * + * Handshake_type should be GH_REQUEST or GH_RESPONSE. + * + * Returns true on success. + */ +non_null() +static bool send_gc_handshake_packet(const GC_Chat *chat, GC_Connection *gconn, uint8_t handshake_type, + uint8_t request_type, uint8_t join_type) +{ + if (gconn == nullptr) { + return false; + } + + Node_format node; + memset(&node, 0, sizeof(node)); + + if (!gcc_copy_tcp_relay(chat->rng, &node, gconn)) { + LOGGER_TRACE(chat->log, "Failed to copy TCP relay during handshake (%u TCP relays)", gconn->tcp_relays_count); + } + + uint8_t packet[GC_MIN_ENCRYPTED_HS_PAYLOAD_SIZE + sizeof(Node_format)]; + const int length = make_gc_handshake_packet(chat, gconn, handshake_type, request_type, join_type, packet, + sizeof(packet), &node); + + if (length < 0) { + return false; + } + + const bool try_tcp_fallback = gconn->handshake_attempts % 2 == 1 && gconn->tcp_relays_count > 0; + ++gconn->handshake_attempts; + + int ret = -1; + + if (!try_tcp_fallback && gcc_direct_conn_is_possible(chat, gconn)) { + ret = sendpacket(chat->net, &gconn->addr.ip_port, packet, (uint16_t)length); + } + + if (ret != length && gconn->tcp_relays_count == 0) { + LOGGER_WARNING(chat->log, "UDP handshake failed and no TCP relays to fall back on"); + return false; + } + + // Send a TCP handshake if UDP fails, or if UDP succeeded last time but we never got a response + if (gconn->tcp_relays_count > 0 && (ret != length || try_tcp_fallback)) { + if (send_packet_tcp_connection(chat->tcp_conn, gconn->tcp_connection_num, packet, (uint16_t)length) == -1) { + LOGGER_DEBUG(chat->log, "Send handshake packet failed. Type 0x%02x", request_type); + return false; + } + } + + if (gconn->is_pending_handshake_response) { + gcc_set_send_message_id(gconn, 3); // handshake response is always second packet + } else { + gcc_set_send_message_id(gconn, 2); // handshake request is always first packet + } + + return true; +} + +/** @brief Sends an out-of-band TCP handshake request packet to `gconn`. + * + * Return true on success. + */ +static bool send_gc_oob_handshake_request(const GC_Chat *chat, const GC_Connection *gconn) +{ + if (gconn == nullptr) { + return false; + } + + Node_format node; + memset(&node, 0, sizeof(node)); + + if (!gcc_copy_tcp_relay(chat->rng, &node, gconn)) { + LOGGER_WARNING(chat->log, "Failed to copy TCP relay"); + return false; + } + + uint8_t packet[GC_MIN_ENCRYPTED_HS_PAYLOAD_SIZE + sizeof(Node_format)]; + const int length = make_gc_handshake_packet(chat, gconn, GH_REQUEST, gconn->pending_handshake_type, chat->join_type, + packet, sizeof(packet), &node); + + if (length < 0) { + LOGGER_WARNING(chat->log, "Failed to make handshake packet"); + return false; + } + + return tcp_send_oob_packet_using_relay(chat->tcp_conn, gconn->oob_relay_pk, gconn->addr.public_key, + packet, (uint16_t)length) == 0; +} + +/** @brief Handles a handshake response packet and takes appropriate action depending on the value of request_type. + * + * This function assumes the length has already been validated. + * + * Returns peer_number of new connected peer on success. + * Returns -1 on failure. + */ +non_null() +static int handle_gc_handshake_response(const GC_Chat *chat, const uint8_t *sender_pk, const uint8_t *data, + uint16_t length) +{ + // this should be checked at lower level; this is a redundant defense check. Ideally we should + // guarantee that this can never happen in the future. + if (length < ENC_PUBLIC_KEY_SIZE + SIG_PUBLIC_KEY_SIZE + 1) { + LOGGER_FATAL(chat->log, "Invalid handshake response size (%u)", length); + return -1; + } + + const int peer_number = get_peer_number_of_enc_pk(chat, sender_pk, false); + + if (peer_number == -1) { + return -1; + } + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return -1; + } + + const uint8_t *sender_session_pk = data; + + gcc_make_session_shared_key(gconn, sender_session_pk); + + set_sig_pk(gconn->addr.public_key, data + ENC_PUBLIC_KEY_SIZE); + + gcc_set_recv_message_id(gconn, 2); // handshake response is always second packet + + gconn->handshaked = true; + + send_gc_hs_response_ack(chat, gconn); + + const uint8_t request_type = data[ENC_PUBLIC_KEY_SIZE + SIG_PUBLIC_KEY_SIZE]; + + switch (request_type) { + case HS_INVITE_REQUEST: { + if (!send_gc_invite_request(chat, gconn)) { + return -1; + } + + break; + } + + case HS_PEER_INFO_EXCHANGE: { + if (!send_gc_peer_exchange(chat, gconn)) { + return -1; + } + + break; + } + + default: { + return -1; + } + } + + return peer_number; +} + +/** @brief Sends a handshake response packet of type `request_type` to `gconn`. + * + * Return true on success. + */ +non_null() +static bool send_gc_handshake_response(const GC_Chat *chat, GC_Connection *gconn) +{ + return send_gc_handshake_packet(chat, gconn, GH_RESPONSE, gconn->pending_handshake_type, 0); +} + +/** @brief Handles handshake request packets. + * + * Peer is added to peerlist and a lossless connection is established. + * + * This function assumes the length has already been validated. + * + * Return new peer's peer_number on success. + * Return -1 on failure. + */ +#define GC_NEW_PEER_CONNECTION_LIMIT 10 +non_null(1, 3, 4) nullable(2) +static int handle_gc_handshake_request(GC_Chat *chat, const IP_Port *ipp, const uint8_t *sender_pk, + const uint8_t *data, uint16_t length) +{ + // this should be checked at lower level; this is a redundant defense check. Ideally we should + // guarantee that this can never happen in the future. + if (length < ENC_PUBLIC_KEY_SIZE + SIG_PUBLIC_KEY_SIZE + 1 + 1) { + LOGGER_FATAL(chat->log, "Invalid length (%u)", length); + return -1; + } + + if (chat->connection_state <= CS_DISCONNECTED) { + LOGGER_DEBUG(chat->log, "Handshake request ignored; state is disconnected"); + return -1; + } + + if (chat->connection_O_metre >= GC_NEW_PEER_CONNECTION_LIMIT) { + chat->block_handshakes = true; + LOGGER_DEBUG(chat->log, "Handshake overflow. Blocking handshakes."); + return -1; + } + + ++chat->connection_O_metre; + + const uint8_t *public_sig_key = data + ENC_PUBLIC_KEY_SIZE; + + const uint8_t request_type = data[ENC_PUBLIC_KEY_SIZE + SIG_PUBLIC_KEY_SIZE]; + const uint8_t join_type = data[ENC_PUBLIC_KEY_SIZE + SIG_PUBLIC_KEY_SIZE + 1]; + + int peer_number = get_peer_number_of_enc_pk(chat, sender_pk, false); + const bool is_new_peer = peer_number < 0; + + if (is_new_peer) { + peer_number = peer_add(chat, ipp, sender_pk); + + if (peer_number < 0) { + LOGGER_WARNING(chat->log, "Failed to add peer during handshake request"); + return -1; + } + } else { + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + LOGGER_WARNING(chat->log, "Invalid peer number"); + return -1; + } + + if (gconn->handshaked) { + gconn->handshaked = false; + LOGGER_DEBUG(chat->log, "Handshaked peer sent a handshake request"); + return -1; + } + + // peers sent handshake request at same time so the closer peer becomes the requestor + // and ignores the request packet while further peer continues on with the response + if (gconn->self_is_closer) { + LOGGER_DEBUG(chat->log, "Simultaneous handshake requests; other peer is closer"); + return 0; + } + } + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + LOGGER_DEBUG(chat->log, "Peer connection invalid"); + return -1; + } + + gcc_set_ip_port(gconn, ipp); + + Node_format node[GCA_MAX_ANNOUNCED_TCP_RELAYS]; + const int processed = ENC_PUBLIC_KEY_SIZE + SIG_PUBLIC_KEY_SIZE + 1 + 1; + + const int nodes_count = unpack_nodes(node, GCA_MAX_ANNOUNCED_TCP_RELAYS, nullptr, + data + processed, length - processed, true); + + if (nodes_count <= 0 && ipp == nullptr) { + if (is_new_peer) { + LOGGER_WARNING(chat->log, "Broken tcp relay for new peer"); + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_DISCONNECTED, nullptr, 0); + } + + return -1; + } + + if (nodes_count > 0) { + const int add_tcp_result = add_tcp_relay_connection(chat->tcp_conn, gconn->tcp_connection_num, + &node->ip_port, node->public_key); + + if (add_tcp_result < 0 && is_new_peer && ipp == nullptr) { + LOGGER_WARNING(chat->log, "Broken tcp relay for new peer"); + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_DISCONNECTED, nullptr, 0); + return -1; + } + + if (add_tcp_result == 0) { + gcc_save_tcp_relay(chat->rng, gconn, node); + } + } + + const uint8_t *sender_session_pk = data; + + gcc_make_session_shared_key(gconn, sender_session_pk); + + set_sig_pk(gconn->addr.public_key, public_sig_key); + + if (join_type == HJ_PUBLIC && !is_public_chat(chat)) { + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_DISCONNECTED, nullptr, 0); + LOGGER_DEBUG(chat->log, "Ignoring invalid invite request"); + return -1; + } + + gcc_set_recv_message_id(gconn, 1); // handshake request is always first packet + + gconn->is_pending_handshake_response = true; + gconn->pending_handshake_type = request_type; + + return peer_number; +} + +/** @brief Handles handshake request and handshake response packets. + * + * Returns the peer_number of the connecting peer on success. + * Returns -1 on failure. + */ +non_null(1, 2, 4) nullable(3, 7) +static int handle_gc_handshake_packet(GC_Chat *chat, const uint8_t *sender_pk, const IP_Port *ipp, + const uint8_t *packet, uint16_t length, bool direct_conn, void *userdata) +{ + if (length < GC_MIN_HS_PACKET_PAYLOAD_SIZE + CRYPTO_MAC_SIZE + CRYPTO_NONCE_SIZE) { + return -1; + } + + const size_t data_buf_size = length - CRYPTO_NONCE_SIZE - CRYPTO_MAC_SIZE; + uint8_t *data = (uint8_t *)malloc(data_buf_size); + + if (data == nullptr) { + return -1; + } + + const int plain_len = unwrap_group_handshake_packet(chat->log, chat->self_secret_key, sender_pk, data, + data_buf_size, packet, length); + + if (plain_len < GC_MIN_HS_PACKET_PAYLOAD_SIZE) { + LOGGER_DEBUG(chat->log, "Failed to unwrap handshake packet (probably a stale request using an old key)"); + free(data); + return -1; + } + + const uint8_t handshake_type = data[0]; + + const uint8_t *real_data = data + 1; + const uint16_t real_len = (uint16_t)plain_len - 1; + + int peer_number; + + if (handshake_type == GH_REQUEST) { + peer_number = handle_gc_handshake_request(chat, ipp, sender_pk, real_data, real_len); + } else if (handshake_type == GH_RESPONSE) { + peer_number = handle_gc_handshake_response(chat, sender_pk, real_data, real_len); + } else { + free(data); + return -1; + } + + free(data); + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return -1; + } + + if (direct_conn) { + gconn->last_received_direct_time = mono_time_get(chat->mono_time); + } + + return peer_number; +} + +bool handle_gc_lossless_helper(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, const uint8_t *data, + uint16_t length, uint8_t packet_type, void *userdata) +{ + GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return false; + } + + GC_Connection *gconn = &peer->gconn; + + int ret; + + switch (packet_type) { + case GP_BROADCAST: { + ret = handle_gc_broadcast(c, chat, peer_number, data, length, userdata); + break; + } + + case GP_PEER_INFO_REQUEST: { + ret = handle_gc_peer_info_request(chat, peer_number); + break; + } + + case GP_PEER_INFO_RESPONSE: { + ret = handle_gc_peer_info_response(c, chat, peer_number, data, length, userdata); + break; + } + + case GP_SYNC_REQUEST: { + ret = handle_gc_sync_request(chat, peer_number, data, length); + break; + } + + case GP_SYNC_RESPONSE: { + ret = handle_gc_sync_response(c, chat, peer_number, data, length, userdata); + break; + } + + case GP_INVITE_REQUEST: { + ret = handle_gc_invite_request(chat, peer_number, data, length); + break; + } + + case GP_INVITE_RESPONSE: { + ret = handle_gc_invite_response(chat, gconn); + break; + } + + case GP_TOPIC: { + ret = handle_gc_topic(c, chat, peer, data, length, userdata); + break; + } + + case GP_SHARED_STATE: { + ret = handle_gc_shared_state(c, chat, gconn, data, length, userdata); + break; + } + + case GP_MOD_LIST: { + ret = handle_gc_mod_list(c, chat, data, length, userdata); + break; + } + + case GP_SANCTIONS_LIST: { + ret = handle_gc_sanctions_list(c, chat, data, length, userdata); + break; + } + + case GP_HS_RESPONSE_ACK: { + ret = handle_gc_hs_response_ack(chat, gconn); + break; + } + + case GP_TCP_RELAYS: { + ret = handle_gc_tcp_relays(chat, gconn, data, length); + break; + } + + case GP_KEY_ROTATION: { + ret = handle_gc_key_exchange(chat, gconn, data, length); + break; + } + + case GP_CUSTOM_PACKET: { + ret = handle_gc_custom_packet(c, chat, peer, data, length, true, userdata); + break; + } + + case GP_CUSTOM_PRIVATE_PACKET: { + ret = handle_gc_custom_private_packet(c, chat, peer, data, length, true, userdata); + break; + } + + default: { + LOGGER_DEBUG(chat->log, "Handling invalid lossless group packet type 0x%02x", packet_type); + return false; + } + } + + if (ret < 0) { + LOGGER_DEBUG(chat->log, "Lossless packet handle error %d: type: 0x%02x, peernumber: %d", + ret, packet_type, peer_number); + return false; + } + + peer = get_gc_peer(chat, peer_number); + + if (peer != nullptr) { + peer->gconn.last_requested_packet_time = mono_time_get(chat->mono_time); + } + + return true; +} + +/** @brief Handles a packet fragment. + * + * If the fragment is the last one in a sequence we send an ack. Otherwise we + * store the fragment in the receive array and wait for the next segment. + * + * Segments must be processed in correct sequence, and we cannot handle + * non-fragment packets while a sequence is incomplete. + * + * Return true if packet is handled successfully. + */ +non_null(1, 2, 4) nullable(5, 9) +static bool handle_gc_packet_fragment(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, GC_Connection *gconn, + const uint8_t *data, uint16_t length, uint8_t packet_type, uint64_t message_id, + void *userdata) +{ + if (gconn->last_chunk_id != 0 && message_id != gconn->last_chunk_id + 1) { + return gc_send_message_ack(chat, gconn, gconn->last_chunk_id + 1, GR_ACK_REQ); + } + + if (gconn->last_chunk_id == 0 && message_id != gconn->received_message_id + 1) { + return gc_send_message_ack(chat, gconn, gconn->received_message_id + 1, GR_ACK_REQ); + } + + const int frag_ret = gcc_handle_packet_fragment(c, chat, peer_number, gconn, data, length, packet_type, + message_id, userdata); + + if (frag_ret == -1) { + return false; + } + + if (frag_ret == 0) { + gc_send_message_ack(chat, gconn, message_id, GR_ACK_RECV); + } + + gconn->last_received_packet_time = mono_time_get(chat->mono_time); + + return true; +} + +/** @brief Handles lossless groupchat packets. + * + * This function assumes the length has already been validated. + * + * Returns true if packet is successfully handled. + */ +non_null(1, 2, 3, 4) nullable(7) +static bool handle_gc_lossless_packet(const GC_Session *c, GC_Chat *chat, const uint8_t *sender_pk, + const uint8_t *packet, uint16_t length, bool direct_conn, void *userdata) +{ + if (length < GC_MIN_LOSSLESS_PAYLOAD_SIZE) { + return false; + } + + int peer_number = get_peer_number_of_enc_pk(chat, sender_pk, false); + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return false; + } + + if (gconn->pending_delete) { + return true; + } + + uint8_t *data = (uint8_t *)malloc(length); + + if (data == nullptr) { + LOGGER_DEBUG(chat->log, "Failed to allocate memory for packet data buffer"); + return false; + } + + uint8_t packet_type; + uint64_t message_id; + + const int len = group_packet_unwrap(chat->log, gconn, data, &message_id, &packet_type, packet, length); + + if (len < 0) { + Ip_Ntoa ip_str; + LOGGER_DEBUG(chat->log, "Failed to unwrap lossless packet from %s:%d: %d", + net_ip_ntoa(&gconn->addr.ip_port.ip, &ip_str), net_ntohs(gconn->addr.ip_port.port), len); + free(data); + return false; + } + + if (!gconn->handshaked && (packet_type != GP_HS_RESPONSE_ACK && packet_type != GP_INVITE_REQUEST)) { + LOGGER_DEBUG(chat->log, "Got lossless packet type 0x%02x from unconfirmed peer", packet_type); + free(data); + return false; + } + + const bool is_invite_packet = packet_type == GP_INVITE_REQUEST || packet_type == GP_INVITE_RESPONSE + || packet_type == GP_INVITE_RESPONSE_REJECT; + + if (message_id == 3 && is_invite_packet && gconn->received_message_id <= 1) { + // we missed initial handshake request. Drop this packet and wait for another handshake request. + LOGGER_DEBUG(chat->log, "Missed handshake packet, type: 0x%02x", packet_type); + free(data); + return false; + } + + const int lossless_ret = gcc_handle_received_message(chat->log, chat->mono_time, gconn, data, (uint16_t) len, + packet_type, message_id, direct_conn); + + if (packet_type == GP_INVITE_REQUEST && !gconn->handshaked) { // Both peers sent request at same time + free(data); + return true; + } + + if (lossless_ret < 0) { + LOGGER_DEBUG(chat->log, "failed to handle packet %llu (type: 0x%02x, id: %llu)", + (unsigned long long)message_id, packet_type, (unsigned long long)message_id); + free(data); + return false; + } + + /* Duplicate packet */ + if (lossless_ret == 0) { + free(data); + return gc_send_message_ack(chat, gconn, message_id, GR_ACK_RECV); + } + + /* request missing packet */ + if (lossless_ret == 1) { + LOGGER_TRACE(chat->log, "received out of order packet from peer %u. expected %llu, got %llu", peer_number, + (unsigned long long)gconn->received_message_id + 1, (unsigned long long)message_id); + free(data); + return gc_send_message_ack(chat, gconn, gconn->received_message_id + 1, GR_ACK_REQ); + } + + /* handle packet fragment */ + if (lossless_ret == 3) { + const bool frag_ret = handle_gc_packet_fragment(c, chat, peer_number, gconn, data, (uint16_t)len, packet_type, + message_id, userdata); + free(data); + return frag_ret; + } + + const bool ret = handle_gc_lossless_helper(c, chat, peer_number, data, (uint16_t)len, packet_type, userdata); + + free(data); + + if (!ret) { + return false; + } + + /* peer number can change from peer add operations in packet handlers */ + peer_number = get_peer_number_of_enc_pk(chat, sender_pk, false); + gconn = get_gc_connection(chat, peer_number); + + if (gconn != nullptr && lossless_ret == 2) { + gc_send_message_ack(chat, gconn, message_id, GR_ACK_RECV); + } + + return true; +} + +/** @brief Handles lossy groupchat message packets. + * + * This function assumes the length has already been validated. + * + * Return true if packet is handled successfully. + */ +non_null(1, 2, 3, 4) nullable(7) +static bool handle_gc_lossy_packet(const GC_Session *c, GC_Chat *chat, const uint8_t *sender_pk, + const uint8_t *packet, uint16_t length, bool direct_conn, void *userdata) +{ + if (length < GC_MIN_LOSSY_PAYLOAD_SIZE) { + return false; + } + + const int peer_number = get_peer_number_of_enc_pk(chat, sender_pk, false); + + GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return false; + } + + GC_Connection *gconn = &peer->gconn; + + if (!gconn->handshaked || gconn->pending_delete) { + LOGGER_DEBUG(chat->log, "Got lossy packet from invalid peer"); + return false; + } + + uint8_t *data = (uint8_t *)malloc(length); + + if (data == nullptr) { + LOGGER_ERROR(chat->log, "Failed to allocate memory for packet buffer"); + return false; + } + + uint8_t packet_type; + + const int len = group_packet_unwrap(chat->log, gconn, data, nullptr, &packet_type, packet, length); + + if (len <= 0) { + Ip_Ntoa ip_str; + LOGGER_DEBUG(chat->log, "Failed to unwrap lossy packet from %s:%d: %d", + net_ip_ntoa(&gconn->addr.ip_port.ip, &ip_str), net_ntohs(gconn->addr.ip_port.port), len); + free(data); + return false; + } + + int ret = -1; + const uint16_t payload_len = (uint16_t)len; + + switch (packet_type) { + case GP_MESSAGE_ACK: { + ret = handle_gc_message_ack(chat, gconn, data, payload_len); + break; + } + + case GP_PING: { + ret = handle_gc_ping(chat, gconn, data, payload_len); + break; + } + + case GP_INVITE_RESPONSE_REJECT: { + ret = handle_gc_invite_response_reject(c, chat, data, payload_len, userdata); + break; + } + + case GP_CUSTOM_PACKET: { + ret = handle_gc_custom_packet(c, chat, peer, data, payload_len, false, userdata); + break; + } + + case GP_CUSTOM_PRIVATE_PACKET: { + ret = handle_gc_custom_private_packet(c, chat, peer, data, payload_len, false, userdata); + break; + } + + default: { + LOGGER_WARNING(chat->log, "Warning: handling invalid lossy group packet type 0x%02x", packet_type); + free(data); + return false; + } + } + + free(data); + + if (ret < 0) { + LOGGER_DEBUG(chat->log, "Lossy packet handle error %d: type: 0x%02x, peernumber %d", ret, packet_type, + peer_number); + return false; + } + + const uint64_t tm = mono_time_get(chat->mono_time); + + if (direct_conn) { + gconn->last_received_direct_time = tm; + } + + gconn->last_received_packet_time = tm; + + return true; +} + +/** @brief Return true if group is either connected or attempting to connect. */ +non_null() +static bool group_can_handle_packets(const GC_Chat *chat) +{ + const GC_Conn_State state = chat->connection_state; + return state == CS_CONNECTING || state == CS_CONNECTED; +} + +/** @brief Sends a group packet to appropriate handler function. + * + * Returns non-negative value on success. + * Returns -1 on failure. + */ +#define MIN_TCP_PACKET_SIZE (1 + ENC_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + CRYPTO_MAC_SIZE) +non_null(1, 3) nullable(5) +static int handle_gc_tcp_packet(void *object, int id, const uint8_t *packet, uint16_t length, void *userdata) +{ + const Messenger *m = (Messenger *)object; + + if (m == nullptr) { + return -1; + } + + if (length <= MIN_TCP_PACKET_SIZE) { + LOGGER_WARNING(m->log, "Got tcp packet with invalid length: %u (expected %u to %u)", length, + MIN_TCP_PACKET_SIZE, MAX_GC_PACKET_CHUNK_SIZE + MIN_TCP_PACKET_SIZE + ENC_PUBLIC_KEY_SIZE); + return -1; + } + + if (length > MAX_GC_PACKET_CHUNK_SIZE + MIN_TCP_PACKET_SIZE + ENC_PUBLIC_KEY_SIZE) { + LOGGER_WARNING(m->log, "Got tcp packet with invalid length: %u (expected %u to %u)", length, + MIN_TCP_PACKET_SIZE, MAX_GC_PACKET_CHUNK_SIZE + MIN_TCP_PACKET_SIZE + ENC_PUBLIC_KEY_SIZE); + return -1; + } + + const uint8_t packet_type = packet[0]; + + const uint8_t *sender_pk = packet + 1; + + const GC_Session *c = m->group_handler; + GC_Chat *chat = nullptr; + + if (packet_type == NET_PACKET_GC_HANDSHAKE) { + chat = get_chat_by_id(c, packet + 1 + ENC_PUBLIC_KEY_SIZE); + } else { + chat = get_chat_by_id(c, sender_pk); + } + + if (chat == nullptr) { + return -1; + } + + if (!group_can_handle_packets(chat)) { + return -1; + } + + const uint8_t *payload = packet + 1 + ENC_PUBLIC_KEY_SIZE; + uint16_t payload_len = length - 1 - ENC_PUBLIC_KEY_SIZE; + + switch (packet_type) { + case NET_PACKET_GC_LOSSLESS: { + if (!handle_gc_lossless_packet(c, chat, sender_pk, payload, payload_len, false, userdata)) { + return -1; + } + + return 0; + } + + case NET_PACKET_GC_LOSSY: { + if (!handle_gc_lossy_packet(c, chat, sender_pk, payload, payload_len, false, userdata)) { + return -1; + } + + return 0; + } + + case NET_PACKET_GC_HANDSHAKE: { + // handshake packets have an extra public key in plaintext header + if (length <= 1 + ENC_PUBLIC_KEY_SIZE + ENC_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + CRYPTO_MAC_SIZE) { + return -1; + } + + payload_len = payload_len - ENC_PUBLIC_KEY_SIZE; + payload = payload + ENC_PUBLIC_KEY_SIZE; + + return handle_gc_handshake_packet(chat, sender_pk, nullptr, payload, payload_len, false, userdata); + } + + default: { + return -1; + } + } +} + +non_null(1, 2, 4) nullable(6) +static int handle_gc_tcp_oob_packet(void *object, const uint8_t *public_key, unsigned int tcp_connections_number, + const uint8_t *packet, uint16_t length, void *userdata) +{ + const Messenger *m = (Messenger *)object; + + if (m == nullptr) { + return -1; + } + + if (length <= GC_MIN_HS_PACKET_PAYLOAD_SIZE) { + LOGGER_WARNING(m->log, "Got tcp oob packet with invalid length: %u (expected %u to %u)", length, + GC_MIN_HS_PACKET_PAYLOAD_SIZE, MAX_GC_PACKET_CHUNK_SIZE + CRYPTO_MAC_SIZE + CRYPTO_NONCE_SIZE); + return -1; + } + + if (length > MAX_GC_PACKET_CHUNK_SIZE + CRYPTO_MAC_SIZE + CRYPTO_NONCE_SIZE) { + LOGGER_WARNING(m->log, "Got tcp oob packet with invalid length: %u (expected %u to %u)", length, + GC_MIN_HS_PACKET_PAYLOAD_SIZE, MAX_GC_PACKET_CHUNK_SIZE + CRYPTO_MAC_SIZE + CRYPTO_NONCE_SIZE); + return -1; + } + + const GC_Session *c = m->group_handler; + GC_Chat *chat = get_chat_by_id(c, packet + 1 + ENC_PUBLIC_KEY_SIZE); + + if (chat == nullptr) { + return -1; + } + + if (!group_can_handle_packets(chat)) { + return -1; + } + + const uint8_t packet_type = packet[0]; + + if (packet_type != NET_PACKET_GC_HANDSHAKE) { + return -1; + } + + const uint8_t *sender_pk = packet + 1; + + const uint8_t *payload = packet + 1 + ENC_PUBLIC_KEY_SIZE + ENC_PUBLIC_KEY_SIZE; + const uint16_t payload_len = length - 1 - ENC_PUBLIC_KEY_SIZE - ENC_PUBLIC_KEY_SIZE; + + if (payload_len < GC_MIN_HS_PACKET_PAYLOAD_SIZE + CRYPTO_MAC_SIZE + CRYPTO_NONCE_SIZE) { + return -1; + } + + if (handle_gc_handshake_packet(chat, sender_pk, nullptr, payload, payload_len, false, userdata) == -1) { + return -1; + } + + return 0; +} + +#define MIN_UDP_PACKET_SIZE (1 + ENC_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + CRYPTO_MAC_SIZE) +non_null(1, 2, 3) nullable(5) +static int handle_gc_udp_packet(void *object, const IP_Port *ipp, const uint8_t *packet, uint16_t length, + void *userdata) +{ + const Messenger *m = (Messenger *)object; + + if (m == nullptr) { + return -1; + } + + if (length <= MIN_UDP_PACKET_SIZE) { + LOGGER_WARNING(m->log, "Got UDP packet with invalid length: %u (expected %u to %u)", length, + MIN_UDP_PACKET_SIZE, MAX_GC_PACKET_CHUNK_SIZE + MIN_UDP_PACKET_SIZE + ENC_PUBLIC_KEY_SIZE); + return -1; + } + + if (length > MAX_GC_PACKET_CHUNK_SIZE + MIN_UDP_PACKET_SIZE + ENC_PUBLIC_KEY_SIZE) { + LOGGER_WARNING(m->log, "Got UDP packet with invalid length: %u (expected %u to %u)", length, + MIN_UDP_PACKET_SIZE, MAX_GC_PACKET_CHUNK_SIZE + MIN_UDP_PACKET_SIZE + ENC_PUBLIC_KEY_SIZE); + return -1; + } + + const uint8_t packet_type = packet[0]; + const uint8_t *sender_pk = packet + 1; + + const GC_Session *c = m->group_handler; + GC_Chat *chat = nullptr; + + if (packet_type == NET_PACKET_GC_HANDSHAKE) { + chat = get_chat_by_id(c, packet + 1 + ENC_PUBLIC_KEY_SIZE); + } else { + chat = get_chat_by_id(c, sender_pk); + } + + if (chat == nullptr) { + return -1; + } + + if (!group_can_handle_packets(chat)) { + return -1; + } + + const uint8_t *payload = packet + 1 + ENC_PUBLIC_KEY_SIZE; + uint16_t payload_len = length - 1 - ENC_PUBLIC_KEY_SIZE; + bool ret = false; + + switch (packet_type) { + case NET_PACKET_GC_LOSSLESS: { + ret = handle_gc_lossless_packet(c, chat, sender_pk, payload, payload_len, true, userdata); + break; + } + + case NET_PACKET_GC_LOSSY: { + ret = handle_gc_lossy_packet(c, chat, sender_pk, payload, payload_len, true, userdata); + break; + } + + case NET_PACKET_GC_HANDSHAKE: { + // handshake packets have an extra public key in plaintext header + if (length <= 1 + ENC_PUBLIC_KEY_SIZE + ENC_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + CRYPTO_MAC_SIZE) { + return -1; + } + + payload_len = payload_len - ENC_PUBLIC_KEY_SIZE; + payload = payload + ENC_PUBLIC_KEY_SIZE; + + ret = handle_gc_handshake_packet(chat, sender_pk, ipp, payload, payload_len, true, userdata) != -1; + break; + } + + default: { + return -1; + } + } + + return ret ? 0 : -1; +} + +void gc_callback_message(const Messenger *m, gc_message_cb *function) +{ + GC_Session *c = m->group_handler; + c->message = function; +} + +void gc_callback_private_message(const Messenger *m, gc_private_message_cb *function) +{ + GC_Session *c = m->group_handler; + c->private_message = function; +} + +void gc_callback_custom_packet(const Messenger *m, gc_custom_packet_cb *function) +{ + GC_Session *c = m->group_handler; + c->custom_packet = function; +} + +void gc_callback_custom_private_packet(const Messenger *m, gc_custom_private_packet_cb *function) +{ + GC_Session *c = m->group_handler; + c->custom_private_packet = function; +} + +void gc_callback_moderation(const Messenger *m, gc_moderation_cb *function) +{ + GC_Session *c = m->group_handler; + c->moderation = function; +} + +void gc_callback_nick_change(const Messenger *m, gc_nick_change_cb *function) +{ + GC_Session *c = m->group_handler; + c->nick_change = function; +} + +void gc_callback_status_change(const Messenger *m, gc_status_change_cb *function) +{ + GC_Session *c = m->group_handler; + c->status_change = function; +} + +void gc_callback_topic_change(const Messenger *m, gc_topic_change_cb *function) +{ + GC_Session *c = m->group_handler; + c->topic_change = function; +} + +void gc_callback_topic_lock(const Messenger *m, gc_topic_lock_cb *function) +{ + GC_Session *c = m->group_handler; + c->topic_lock = function; +} + +void gc_callback_voice_state(const Messenger *m, gc_voice_state_cb *function) +{ + GC_Session *c = m->group_handler; + c->voice_state = function; +} + +void gc_callback_peer_limit(const Messenger *m, gc_peer_limit_cb *function) +{ + GC_Session *c = m->group_handler; + c->peer_limit = function; +} + +void gc_callback_privacy_state(const Messenger *m, gc_privacy_state_cb *function) +{ + GC_Session *c = m->group_handler; + c->privacy_state = function; +} + +void gc_callback_password(const Messenger *m, gc_password_cb *function) +{ + GC_Session *c = m->group_handler; + c->password = function; +} + +void gc_callback_peer_join(const Messenger *m, gc_peer_join_cb *function) +{ + GC_Session *c = m->group_handler; + c->peer_join = function; +} + +void gc_callback_peer_exit(const Messenger *m, gc_peer_exit_cb *function) +{ + GC_Session *c = m->group_handler; + c->peer_exit = function; +} + +void gc_callback_self_join(const Messenger *m, gc_self_join_cb *function) +{ + GC_Session *c = m->group_handler; + c->self_join = function; +} + +void gc_callback_rejected(const Messenger *m, gc_rejected_cb *function) +{ + GC_Session *c = m->group_handler; + c->rejected = function; +} + +/** @brief Deletes peer_number from group. + * + * `no_callback` should be set to true if the `peer_exit` callback + * should not be triggered. + * + * Return true on success. + */ +static bool peer_delete(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, void *userdata) +{ + GC_Peer *peer = get_gc_peer(chat, peer_number); + + if (peer == nullptr) { + return false; + } + + // We need to save some peer info for the callback before deleting it + const bool peer_confirmed = peer->gconn.confirmed; + const uint32_t peer_id = peer->peer_id; + uint8_t nick[MAX_GC_NICK_SIZE]; + const uint16_t nick_length = peer->nick_length; + const GC_Exit_Info exit_info = peer->gconn.exit_info; + + assert(nick_length <= MAX_GC_NICK_SIZE); + memcpy(nick, peer->nick, nick_length); + + gcc_peer_cleanup(&peer->gconn); + + --chat->numpeers; + + if (chat->numpeers != peer_number) { + chat->group[peer_number] = chat->group[chat->numpeers]; + } + + chat->group[chat->numpeers] = (GC_Peer) { + 0 + }; + + GC_Peer *tmp_group = (GC_Peer *)realloc(chat->group, chat->numpeers * sizeof(GC_Peer)); + + if (tmp_group == nullptr) { + return false; + } + + chat->group = tmp_group; + + set_gc_peerlist_checksum(chat); + + if (peer_confirmed) { + refresh_gc_saved_peers(chat); + } + + if (exit_info.exit_type != GC_EXIT_TYPE_NO_CALLBACK && c->peer_exit != nullptr && peer_confirmed) { + c->peer_exit(c->messenger, chat->group_number, peer_id, exit_info.exit_type, nick, + nick_length, exit_info.part_message, exit_info.length, userdata); + } + + return true; +} + +/** @brief Updates peer_number with info from `peer` and validates peer data. + * + * Returns peer_number on success. + * Returns -1 on failure. + */ +static int peer_update(const GC_Chat *chat, const GC_Peer *peer, uint32_t peer_number) +{ + if (peer->nick_length == 0) { + return -1; + } + + if (peer->status > GS_BUSY) { + return -1; + } + + if (peer->role > GR_OBSERVER) { + return -1; + } + + GC_Peer *curr_peer = get_gc_peer(chat, peer_number); + assert(curr_peer != nullptr); + + curr_peer->status = peer->status; + curr_peer->nick_length = peer->nick_length; + + memcpy(curr_peer->nick, peer->nick, peer->nick_length); + + return peer_number; +} + +int peer_add(GC_Chat *chat, const IP_Port *ipp, const uint8_t *public_key) +{ + if (get_peer_number_of_enc_pk(chat, public_key, false) != -1) { + return -2; + } + + const uint32_t peer_id = get_new_peer_id(chat); + + if (peer_id == UINT32_MAX) { + LOGGER_WARNING(chat->log, "Failed to add peer: all peer ID's are taken?"); + return -1; + } + + const int peer_number = chat->numpeers; + int tcp_connection_num = -1; + + if (peer_number > 0) { // we don't need a connection to ourself + tcp_connection_num = new_tcp_connection_to(chat->tcp_conn, public_key, 0); + + if (tcp_connection_num == -1) { + LOGGER_WARNING(chat->log, "Failed to init tcp connection for peer %d", peer_number); + } + } + + GC_Message_Array_Entry *send = (GC_Message_Array_Entry *)calloc(GCC_BUFFER_SIZE, sizeof(GC_Message_Array_Entry)); + GC_Message_Array_Entry *recv = (GC_Message_Array_Entry *)calloc(GCC_BUFFER_SIZE, sizeof(GC_Message_Array_Entry)); + + if (send == nullptr || recv == nullptr) { + LOGGER_ERROR(chat->log, "Failed to allocate memory for gconn buffers"); + + if (tcp_connection_num != -1) { + kill_tcp_connection_to(chat->tcp_conn, tcp_connection_num); + } + + free(send); + free(recv); + return -1; + } + + GC_Peer *tmp_group = (GC_Peer *)realloc(chat->group, (chat->numpeers + 1) * sizeof(GC_Peer)); + + if (tmp_group == nullptr) { + LOGGER_ERROR(chat->log, "Failed to allocate memory for group realloc"); + + if (tcp_connection_num != -1) { + kill_tcp_connection_to(chat->tcp_conn, tcp_connection_num); + } + + free(send); + free(recv); + return -1; + } + + ++chat->numpeers; + chat->group = tmp_group; + + chat->group[peer_number] = (GC_Peer) { + 0 + }; + + GC_Connection *gconn = &chat->group[peer_number].gconn; + + gconn->send_array = send; + gconn->recv_array = recv; + + gcc_set_ip_port(gconn, ipp); + chat->group[peer_number].role = GR_USER; + chat->group[peer_number].peer_id = peer_id; + chat->group[peer_number].ignore = false; + + crypto_memlock(gconn->session_secret_key, sizeof(gconn->session_secret_key)); + + create_gc_session_keypair(chat->log, chat->rng, gconn->session_public_key, gconn->session_secret_key); + + if (peer_number > 0) { + memcpy(gconn->addr.public_key, public_key, ENC_PUBLIC_KEY_SIZE); // we get the sig key in the handshake + } else { + memcpy(gconn->addr.public_key, chat->self_public_key, EXT_PUBLIC_KEY_SIZE); + } + + const uint64_t tm = mono_time_get(chat->mono_time); + + gcc_set_send_message_id(gconn, 1); + gconn->public_key_hash = gc_get_pk_jenkins_hash(public_key); + gconn->last_received_packet_time = tm; + gconn->last_key_rotation = tm; + gconn->tcp_connection_num = tcp_connection_num; + gconn->last_sent_ip_time = tm; + gconn->last_sent_ping_time = tm - (GC_PING_TIMEOUT / 2) + (peer_number % (GC_PING_TIMEOUT / 2)); + gconn->self_is_closer = id_closest(get_chat_id(chat->chat_public_key), + get_enc_key(chat->self_public_key), + get_enc_key(gconn->addr.public_key)) == 1; + return peer_number; +} + +/** @brief Copies own peer data to `peer`. */ +non_null() +static void copy_self(const GC_Chat *chat, GC_Peer *peer) +{ + *peer = (GC_Peer) { + 0 + }; + + peer->status = gc_get_self_status(chat); + gc_get_self_nick(chat, peer->nick); + peer->nick_length = gc_get_self_nick_size(chat); + peer->role = gc_get_self_role(chat); +} + +/** @brief Returns true if we haven't received a ping from this peer after n seconds. + * n depends on whether or not the peer has been confirmed. + */ +non_null() +static bool peer_timed_out(const Mono_Time *mono_time, const GC_Connection *gconn) +{ + return mono_time_is_timeout(mono_time, gconn->last_received_packet_time, gconn->confirmed + ? GC_CONFIRMED_PEER_TIMEOUT + : GC_UNCONFIRMED_PEER_TIMEOUT); +} + +/** @brief Attempts to send pending handshake packets to peer designated by `gconn`. + * + * One request of each type can be sent per `GC_SEND_HANDSHAKE_INTERVAL` seconds. + * + * Return true on success. + */ +non_null() +static bool send_pending_handshake(const GC_Chat *chat, GC_Connection *gconn) +{ + if (chat == nullptr || gconn == nullptr) { + return false; + } + + if (gconn->is_pending_handshake_response) { + if (!mono_time_is_timeout(chat->mono_time, gconn->last_handshake_response, GC_SEND_HANDSHAKE_INTERVAL)) { + return true; + } + + gconn->last_handshake_response = mono_time_get(chat->mono_time); + + return send_gc_handshake_response(chat, gconn); + } + + if (!mono_time_is_timeout(chat->mono_time, gconn->last_handshake_request, GC_SEND_HANDSHAKE_INTERVAL)) { + return true; + } + + gconn->last_handshake_request = mono_time_get(chat->mono_time); + + if (gconn->is_oob_handshake) { + return send_gc_oob_handshake_request(chat, gconn); + } + + return send_gc_handshake_packet(chat, gconn, GH_REQUEST, gconn->pending_handshake_type, chat->join_type); +} + +#define GC_TCP_RELAY_SEND_INTERVAL (60 * 3) +non_null(1, 2) nullable(3) +static void do_peer_connections(const GC_Session *c, GC_Chat *chat, void *userdata) +{ + for (uint32_t i = 1; i < chat->numpeers; ++i) { + GC_Connection *gconn = get_gc_connection(chat, i); + assert(gconn != nullptr); + + if (gconn->pending_delete) { + continue; + } + + if (peer_timed_out(chat->mono_time, gconn)) { + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_TIMEOUT, nullptr, 0); + continue; + } + + gcc_resend_packets(chat, gconn); + + if (gconn->tcp_relays_count > 0 && + mono_time_is_timeout(chat->mono_time, gconn->last_sent_tcp_relays_time, GC_TCP_RELAY_SEND_INTERVAL)) { + if (gconn->confirmed) { + send_gc_tcp_relays(chat, gconn); + gconn->last_sent_tcp_relays_time = mono_time_get(chat->mono_time); + } + } + + gcc_check_recv_array(c, chat, gconn, i, userdata); // may change peer numbers + } +} + +/** @brief Executes pending handshakes for peers. + * + * If our peerlist is empty we periodically try to + * load peers from our saved peers list and initiate handshake requests with them. + */ +#define LOAD_PEERS_TIMEOUT (GC_UNCONFIRMED_PEER_TIMEOUT + 10) +non_null() +static void do_handshakes(GC_Chat *chat) +{ + for (uint32_t i = 1; i < chat->numpeers; ++i) { + GC_Connection *gconn = get_gc_connection(chat, i); + assert(gconn != nullptr); + + if (gconn->handshaked || gconn->pending_delete) { + continue; + } + + send_pending_handshake(chat, gconn); + } + + if (chat->numpeers <= 1) { + const uint64_t tm = mono_time_get(chat->mono_time); + + if (mono_time_is_timeout(chat->mono_time, chat->last_time_peers_loaded, LOAD_PEERS_TIMEOUT)) { + load_gc_peers(chat, chat->saved_peers, GC_MAX_SAVED_PEERS); + chat->last_time_peers_loaded = tm; + } + } +} + +/** @brief Adds `gconn` to the group timeout list. */ +non_null() +static void add_gc_peer_timeout_list(GC_Chat *chat, const GC_Connection *gconn) +{ + const size_t idx = chat->timeout_list_index; + const uint64_t tm = mono_time_get(chat->mono_time); + + copy_gc_saved_peer(chat->rng, gconn, &chat->timeout_list[idx].addr); + + chat->timeout_list[idx].last_seen = tm; + chat->timeout_list[idx].last_reconn_try = 0; + chat->timeout_list_index = (idx + 1) % MAX_GC_SAVED_TIMEOUTS; +} + +non_null(1, 2) nullable(3) +static void do_peer_delete(const GC_Session *c, GC_Chat *chat, void *userdata) +{ + for (uint32_t i = 1; i < chat->numpeers; ++i) { + const GC_Connection *gconn = get_gc_connection(chat, i); + assert(gconn != nullptr); + + if (gconn->pending_delete) { + const GC_Exit_Info *exit_info = &gconn->exit_info; + + if (exit_info->exit_type == GC_EXIT_TYPE_TIMEOUT && gconn->confirmed) { + add_gc_peer_timeout_list(chat, gconn); + } + + if (!peer_delete(c, chat, i, userdata)) { + LOGGER_ERROR(chat->log, "Failed to delete peer %u", i); + } + + if (i >= chat->numpeers) { + break; + } + } + } +} + +/** @brief Constructs and sends a ping packet to `gconn` containing info needed for group syncing + * and connection maintenance. + * + * Return true on success. + */ +non_null() +static bool ping_peer(const GC_Chat *chat, const GC_Connection *gconn) +{ + const uint16_t buf_size = GC_PING_PACKET_MIN_DATA_SIZE + sizeof(IP_Port); + uint8_t *data = (uint8_t *)malloc(buf_size); + + if (data == nullptr) { + return false; + } + + const uint16_t roles_checksum = chat->moderation.sanctions_creds.checksum + chat->roles_checksum; + uint16_t packed_len = 0; + + net_pack_u16(data, chat->peers_checksum); + packed_len += sizeof(uint16_t); + + net_pack_u16(data + packed_len, get_gc_confirmed_numpeers(chat)); + packed_len += sizeof(uint16_t); + + net_pack_u32(data + packed_len, chat->shared_state.version); + packed_len += sizeof(uint32_t); + + net_pack_u32(data + packed_len, chat->moderation.sanctions_creds.version); + packed_len += sizeof(uint32_t); + + net_pack_u16(data + packed_len, roles_checksum); + packed_len += sizeof(uint16_t); + + net_pack_u32(data + packed_len, chat->topic_info.version); + packed_len += sizeof(uint32_t); + + net_pack_u16(data + packed_len, chat->topic_info.checksum); + packed_len += sizeof(uint16_t); + + if (packed_len != GC_PING_PACKET_MIN_DATA_SIZE) { + LOGGER_FATAL(chat->log, "Packed length is impossible"); + } + + if (chat->self_udp_status == SELF_UDP_STATUS_WAN && !gcc_conn_is_direct(chat->mono_time, gconn) + && mono_time_is_timeout(chat->mono_time, gconn->last_sent_ip_time, GC_SEND_IP_PORT_INTERVAL)) { + + const int packed_ipp_len = pack_ip_port(chat->log, data + buf_size - sizeof(IP_Port), sizeof(IP_Port), + &chat->self_ip_port); + + if (packed_ipp_len > 0) { + packed_len += packed_ipp_len; + } + } + + if (!send_lossy_group_packet(chat, gconn, data, packed_len, GP_PING)) { + free(data); + return true; + } + + free(data); + + return false; +} + +/** + * Sends a ping packet to peers that haven't been pinged in at least GC_PING_TIMEOUT seconds, and + * a key rotation request to peers with whom we haven't refreshed keys in at least GC_KEY_ROTATION_TIMEOUT + * seconds. + * + * Ping packet always includes your confirmed peer count, a peer list checksum, your shared state and sanctions + * list version for syncing purposes. We also occasionally try to send our own IP info to peers that we + * do not have a direct connection with. + */ +#define GC_DO_PINGS_INTERVAL 2 +non_null() +static void do_gc_ping_and_key_rotation(GC_Chat *chat) +{ + if (!mono_time_is_timeout(chat->mono_time, chat->last_ping_interval, GC_DO_PINGS_INTERVAL)) { + return; + } + + const uint64_t tm = mono_time_get(chat->mono_time); + + for (uint32_t i = 1; i < chat->numpeers; ++i) { + GC_Connection *gconn = get_gc_connection(chat, i); + assert(gconn != nullptr); + + if (!gconn->confirmed) { + continue; + } + + if (mono_time_is_timeout(chat->mono_time, gconn->last_sent_ping_time, GC_PING_TIMEOUT)) { + if (ping_peer(chat, gconn)) { + gconn->last_sent_ping_time = tm; + } + } + + if (mono_time_is_timeout(chat->mono_time, gconn->last_key_rotation, GC_KEY_ROTATION_TIMEOUT)) { + if (send_peer_key_rotation_request(chat, gconn)) { + gconn->last_key_rotation = tm; + } + } + } + + chat->last_ping_interval = tm; +} + +non_null() +static void do_new_connection_cooldown(GC_Chat *chat) +{ + if (chat->connection_O_metre == 0) { + return; + } + + const uint64_t tm = mono_time_get(chat->mono_time); + + if (chat->connection_cooldown_timer < tm) { + chat->connection_cooldown_timer = tm; + --chat->connection_O_metre; + + if (chat->connection_O_metre == 0 && chat->block_handshakes) { + chat->block_handshakes = false; + LOGGER_DEBUG(chat->log, "Unblocking handshakes"); + } + } +} + +#define TCP_RELAYS_CHECK_INTERVAL 10 +non_null(1, 2) nullable(3) +static void do_gc_tcp(const GC_Session *c, GC_Chat *chat, void *userdata) +{ + if (chat->tcp_conn == nullptr || !group_can_handle_packets(chat)) { + return; + } + + do_tcp_connections(chat->log, chat->tcp_conn, userdata); + + for (uint32_t i = 1; i < chat->numpeers; ++i) { + const GC_Connection *gconn = get_gc_connection(chat, i); + assert(gconn != nullptr); + + const bool tcp_set = !gcc_conn_is_direct(chat->mono_time, gconn); + set_tcp_connection_to_status(chat->tcp_conn, gconn->tcp_connection_num, tcp_set); + } + + if (mono_time_is_timeout(chat->mono_time, chat->last_checked_tcp_relays, TCP_RELAYS_CHECK_INTERVAL) + && tcp_connected_relays_count(chat->tcp_conn) != chat->connected_tcp_relays) { + add_tcp_relays_to_chat(c, chat); + chat->connected_tcp_relays = tcp_connected_relays_count(chat->tcp_conn); + chat->last_checked_tcp_relays = mono_time_get(chat->mono_time); + } +} + +/** + * Updates our TCP and UDP connection status and flags a new announcement if our connection has + * changed and we have either a UDP or TCP connection. + */ +#define GC_SELF_CONNECTION_CHECK_INTERVAL 5 // how often in seconds we should run this function +#define GC_SELF_REFRESH_ANNOUNCE_INTERVAL (60 * 20) // how often in seconds we force refresh our group announcement +non_null() +static void do_self_connection(const GC_Session *c, GC_Chat *chat) +{ + if (!mono_time_is_timeout(chat->mono_time, chat->last_self_announce_check, GC_SELF_CONNECTION_CHECK_INTERVAL)) { + return; + } + + const unsigned int self_udp_status = ipport_self_copy(c->messenger->dht, &chat->self_ip_port); + const bool udp_change = (chat->self_udp_status != self_udp_status) && (self_udp_status != SELF_UDP_STATUS_NONE); + + // We flag a group announce if our UDP status has changed since last run, or if our last announced TCP + // relay is no longer valid. Additionally, we will always flag an announce in the specified interval + // regardless of the prior conditions. Private groups are never announced. + if (is_public_chat(chat) && + ((udp_change || !tcp_relay_is_valid(chat->tcp_conn, chat->announced_tcp_relay_pk)) + || mono_time_is_timeout(chat->mono_time, chat->last_time_self_announce, GC_SELF_REFRESH_ANNOUNCE_INTERVAL))) { + chat->update_self_announces = true; + } + + chat->self_udp_status = (Self_UDP_Status) self_udp_status; + chat->last_self_announce_check = mono_time_get(chat->mono_time); +} + +/** @brief Attempts to initiate a new connection with peers in the timeout list. + * + * This function is not used for public groups as the DHT and group sync mechanism + * should automatically do this for us. + */ +#define TIMED_OUT_RECONN_INTERVAL 2 +non_null() +static void do_timed_out_reconn(GC_Chat *chat) +{ + if (is_public_chat(chat)) { + return; + } + + if (!mono_time_is_timeout(chat->mono_time, chat->last_timed_out_reconn_try, TIMED_OUT_RECONN_INTERVAL)) { + return; + } + + const uint64_t curr_time = mono_time_get(chat->mono_time); + + for (size_t i = 0; i < MAX_GC_SAVED_TIMEOUTS; ++i) { + GC_TimedOutPeer *timeout = &chat->timeout_list[i]; + + if (timeout->last_seen == 0 || timeout->last_seen == curr_time) { + continue; + } + + if (mono_time_is_timeout(chat->mono_time, timeout->last_seen, GC_TIMED_OUT_STALE_TIMEOUT) + || get_peer_number_of_enc_pk(chat, timeout->addr.public_key, true) != -1) { + *timeout = (GC_TimedOutPeer) { + {{ + 0 + } + } + }; + continue; + } + + if (mono_time_is_timeout(chat->mono_time, timeout->last_reconn_try, GC_TIMED_OUT_RECONN_TIMEOUT)) { + if (load_gc_peers(chat, &timeout->addr, 1) != 1) { + LOGGER_WARNING(chat->log, "Failed to load timed out peer"); + } + + timeout->last_reconn_try = curr_time; + } + } + + chat->last_timed_out_reconn_try = curr_time; +} + +void do_gc(GC_Session *c, void *userdata) +{ + if (c == nullptr) { + return; + } + + for (uint32_t i = 0; i < c->chats_index; ++i) { + GC_Chat *chat = &c->chats[i]; + + const GC_Conn_State state = chat->connection_state; + + if (state == CS_NONE) { + continue; + } + + if (state != CS_DISCONNECTED) { + do_peer_connections(c, chat, userdata); + do_gc_tcp(c, chat, userdata); + do_handshakes(chat); + do_self_connection(c, chat); + } + + if (chat->connection_state == CS_CONNECTED) { + do_gc_ping_and_key_rotation(chat); + do_timed_out_reconn(chat); + } + + do_new_connection_cooldown(chat); + do_peer_delete(c, chat, userdata); + } +} + +/** @brief Set the size of the groupchat list to n. + * + * Return true on success. + */ +non_null() +static bool realloc_groupchats(GC_Session *c, uint32_t n) +{ + if (n == 0) { + free(c->chats); + c->chats = nullptr; + return true; + } + + GC_Chat *temp = (GC_Chat *)realloc(c->chats, n * sizeof(GC_Chat)); + + if (temp == nullptr) { + return false; + } + + c->chats = temp; + return true; +} + +non_null() +static int get_new_group_index(GC_Session *c) +{ + if (c == nullptr) { + return -1; + } + + for (uint32_t i = 0; i < c->chats_index; ++i) { + if (c->chats[i].connection_state == CS_NONE) { + return i; + } + } + + if (!realloc_groupchats(c, c->chats_index + 1)) { + return -1; + } + + const int new_index = c->chats_index; + + c->chats[new_index] = empty_gc_chat; + + memset(&c->chats[new_index].saved_invites, -1, sizeof(c->chats[new_index].saved_invites)); + + ++c->chats_index; + + return new_index; +} + +/** Attempts to associate new TCP relays with our group connection. */ +static void add_tcp_relays_to_chat(const GC_Session *c, GC_Chat *chat) +{ + const Messenger *m = c->messenger; + + const uint32_t num_relays = tcp_connections_count(nc_get_tcp_c(m->net_crypto)); + + if (num_relays == 0) { + return; + } + + Node_format *tcp_relays = (Node_format *)calloc(num_relays, sizeof(Node_format)); + + if (tcp_relays == nullptr) { + return; + } + + const uint32_t num_copied = tcp_copy_connected_relays(nc_get_tcp_c(m->net_crypto), tcp_relays, (uint16_t)num_relays); + + for (uint32_t i = 0; i < num_copied; ++i) { + add_tcp_relay_global(chat->tcp_conn, &tcp_relays[i].ip_port, tcp_relays[i].public_key); + } + + free(tcp_relays); +} + +non_null() +static bool init_gc_tcp_connection(const GC_Session *c, GC_Chat *chat) +{ + const Messenger *m = c->messenger; + + chat->tcp_conn = new_tcp_connections(chat->log, chat->rng, m->ns, chat->mono_time, chat->self_secret_key, + &m->options.proxy_info); + + if (chat->tcp_conn == nullptr) { + return false; + } + + add_tcp_relays_to_chat(c, chat); + + set_packet_tcp_connection_callback(chat->tcp_conn, &handle_gc_tcp_packet, c->messenger); + set_oob_packet_tcp_connection_callback(chat->tcp_conn, &handle_gc_tcp_oob_packet, c->messenger); + + return true; +} + +/** Initializes default shared state values. */ +non_null() +static void init_gc_shared_state(GC_Chat *chat, const Group_Privacy_State privacy_state) +{ + chat->shared_state.maxpeers = MAX_GC_PEERS_DEFAULT; + chat->shared_state.privacy_state = privacy_state; + chat->shared_state.topic_lock = GC_TOPIC_LOCK_ENABLED; + chat->shared_state.voice_state = GV_ALL; +} + +/** @brief Initializes the group shared state for the founder. + * + * Return true on success. + */ +non_null() +static bool init_gc_shared_state_founder(GC_Chat *chat, Group_Privacy_State privacy_state, const uint8_t *group_name, + uint16_t name_length) +{ + memcpy(chat->shared_state.founder_public_key, chat->self_public_key, EXT_PUBLIC_KEY_SIZE); + memcpy(chat->shared_state.group_name, group_name, name_length); + chat->shared_state.group_name_len = name_length; + chat->shared_state.privacy_state = privacy_state; + + return sign_gc_shared_state(chat); +} + +/** @brief Initializes shared state for moderation object. + * + * This must be called before any moderation + * or sanctions related operations. + */ +non_null() +static void init_gc_moderation(GC_Chat *chat) +{ + memcpy(chat->moderation.founder_public_sig_key, + get_sig_pk(chat->shared_state.founder_public_key), SIG_PUBLIC_KEY_SIZE); + memcpy(chat->moderation.self_public_sig_key, get_sig_pk(chat->self_public_key), SIG_PUBLIC_KEY_SIZE); + memcpy(chat->moderation.self_secret_sig_key, get_sig_pk(chat->self_secret_key), SIG_SECRET_KEY_SIZE); + chat->moderation.shared_state_version = chat->shared_state.version; + chat->moderation.log = chat->log; +} + +non_null() +static bool create_new_chat_ext_keypair(GC_Chat *chat); + +non_null() +static int create_new_group(GC_Session *c, const uint8_t *nick, size_t nick_length, bool founder, + const Group_Privacy_State privacy_state) +{ + if (nick == nullptr || nick_length == 0) { + return -1; + } + + if (nick_length > MAX_GC_NICK_SIZE) { + return -1; + } + + const int group_number = get_new_group_index(c); + + if (group_number == -1) { + return -1; + } + + Messenger *m = c->messenger; + GC_Chat *chat = &c->chats[group_number]; + + chat->log = m->log; + chat->rng = m->rng; + + const uint64_t tm = mono_time_get(m->mono_time); + + chat->group_number = group_number; + chat->numpeers = 0; + chat->connection_state = CS_CONNECTING; + chat->net = m->net; + chat->mono_time = m->mono_time; + chat->last_ping_interval = tm; + chat->friend_connection_id = -1; + + if (!create_new_chat_ext_keypair(chat)) { + LOGGER_ERROR(chat->log, "Failed to create extended keypair"); + group_delete(c, chat); + return -1; + } + + if (!init_gc_tcp_connection(c, chat)) { + group_delete(c, chat); + return -1; + } + + if (peer_add(chat, nullptr, chat->self_public_key) != 0) { /* you are always peer_number/index 0 */ + group_delete(c, chat); + return -1; + } + + if (!self_gc_set_nick(chat, nick, (uint16_t)nick_length)) { + group_delete(c, chat); + return -1; + } + + self_gc_set_status(chat, GS_NONE); + self_gc_set_role(chat, founder ? GR_FOUNDER : GR_USER); + self_gc_set_confirmed(chat, true); + self_gc_set_ext_public_key(chat, chat->self_public_key); + + init_gc_shared_state(chat, privacy_state); + init_gc_moderation(chat); + + return group_number; +} + +/** @brief Inits the sanctions list credentials. + * + * This should be called by the group founder on creation. + * + * This function must be called after `init_gc_moderation()`. + * + * Return true on success. + */ +non_null() +static bool init_gc_sanctions_creds(GC_Chat *chat) +{ + return sanctions_list_make_creds(&chat->moderation); +} + +/** @brief Attempts to add `num_addrs` peers from `addrs` to our peerlist and initiate invite requests + * for all of them. + * + * Returns the number of peers successfully loaded. + */ +static size_t load_gc_peers(GC_Chat *chat, const GC_SavedPeerInfo *addrs, uint16_t num_addrs) +{ + size_t count = 0; + + for (size_t i = 0; i < num_addrs; ++i) { + if (!saved_peer_is_valid(&addrs[i])) { + continue; + } + + const bool ip_port_is_set = ipport_isset(&addrs[i].ip_port); + const IP_Port *ip_port = ip_port_is_set ? &addrs[i].ip_port : nullptr; + + const int peer_number = peer_add(chat, ip_port, addrs[i].public_key); + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + continue; + } + + add_tcp_relay_global(chat->tcp_conn, &addrs[i].tcp_relay.ip_port, addrs[i].tcp_relay.public_key); + + const int add_tcp_result = add_tcp_relay_connection(chat->tcp_conn, gconn->tcp_connection_num, + &addrs[i].tcp_relay.ip_port, + addrs[i].tcp_relay.public_key); + + if (add_tcp_result == -1 && !ip_port_is_set) { + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_DISCONNECTED, nullptr, 0); + continue; + } + + if (add_tcp_result == 0) { + const int save_tcp_result = gcc_save_tcp_relay(chat->rng, gconn, &addrs[i].tcp_relay); + + if (save_tcp_result == -1) { + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_DISCONNECTED, nullptr, 0); + continue; + } + + memcpy(gconn->oob_relay_pk, addrs[i].tcp_relay.public_key, CRYPTO_PUBLIC_KEY_SIZE); + } + + const uint64_t tm = mono_time_get(chat->mono_time); + + gconn->is_oob_handshake = !gcc_direct_conn_is_possible(chat, gconn); + gconn->is_pending_handshake_response = false; + gconn->pending_handshake_type = HS_INVITE_REQUEST; + gconn->last_received_packet_time = tm; + gconn->last_key_rotation = tm; + + ++count; + } + + update_gc_peer_roles(chat); + + return count; +} + +void gc_group_save(const GC_Chat *chat, Bin_Pack *bp) +{ + gc_save_pack_group(chat, bp); +} + +int gc_group_load(GC_Session *c, Bin_Unpack *bu) +{ + const int group_number = get_new_group_index(c); + + if (group_number < 0) { + return -1; + } + + const uint64_t tm = mono_time_get(c->messenger->mono_time); + + Messenger *m = c->messenger; + GC_Chat *chat = &c->chats[group_number]; + + chat->group_number = group_number; + chat->numpeers = 0; + chat->net = m->net; + chat->mono_time = m->mono_time; + chat->log = m->log; + chat->rng = m->rng; + chat->last_ping_interval = tm; + chat->friend_connection_id = -1; + + if (!gc_load_unpack_group(chat, bu)) { + LOGGER_ERROR(chat->log, "Failed to unpack group"); + return -1; + } + + init_gc_moderation(chat); + + if (!init_gc_tcp_connection(c, chat)) { + LOGGER_ERROR(chat->log, "Failed to init tcp connection"); + return -1; + } + + if (chat->connection_state == CS_DISCONNECTED) { + return group_number; + } + + if (is_public_chat(chat)) { + if (!m_create_group_connection(m, chat)) { + LOGGER_ERROR(chat->log, "Failed to initialize group friend connection"); + } + } + + return group_number; +} + +int gc_group_add(GC_Session *c, Group_Privacy_State privacy_state, const uint8_t *group_name, + uint16_t group_name_length, + const uint8_t *nick, size_t nick_length) +{ + if (group_name_length > MAX_GC_GROUP_NAME_SIZE) { + return -1; + } + + if (nick_length > MAX_GC_NICK_SIZE) { + return -1; + } + + if (group_name_length == 0 || group_name == nullptr) { + return -2; + } + + if (nick_length == 0 || nick == nullptr) { + return -2; + } + + const int group_number = create_new_group(c, nick, nick_length, true, privacy_state); + + if (group_number == -1) { + return -3; + } + + GC_Chat *chat = gc_get_group(c, group_number); + + if (chat == nullptr) { + return -3; + } + + crypto_memlock(chat->chat_secret_key, sizeof(chat->chat_secret_key)); + + create_extended_keypair(chat->chat_public_key, chat->chat_secret_key); + + if (!init_gc_shared_state_founder(chat, privacy_state, group_name, group_name_length)) { + group_delete(c, chat); + return -4; + } + + init_gc_moderation(chat); + + if (!init_gc_sanctions_creds(chat)) { + group_delete(c, chat); + return -4; + } + + if (gc_set_topic(chat, nullptr, 0) != 0) { + group_delete(c, chat); + return -4; + } + + chat->join_type = HJ_PRIVATE; + chat->connection_state = CS_CONNECTED; + chat->time_connected = mono_time_get(c->messenger->mono_time); + + if (is_public_chat(chat)) { + if (!m_create_group_connection(c->messenger, chat)) { + LOGGER_ERROR(chat->log, "Failed to initialize group friend connection"); + group_delete(c, chat); + return -5; + } + + chat->join_type = HJ_PUBLIC; + } + + update_gc_peer_roles(chat); + + return group_number; +} + +int gc_group_join(GC_Session *c, const uint8_t *chat_id, const uint8_t *nick, size_t nick_length, const uint8_t *passwd, + uint16_t passwd_len) +{ + if (chat_id == nullptr || group_exists(c, chat_id) || getfriend_id(c->messenger, chat_id) != -1) { + return -2; + } + + if (nick_length > MAX_GC_NICK_SIZE) { + return -3; + } + + if (nick == nullptr || nick_length == 0) { + return -4; + } + + const int group_number = create_new_group(c, nick, nick_length, false, GI_PUBLIC); + + if (group_number == -1) { + return -1; + } + + GC_Chat *chat = gc_get_group(c, group_number); + + if (chat == nullptr) { + return -1; + } + + if (!expand_chat_id(chat->chat_public_key, chat_id)) { + group_delete(c, chat); + return -1; + } + + chat->connection_state = CS_CONNECTING; + + if (passwd != nullptr && passwd_len > 0) { + if (!set_gc_password_local(chat, passwd, passwd_len)) { + group_delete(c, chat); + return -5; + } + } + + if (!m_create_group_connection(c->messenger, chat)) { + group_delete(c, chat); + return -6; + } + + update_gc_peer_roles(chat); + + return group_number; +} + +bool gc_disconnect_from_group(const GC_Session *c, GC_Chat *chat) +{ + if (c == nullptr || chat == nullptr) { + return false; + } + + chat->connection_state = CS_DISCONNECTED; + + send_gc_broadcast_message(chat, nullptr, 0, GM_PEER_EXIT); + + for (uint32_t i = 1; i < chat->numpeers; ++i) { + GC_Connection *gconn = get_gc_connection(chat, i); + assert(gconn != nullptr); + + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_SELF_DISCONNECTED, nullptr, 0); + } + + return true; +} + +int gc_rejoin_group(GC_Session *c, GC_Chat *chat) +{ + if (c == nullptr || chat == nullptr) { + return -1; + } + + chat->time_connected = 0; + + if (group_can_handle_packets(chat)) { + send_gc_self_exit(chat, nullptr, 0); + } + + for (uint32_t i = 1; i < chat->numpeers; ++i) { + GC_Connection *gconn = get_gc_connection(chat, i); + assert(gconn != nullptr); + + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_SELF_DISCONNECTED, nullptr, 0); + } + + if (is_public_chat(chat)) { + kill_group_friend_connection(c, chat); + + if (!m_create_group_connection(c->messenger, chat)) { + LOGGER_WARNING(chat->log, "Failed to create new messenger connection for group"); + return -2; + } + + chat->update_self_announces = true; + } + + chat->connection_state = CS_CONNECTING; + + return 0; +} + +bool group_not_added(const GC_Session *c, const uint8_t *chat_id, uint32_t length) +{ + if (length < CHAT_ID_SIZE) { + return false; + } + + return !group_exists(c, chat_id); +} + +int gc_invite_friend(const GC_Session *c, GC_Chat *chat, int32_t friend_number, + gc_send_group_invite_packet_cb *callback) +{ + if (!friend_is_valid(c->messenger, friend_number)) { + return -1; + } + + const uint16_t group_name_length = chat->shared_state.group_name_len; + + assert(group_name_length <= MAX_GC_GROUP_NAME_SIZE); + + uint8_t *packet = (uint8_t *)malloc(2 + CHAT_ID_SIZE + ENC_PUBLIC_KEY_SIZE + group_name_length); + + if (packet == nullptr) { + return -1; + } + + packet[0] = GP_FRIEND_INVITE; + packet[1] = GROUP_INVITE; + + memcpy(packet + 2, get_chat_id(chat->chat_public_key), CHAT_ID_SIZE); + uint16_t length = 2 + CHAT_ID_SIZE; + + memcpy(packet + length, chat->self_public_key, ENC_PUBLIC_KEY_SIZE); + length += ENC_PUBLIC_KEY_SIZE; + + + memcpy(packet + length, chat->shared_state.group_name, group_name_length); + length += group_name_length; + + assert(length <= MAX_GC_PACKET_SIZE); + + if (!callback(c->messenger, friend_number, packet, length)) { + free(packet); + return -2; + } + + free(packet); + + chat->saved_invites[chat->saved_invites_index] = friend_number; + chat->saved_invites_index = (chat->saved_invites_index + 1) % MAX_GC_SAVED_INVITES; + + return 0; +} + +/** @brief Sends an invite accepted packet to `friend_number`. + * + * Return 0 on success. + * Return -1 if `friend_number` does not designate a valid friend. + * Return -2 if `chat `is null. + * Return -3 if packet failed to send. + */ +non_null() +static int send_gc_invite_accepted_packet(const Messenger *m, const GC_Chat *chat, uint32_t friend_number) +{ + if (!friend_is_valid(m, friend_number)) { + return -1; + } + + if (chat == nullptr) { + return -2; + } + + uint8_t packet[1 + 1 + CHAT_ID_SIZE + ENC_PUBLIC_KEY_SIZE]; + packet[0] = GP_FRIEND_INVITE; + packet[1] = GROUP_INVITE_ACCEPTED; + + memcpy(packet + 2, get_chat_id(chat->chat_public_key), CHAT_ID_SIZE); + uint16_t length = 2 + CHAT_ID_SIZE; + + memcpy(packet + length, chat->self_public_key, ENC_PUBLIC_KEY_SIZE); + length += ENC_PUBLIC_KEY_SIZE; + + if (!send_group_invite_packet(m, friend_number, packet, length)) { + LOGGER_ERROR(chat->log, "Failed to send group invite packet."); + return -3; + } + + return 0; +} + +/** @brief Sends an invite confirmed packet to friend designated by `friend_number`. + * + * `data` must contain the group's Chat ID, the sender's public encryption key, + * and either the sender's packed IP_Port, or at least one packed TCP node that + * the sender can be connected to through (or both). + * + * Return true on success. + */ +non_null() +static bool send_gc_invite_confirmed_packet(const Messenger *m, const GC_Chat *chat, uint32_t friend_number, + const uint8_t *data, uint16_t length) +{ + if (!friend_is_valid(m, friend_number)) { + return false; + } + + if (chat == nullptr) { + return false; + } + + if (length > MAX_GC_PACKET_SIZE) { + return false; + } + + const uint16_t packet_length = 2 + length; + uint8_t *packet = (uint8_t *)malloc(packet_length); + + if (packet == nullptr) { + return false; + } + + packet[0] = GP_FRIEND_INVITE; + packet[1] = GROUP_INVITE_CONFIRMATION; + + memcpy(packet + 2, data, length); + + if (!send_group_invite_packet(m, friend_number, packet, packet_length)) { + free(packet); + return false; + } + + free(packet); + + return true; +} + +/** @brief Adds `num_nodes` tcp relays from `tcp_relays` to tcp relays list associated with `gconn` + * + * Returns the number of relays successfully added. + */ +non_null() +static uint32_t add_gc_tcp_relays(const GC_Chat *chat, GC_Connection *gconn, const Node_format *tcp_relays, + size_t num_nodes) +{ + uint32_t relays_added = 0; + + for (size_t i = 0; i < num_nodes; ++i) { + const int add_tcp_result = add_tcp_relay_connection(chat->tcp_conn, + gconn->tcp_connection_num, &tcp_relays[i].ip_port, + tcp_relays[i].public_key); + + if (add_tcp_result == 0) { + if (gcc_save_tcp_relay(chat->rng, gconn, &tcp_relays[i]) == 0) { + ++relays_added; + } + } + } + + return relays_added; +} + +non_null() +static bool copy_friend_ip_port_to_gconn(const Messenger *m, int friend_number, GC_Connection *gconn) +{ + if (!friend_is_valid(m, friend_number)) { + return false; + } + + const Friend *f = &m->friendlist[friend_number]; + const int friend_connection_id = f->friendcon_id; + const Friend_Conn *connection = get_conn(m->fr_c, friend_connection_id); + + if (connection == nullptr) { + return false; + } + + const IP_Port *friend_ip_port = friend_conn_get_dht_ip_port(connection); + + if (!ipport_isset(friend_ip_port)) { + return false; + } + + gconn->addr.ip_port = *friend_ip_port; + + return true; +} + +int handle_gc_invite_confirmed_packet(const GC_Session *c, int friend_number, const uint8_t *data, uint16_t length) +{ + if (length < GC_JOIN_DATA_LENGTH) { + return -1; + } + + if (!friend_is_valid(c->messenger, friend_number)) { + return -4; + } + + uint8_t chat_id[CHAT_ID_SIZE]; + uint8_t invite_chat_pk[ENC_PUBLIC_KEY_SIZE]; + + memcpy(chat_id, data, CHAT_ID_SIZE); + memcpy(invite_chat_pk, data + CHAT_ID_SIZE, ENC_PUBLIC_KEY_SIZE); + + const GC_Chat *chat = gc_get_group_by_public_key(c, chat_id); + + if (chat == nullptr) { + return -2; + } + + const int peer_number = get_peer_number_of_enc_pk(chat, invite_chat_pk, false); + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return -3; + } + + Node_format tcp_relays[GCC_MAX_TCP_SHARED_RELAYS]; + const int num_nodes = unpack_nodes(tcp_relays, GCC_MAX_TCP_SHARED_RELAYS, + nullptr, data + ENC_PUBLIC_KEY_SIZE + CHAT_ID_SIZE, + length - GC_JOIN_DATA_LENGTH, true); + + const bool copy_ip_port_result = copy_friend_ip_port_to_gconn(c->messenger, friend_number, gconn); + + uint32_t tcp_relays_added = 0; + + if (num_nodes > 0) { + tcp_relays_added = add_gc_tcp_relays(chat, gconn, tcp_relays, num_nodes); + } else { + LOGGER_WARNING(chat->log, "Invite confirm packet did not contain any TCP relays"); + } + + if (tcp_relays_added == 0 && !copy_ip_port_result) { + LOGGER_ERROR(chat->log, "Got invalid connection info from peer"); + return -5; + } + + gconn->pending_handshake_type = HS_INVITE_REQUEST; + + return 0; +} + +/** Return true if we have a pending sent invite for our friend designated by `friend_number`. */ +non_null() +static bool friend_was_invited(const Messenger *m, GC_Chat *chat, int friend_number) +{ + for (size_t i = 0; i < MAX_GC_SAVED_INVITES; ++i) { + if (chat->saved_invites[i] == friend_number) { + chat->saved_invites[i] = -1; + return friend_is_valid(m, friend_number); + } + } + + return false; +} + +bool handle_gc_invite_accepted_packet(const GC_Session *c, int friend_number, const uint8_t *data, uint16_t length) +{ + if (length < GC_JOIN_DATA_LENGTH) { + return false; + } + + const Messenger *m = c->messenger; + + const uint8_t *chat_id = data; + + GC_Chat *chat = gc_get_group_by_public_key(c, chat_id); + + if (chat == nullptr || !group_can_handle_packets(chat)) { + return false; + } + + const uint8_t *invite_chat_pk = data + CHAT_ID_SIZE; + + const int peer_number = peer_add(chat, nullptr, invite_chat_pk); + + if (!friend_was_invited(m, chat, friend_number)) { + return false; + } + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return false; + } + + Node_format tcp_relays[GCC_MAX_TCP_SHARED_RELAYS]; + const uint32_t num_tcp_relays = tcp_copy_connected_relays(chat->tcp_conn, tcp_relays, GCC_MAX_TCP_SHARED_RELAYS); + + const bool copy_ip_port_result = copy_friend_ip_port_to_gconn(m, friend_number, gconn); + + if (num_tcp_relays == 0 && !copy_ip_port_result) { + return false; + } + + uint16_t len = GC_JOIN_DATA_LENGTH; + uint8_t out_data[GC_JOIN_DATA_LENGTH + (GCC_MAX_TCP_SHARED_RELAYS * PACKED_NODE_SIZE_IP6)]; + + memcpy(out_data, chat_id, CHAT_ID_SIZE); + memcpy(out_data + CHAT_ID_SIZE, chat->self_public_key, ENC_PUBLIC_KEY_SIZE); + + if (num_tcp_relays > 0) { + const uint32_t tcp_relays_added = add_gc_tcp_relays(chat, gconn, tcp_relays, num_tcp_relays); + + if (tcp_relays_added == 0 && !copy_ip_port_result) { + LOGGER_ERROR(chat->log, "Got invalid connection info from peer"); + return false; + } + + const int nodes_len = pack_nodes(chat->log, out_data + len, sizeof(out_data) - len, tcp_relays, + (uint16_t)num_tcp_relays); + + if (nodes_len <= 0 && !copy_ip_port_result) { + return false; + } + + len += nodes_len; + } + + return send_gc_invite_confirmed_packet(m, chat, friend_number, out_data, len); +} + +int gc_accept_invite(GC_Session *c, int32_t friend_number, const uint8_t *data, uint16_t length, const uint8_t *nick, + size_t nick_length, const uint8_t *passwd, uint16_t passwd_len) +{ + if (length < CHAT_ID_SIZE + ENC_PUBLIC_KEY_SIZE) { + return -1; + } + + if (nick_length > MAX_GC_NICK_SIZE) { + return -3; + } + + if (nick == nullptr || nick_length == 0) { + return -4; + } + + if (!friend_is_valid(c->messenger, friend_number)) { + return -6; + } + + const uint8_t *chat_id = data; + const uint8_t *invite_chat_pk = data + CHAT_ID_SIZE; + + const int group_number = create_new_group(c, nick, nick_length, false, GI_PUBLIC); + + if (group_number == -1) { + return -2; + } + + GC_Chat *chat = gc_get_group(c, group_number); + + if (chat == nullptr) { + return -2; + } + + if (!expand_chat_id(chat->chat_public_key, chat_id)) { + group_delete(c, chat); + return -2; + } + + if (passwd != nullptr && passwd_len > 0) { + if (!set_gc_password_local(chat, passwd, passwd_len)) { + group_delete(c, chat); + return -5; + } + } + + const int peer_id = peer_add(chat, nullptr, invite_chat_pk); + + if (peer_id < 0) { + return -2; + } + + chat->join_type = HJ_PRIVATE; + + if (send_gc_invite_accepted_packet(c->messenger, chat, friend_number) != 0) { + return -7; + } + + return group_number; +} + +non_null(1, 3) nullable(5) +static bool gc_handle_announce_response_callback(Onion_Client *onion_c, uint32_t sendback_num, const uint8_t *data, + size_t data_length, void *user_data); + +GC_Session *new_dht_groupchats(Messenger *m) +{ + if (m == nullptr) { + return nullptr; + } + + GC_Session *c = (GC_Session *)calloc(1, sizeof(GC_Session)); + + if (c == nullptr) { + return nullptr; + } + + c->messenger = m; + c->announces_list = m->group_announce; + + networking_registerhandler(m->net, NET_PACKET_GC_LOSSLESS, &handle_gc_udp_packet, m); + networking_registerhandler(m->net, NET_PACKET_GC_LOSSY, &handle_gc_udp_packet, m); + networking_registerhandler(m->net, NET_PACKET_GC_HANDSHAKE, &handle_gc_udp_packet, m); + onion_group_announce_register(m->onion_c, gc_handle_announce_response_callback, c); + + return c; +} + +static void group_cleanup(GC_Session *c, GC_Chat *chat) +{ + kill_group_friend_connection(c, chat); + + mod_list_cleanup(&chat->moderation); + sanctions_list_cleanup(&chat->moderation); + + if (chat->tcp_conn != nullptr) { + kill_tcp_connections(chat->tcp_conn); + } + + gcc_cleanup(chat); + + if (chat->group != nullptr) { + free(chat->group); + chat->group = nullptr; + } + + crypto_memunlock(chat->self_secret_key, sizeof(chat->self_secret_key)); + crypto_memunlock(chat->chat_secret_key, sizeof(chat->chat_secret_key)); + crypto_memunlock(chat->shared_state.password, sizeof(chat->shared_state.password)); +} + +/** Deletes chat from group chat array and cleans up. */ +static void group_delete(GC_Session *c, GC_Chat *chat) +{ + if (c == nullptr || chat == nullptr) { + if (chat != nullptr) { + LOGGER_ERROR(chat->log, "Null pointer"); + } + + return; + } + + group_cleanup(c, chat); + + c->chats[chat->group_number] = empty_gc_chat; + + uint32_t i; + + for (i = c->chats_index; i > 0; --i) { + if (c->chats[i - 1].connection_state != CS_NONE) { + break; + } + } + + if (c->chats_index != i) { + c->chats_index = i; + + if (!realloc_groupchats(c, c->chats_index)) { + LOGGER_ERROR(chat->log, "Failed to reallocate groupchats array"); + } + } +} + +int gc_group_exit(GC_Session *c, GC_Chat *chat, const uint8_t *message, uint16_t length) +{ + const int ret = group_can_handle_packets(chat) ? send_gc_self_exit(chat, message, length) : 0; + group_delete(c, chat); + return ret; +} + +void kill_dht_groupchats(GC_Session *c) +{ + if (c == nullptr) { + return; + } + + for (uint32_t i = 0; i < c->chats_index; ++i) { + GC_Chat *chat = &c->chats[i]; + + if (chat->connection_state == CS_NONE) { + continue; + } + + if (group_can_handle_packets(chat)) { + send_gc_self_exit(chat, nullptr, 0); + } + + group_cleanup(c, chat); + } + + networking_registerhandler(c->messenger->net, NET_PACKET_GC_LOSSY, nullptr, nullptr); + networking_registerhandler(c->messenger->net, NET_PACKET_GC_LOSSLESS, nullptr, nullptr); + networking_registerhandler(c->messenger->net, NET_PACKET_GC_HANDSHAKE, nullptr, nullptr); + onion_group_announce_register(c->messenger->onion_c, nullptr, nullptr); + + free(c->chats); + free(c); +} + +bool gc_group_is_valid(const GC_Chat *chat) +{ + return chat->connection_state != CS_NONE && chat->shared_state.version > 0; +} + +/** Return true if `group_number` designates an active group in session `c`. */ +static bool group_number_valid(const GC_Session *c, int group_number) +{ + if (group_number < 0 || group_number >= c->chats_index) { + return false; + } + + if (c->chats == nullptr) { + return false; + } + + return c->chats[group_number].connection_state != CS_NONE; +} + +uint32_t gc_count_groups(const GC_Session *c) +{ + uint32_t count = 0; + + for (uint32_t i = 0; i < c->chats_index; ++i) { + const GC_Chat *chat = &c->chats[i]; + + if (gc_group_is_valid(chat)) { + ++count; + } + } + + return count; +} + +GC_Chat *gc_get_group(const GC_Session *c, int group_number) +{ + if (!group_number_valid(c, group_number)) { + return nullptr; + } + + return &c->chats[group_number]; +} + +GC_Chat *gc_get_group_by_public_key(const GC_Session *c, const uint8_t *public_key) +{ + for (uint32_t i = 0; i < c->chats_index; ++i) { + GC_Chat *chat = &c->chats[i]; + + if (chat->connection_state == CS_NONE) { + continue; + } + + if (memcmp(public_key, get_chat_id(chat->chat_public_key), CHAT_ID_SIZE) == 0) { + return chat; + } + } + + return nullptr; +} + +/** Return True if chat_id exists in the session chat array */ +static bool group_exists(const GC_Session *c, const uint8_t *chat_id) +{ + for (uint32_t i = 0; i < c->chats_index; ++i) { + const GC_Chat *chat = &c->chats[i]; + + if (chat->connection_state == CS_NONE) { + continue; + } + + if (memcmp(get_chat_id(chat->chat_public_key), chat_id, CHAT_ID_SIZE) == 0) { + return true; + } + } + + return false; +} + +/** Creates a new 32-byte session encryption keypair and puts the results in `public_key` and `secret_key`. */ +static void create_gc_session_keypair(const Logger *log, const Random *rng, uint8_t *public_key, uint8_t *secret_key) +{ + if (crypto_new_keypair(rng, public_key, secret_key) != 0) { + LOGGER_FATAL(log, "Failed to create group session keypair"); + } +} + +/** + * Creates a new 64-byte extended keypair for `chat` and puts results in `self_public_key` + * and `self_secret_key` buffers. The first 32-bytes of the generated keys are used for + * encryption, while the remaining 32-bytes are used for signing. + * + * Return false if key generation fails. + */ +non_null() +static bool create_new_chat_ext_keypair(GC_Chat *chat) +{ + crypto_memlock(chat->self_secret_key, sizeof(chat->self_secret_key)); + + if (!create_extended_keypair(chat->self_public_key, chat->self_secret_key)) { + crypto_memunlock(chat->self_secret_key, sizeof(chat->self_secret_key)); + return false; + } + + return true; +} + +/** @brief Handles a group announce onion response. + * + * Return true on success. + */ +static bool gc_handle_announce_response_callback(Onion_Client *onion_c, uint32_t sendback_num, const uint8_t *data, + size_t data_length, void *user_data) +{ + const GC_Session *c = (GC_Session *)user_data; + + if (c == nullptr) { + return false; + } + + if (sendback_num == 0) { + return false; + } + + GC_Announce announces[GCA_MAX_SENT_ANNOUNCES]; + const uint8_t *gc_public_key = onion_friend_get_gc_public_key_num(onion_c, sendback_num - 1); + GC_Chat *chat = gc_get_group_by_public_key(c, gc_public_key); + + if (chat == nullptr) { + return false; + } + + const int gc_announces_count = gca_unpack_announces_list(chat->log, data, data_length, + announces, GCA_MAX_SENT_ANNOUNCES); + + if (gc_announces_count == -1) { + return false; + } + + const int added_peers = gc_add_peers_from_announces(chat, announces, gc_announces_count); + + return added_peers >= 0; +} + +/** @brief Adds TCP relays from `announce` to the TCP relays list for `gconn`. + * + * Returns the number of relays successfully added. + */ +non_null() +static uint32_t add_gc_tcp_relays_from_announce(const GC_Chat *chat, GC_Connection *gconn, const GC_Announce *announce) +{ + uint32_t added_relays = 0; + + for (uint8_t j = 0; j < announce->tcp_relays_count; ++j) { + const int add_tcp_result = add_tcp_relay_connection(chat->tcp_conn, gconn->tcp_connection_num, + &announce->tcp_relays[j].ip_port, + announce->tcp_relays[j].public_key); + + if (add_tcp_result == -1) { + continue; + } + + if (gcc_save_tcp_relay(chat->rng, gconn, &announce->tcp_relays[j]) == -1) { + continue; + } + + if (added_relays == 0) { + memcpy(gconn->oob_relay_pk, announce->tcp_relays[j].public_key, CRYPTO_PUBLIC_KEY_SIZE); + } + + ++added_relays; + } + + return added_relays; +} + +int gc_add_peers_from_announces(GC_Chat *chat, const GC_Announce *announces, uint8_t gc_announces_count) +{ + if (chat == nullptr || announces == nullptr) { + return -1; + } + + if (!is_public_chat(chat)) { + return 0; + } + + int added_peers = 0; + + for (uint8_t i = 0; i < gc_announces_count; ++i) { + const GC_Announce *announce = &announces[i]; + + if (!gca_is_valid_announce(announce)) { + continue; + } + + const bool ip_port_set = announce->ip_port_is_set; + const IP_Port *ip_port = ip_port_set ? &announce->ip_port : nullptr; + const int peer_number = peer_add(chat, ip_port, announce->peer_public_key); + + GC_Connection *gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + continue; + } + + const uint32_t added_tcp_relays = add_gc_tcp_relays_from_announce(chat, gconn, announce); + + if (!ip_port_set && added_tcp_relays == 0) { + LOGGER_ERROR(chat->log, "Got invalid announcement: %u relays, IPP set: %d", + added_tcp_relays, ip_port_set); + continue; + } + + gconn->pending_handshake_type = HS_INVITE_REQUEST; + + if (!ip_port_set) { + gconn->is_oob_handshake = true; + } + + ++added_peers; + } + + return added_peers; +} +#endif // VANILLA_NACL diff --git a/protocols/Tox/libtox/src/toxcore/group_chats.h b/protocols/Tox/libtox/src/toxcore/group_chats.h new file mode 100644 index 0000000000..821e629a64 --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/group_chats.h @@ -0,0 +1,782 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Copyright © 2016-2020 The TokTok team. + * Copyright © 2015 Tox project. + */ + +/** + * An implementation of massive text only group chats. + */ + +#ifndef GROUP_CHATS_H +#define GROUP_CHATS_H + +#include <stdbool.h> +#include <stdint.h> + +#include "TCP_connection.h" +#include "bin_pack.h" +#include "bin_unpack.h" +#include "group_announce.h" +#include "group_common.h" +#include "group_connection.h" +#include "logger.h" + +#define GC_PING_TIMEOUT 12 +#define GC_SEND_IP_PORT_INTERVAL (GC_PING_TIMEOUT * 5) +#define GC_CONFIRMED_PEER_TIMEOUT (GC_PING_TIMEOUT * 4 + 10) +#define GC_UNCONFIRMED_PEER_TIMEOUT GC_PING_TIMEOUT + +#define GC_JOIN_DATA_LENGTH (ENC_PUBLIC_KEY_SIZE + CHAT_ID_SIZE) + +/** Group topic lock states. */ +typedef enum Group_Topic_Lock { + TL_ENABLED = 0x00, // Only the Founder and moderators may set the topic + TL_DISABLED = 0x01, // Anyone except Observers may set the topic +} Group_Topic_Lock; + +/** Group moderation events. */ +typedef enum Group_Moderation_Event { + MV_KICK = 0x00, // A peer has been kicked + MV_OBSERVER = 0x01, // A peer has been demoted to Observer + MV_USER = 0x02, // A peer has been demoted or promoted to User + MV_MOD = 0x03, // A peer has been promoted to or demoted from Moderator +} Group_Moderation_Event; + +/** Messenger level group invite types */ +typedef enum Group_Invite_Message_Type { + GROUP_INVITE = 0x00, // Peer has initiated an invite + GROUP_INVITE_ACCEPTED = 0x01, // Peer has accepted the invite + GROUP_INVITE_CONFIRMATION = 0x02, // Peer has confirmed the accepted invite +} Group_Invite_Message_Type; + +/** Group join rejection types. */ +typedef enum Group_Join_Rejected { + GJ_GROUP_FULL = 0x00, + GJ_INVALID_PASSWORD = 0x01, + GJ_INVITE_FAILED = 0x02, + GJ_INVALID = 0x03, +} Group_Join_Rejected; + +/** Group broadcast packet types */ +typedef enum Group_Broadcast_Type { + GM_STATUS = 0x00, // Peer changed their status + GM_NICK = 0x01, // Peer changed their nickname + GM_PLAIN_MESSAGE = 0x02, // Peer sent a normal message + GM_ACTION_MESSAGE = 0x03, // Peer sent an action message + GM_PRIVATE_MESSAGE = 0x04, // Peer sent a private message + GM_PEER_EXIT = 0x05, // Peer left the group + GM_KICK_PEER = 0x06, // Peer was kicked from the group + GM_SET_MOD = 0x07, // Peer was promoted to or demoted from Moderator role + GM_SET_OBSERVER = 0x08, // Peer was demoted to or promoted from Observer role +} Group_Broadcast_Type; + +/*** + * Group packet types. + * + * For a detailed spec, see docs/DHT_Group_Chats_Packet_Spec.md + */ +typedef enum Group_Packet_Type { + /* lossy packets (ID 0 is reserved) */ + GP_PING = 0x01, + GP_MESSAGE_ACK = 0x02, + GP_INVITE_RESPONSE_REJECT = 0x03, + + /* lossless packets */ + GP_CUSTOM_PRIVATE_PACKET = 0xee, + GP_FRAGMENT = 0xef, + GP_KEY_ROTATION = 0xf0, + GP_TCP_RELAYS = 0xf1, + GP_CUSTOM_PACKET = 0xf2, + GP_BROADCAST = 0xf3, + GP_PEER_INFO_REQUEST = 0xf4, + GP_PEER_INFO_RESPONSE = 0xf5, + GP_INVITE_REQUEST = 0xf6, + GP_INVITE_RESPONSE = 0xf7, + GP_SYNC_REQUEST = 0xf8, + GP_SYNC_RESPONSE = 0xf9, + GP_TOPIC = 0xfa, + GP_SHARED_STATE = 0xfb, + GP_MOD_LIST = 0xfc, + GP_SANCTIONS_LIST = 0xfd, + GP_FRIEND_INVITE = 0xfe, + GP_HS_RESPONSE_ACK = 0xff, +} Group_Packet_Type; + +/** Lossless message acknowledgement types. */ +typedef enum Group_Message_Ack_Type { + GR_ACK_RECV = 0x00, // indicates a message has been received + GR_ACK_REQ = 0x01, // indicates a message needs to be re-sent +} Group_Message_Ack_Type; + +/** @brief Returns the GC_Connection object associated with `peer_number`. + * Returns null if peer_number does not designate a valid peer. + */ +non_null() +GC_Connection *get_gc_connection(const GC_Chat *chat, int peer_number); + +/** @brief Returns the jenkins hash of a 32 byte public encryption key. */ +non_null() +uint32_t gc_get_pk_jenkins_hash(const uint8_t *public_key); + +/** @brief Check if peer with the public encryption key is in peer list. + * + * Returns the peer number if peer is in the peer list. + * Returns -1 if peer is not in the peer list. + * + * If `confirmed` is true the peer number will only be returned if the peer is confirmed. + */ +non_null() +int get_peer_number_of_enc_pk(const GC_Chat *chat, const uint8_t *public_enc_key, bool confirmed); + +/** @brief Encrypts `data` of size `length` using the peer's shared key and a new nonce. + * + * Adds encrypted header consisting of: packet type, message_id (only for lossless packets). + * Adds plaintext header consisting of: packet identifier, self public encryption key, nonce. + * + * Return length of encrypted packet on success. + * Return -1 if plaintext length is invalid. + * Return -2 if malloc fails. + * Return -3 if encryption fails. + */ +non_null(1, 2, 3, 4, 5) nullable(7) +int group_packet_wrap( + const Logger *log, const Random *rng, const uint8_t *self_pk, const uint8_t *shared_key, uint8_t *packet, + uint16_t packet_size, const uint8_t *data, uint16_t length, uint64_t message_id, + uint8_t gp_packet_type, uint8_t net_packet_type); + +/** @brief Returns the size of a wrapped/encrypted packet with a plain size of `length`. + * + * `packet_type` should be either NET_PACKET_GC_LOSSY or NET_PACKET_GC_LOSSLESS. + */ +uint16_t gc_get_wrapped_packet_size(uint16_t length, Net_Packet_Type packet_type); + +/** @brief Sends a plain message or an action, depending on type. + * + * `length` must not exceed MAX_GC_MESSAGE_SIZE and must not be equal to zero. + * `message_id` should either point to a uint32_t or be NULL. + * + * Returns 0 on success. + * Returns -1 if the message is too long. + * Returns -2 if the message pointer is NULL or length is zero. + * Returns -3 if the message type is invalid. + * Returns -4 if the sender does not have permission to speak. + * Returns -5 if the packet fails to send. + */ +non_null(1, 2, 3, 4) nullable(5) +int gc_send_message(const GC_Chat *chat, const uint8_t *message, uint16_t length, uint8_t type, + uint32_t *message_id); + +/** @brief Sends a private message to peer_id. + * + * `length` must not exceed MAX_GC_MESSAGE_SIZE and must not be equal to zero. + * + * Returns 0 on success. + * Returns -1 if the message is too long. + * Returns -2 if the message pointer is NULL or length is zero. + * Returns -3 if the peer_id is invalid. + * Returns -4 if the message type is invalid. + * Returns -5 if the sender has the observer role. + * Returns -6 if the packet fails to send. + */ +non_null() +int gc_send_private_message(const GC_Chat *chat, uint32_t peer_id, uint8_t type, const uint8_t *message, + uint16_t length); + +/** @brief Sends a custom packet to the group. If lossless is true, the packet will be lossless. + * + * `length` must not exceed MAX_GC_MESSAGE_SIZE and must not be equal to zero. + * + * Returns 0 on success. + * Returns -1 if the message is too long. + * Returns -2 if the message pointer is NULL or length is zero. + * Returns -3 if the sender has the observer role. + */ +non_null() +int gc_send_custom_packet(const GC_Chat *chat, bool lossless, const uint8_t *data, uint16_t length); + +/** @brief Sends a custom private packet to the peer designated by peer_id. + * + * `length` must not exceed MAX_GC_MESSAGE_SIZE and must not be equal to zero. + * + * @retval 0 on success. + * @retval -1 if the message is too long. + * @retval -2 if the message pointer is NULL or length is zero. + * @retval -3 if the supplied peer_id does not designate a valid peer. + * @retval -4 if the sender has the observer role. + * @retval -5 if the packet fails to send. + */ +non_null() +int gc_send_custom_private_packet(const GC_Chat *chat, bool lossless, uint32_t peer_id, const uint8_t *message, + uint16_t length); + +/** @brief Sets ignore for peer_id. + * + * Returns 0 on success. + * Returns -1 if the peer_id is invalid. + * Returns -2 if the caller attempted to ignore himself. + */ +non_null() +int gc_set_ignore(const GC_Chat *chat, uint32_t peer_id, bool ignore); + +/** @brief Sets the group topic and broadcasts it to the group. + * + * If `length` is equal to zero the topic will be unset. + * + * Returns 0 on success. + * Returns -1 if the topic is too long (must be `<= MAX_GC_TOPIC_SIZE`). + * Returns -2 if the caller does not have the required permissions to set the topic. + * Returns -3 if the packet cannot be created or signing fails. + * Returns -4 if the packet fails + */ +non_null(1) nullable(2) +int gc_set_topic(GC_Chat *chat, const uint8_t *topic, uint16_t length); + +/** @brief Copies the group topic to `topic`. If topic is null this function has no effect. + * + * Call `gc_get_topic_size` to determine the allocation size for the `topic` parameter. + * + * The data written to `topic` is equal to the data received by the last topic callback. + */ +non_null(1) nullable(2) +void gc_get_topic(const GC_Chat *chat, uint8_t *topic); + +/** @brief Returns the topic length. + * + * The return value is equal to the `length` agument received by the last topic callback. + */ +non_null() +uint16_t gc_get_topic_size(const GC_Chat *chat); + +/** @brief Copies group name to `group_name`. If `group_name` is null this function has no effect. + * + * Call `gc_get_group_name_size` to determine the allocation size for the `group_name` + * parameter. + */ +non_null() +void gc_get_group_name(const GC_Chat *chat, uint8_t *group_name); + +/** @brief Returns the group name length. */ +non_null() +uint16_t gc_get_group_name_size(const GC_Chat *chat); + +/** @brief Copies the group password to password. + * + * If password is null this function has no effect. + * + * Call the `gc_get_password_size` function to determine the allocation size for + * the `password` buffer. + * + * The data received is equal to the data received by the last password callback. + */ +non_null() +void gc_get_password(const GC_Chat *chat, uint8_t *password); + +/** @brief Returns the group password length. */ +non_null() +uint16_t gc_get_password_size(const GC_Chat *chat); + +/** @brief Returns the group privacy state. + * + * The value returned is equal to the data receieved by the last privacy_state callback. + */ +non_null() +Group_Privacy_State gc_get_privacy_state(const GC_Chat *chat); + +/** @brief Returns the group topic lock state. + * + * The value returned is equal to the data received by the last last topic_lock callback. + */ +non_null() +Group_Topic_Lock gc_get_topic_lock_state(const GC_Chat *chat); + +/** @brief Returns the group voice state. + * + * The value returned is equal to the data received by the last voice_state callback. + */ +non_null() +Group_Voice_State gc_get_voice_state(const GC_Chat *chat); + +/** @brief Returns the group peer limit. + * + * The value returned is equal to the data receieved by the last peer_limit callback. + */ +non_null() +uint16_t gc_get_max_peers(const GC_Chat *chat); + +/** @brief Sets your own nick to `nick`. + * + * `length` cannot exceed MAX_GC_NICK_SIZE. if `length` is zero or `name` is a + * null pointer the function call will fail. + * + * Returns 0 on success. + * Returns -1 if group_number is invalid. + * Returns -2 if the length is too long. + * Returns -3 if the length is zero or nick is a NULL pointer. + * Returns -4 if the packet fails to send. + */ +non_null() +int gc_set_self_nick(const Messenger *m, int group_number, const uint8_t *nick, uint16_t length); + +/** @brief Copies your own name to `nick`. + * + * If `nick` is null this function has no effect. + */ +non_null() +void gc_get_self_nick(const GC_Chat *chat, uint8_t *nick); + +/** @brief Return your own nick length. + * + * If no nick was set before calling this function it will return 0. + */ +non_null() +uint16_t gc_get_self_nick_size(const GC_Chat *chat); + +/** @brief Returns your own group role. */ +non_null() +Group_Role gc_get_self_role(const GC_Chat *chat); + +/** @brief Return your own status. */ +non_null() +uint8_t gc_get_self_status(const GC_Chat *chat); + +/** @brief Returns your own peer id. */ +non_null() +uint32_t gc_get_self_peer_id(const GC_Chat *chat); + +/** @brief Copies self public key to `public_key`. + * + * If `public_key` is null this function has no effect. + * + * This key is permanently tied to our identity for `chat` until we explicitly + * exit the group. This key is the only way for other peers to reliably identify + * us across client restarts. + */ +non_null(1) nullable(2) +void gc_get_self_public_key(const GC_Chat *chat, uint8_t *public_key); + +/** @brief Copies nick designated by `peer_id` to `name`. + * + * Call `gc_get_peer_nick_size` to determine the allocation size for the `name` parameter. + * + * The data written to `name` is equal to the data received by the last nick_change callback. + * + * Returns true on success. + * Returns false if peer_id is invalid. + */ +non_null(1) nullable(3) +bool gc_get_peer_nick(const GC_Chat *chat, uint32_t peer_id, uint8_t *name); + +/** @brief Returns the length of the nick for the peer designated by `peer_id`. + * Returns -1 if peer_id is invalid. + * + * The value returned is equal to the `length` argument received by the last + * nick_change callback. + */ +non_null() +int gc_get_peer_nick_size(const GC_Chat *chat, uint32_t peer_id); + +/** @brief Copies peer_id's public key to `public_key`. + * + * This key is permanently tied to the peer's identity for `chat` until they explicitly + * exit the group. This key is the only way for to reliably identify the given peer + * across client restarts. + * + * `public_key` shold have room for at least ENC_PUBLIC_KEY_SIZE bytes. + * + * Returns 0 on success. + * Returns -1 if peer_id is invalid or doesn't correspond to a valid peer connection. + * Returns -2 if `public_key` is null. + */ +non_null(1) nullable(3) +int gc_get_peer_public_key_by_peer_id(const GC_Chat *chat, uint32_t peer_id, uint8_t *public_key); + +/** @brief Gets the connection status for peer associated with `peer_id`. + * + * Returns 2 if we have a direct (UDP) connection with a peer. + * Returns 1 if we have an indirect (TCP) connection with a peer. + * Returns 0 if peer_id is invalid or corresponds to ourselves. + * + * Note: Return values must correspond to Tox_Connection enum in API. + */ +non_null() +unsigned int gc_get_peer_connection_status(const GC_Chat *chat, uint32_t peer_id); + +/** @brief Sets the caller's status to `status`. + * + * Returns 0 on success. + * Returns -1 if the group_number is invalid. + * Returns -2 if the packet failed to send. + */ +non_null() +int gc_set_self_status(const Messenger *m, int group_number, Group_Peer_Status status); + +/** @brief Returns the status of peer designated by `peer_id`. + * Returns UINT8_MAX on failure. + * + * The status returned is equal to the last status received through the status_change + * callback. + */ +non_null() +uint8_t gc_get_status(const GC_Chat *chat, uint32_t peer_id); + +/** @brief Returns the group role of peer designated by `peer_id`. + * Returns UINT8_MAX on failure. + * + * The role returned is equal to the last role received through the moderation callback. + */ +non_null() +uint8_t gc_get_role(const GC_Chat *chat, uint32_t peer_id); + +/** @brief Sets the role of peer_id. role must be one of: GR_MODERATOR, GR_USER, GR_OBSERVER + * + * Returns 0 on success. + * Returns -1 if the group_number is invalid. + * Returns -2 if the peer_id is invalid. + * Returns -3 if caller does not have sufficient permissions for the action. + * Returns -4 if the role assignment is invalid. + * Returns -5 if the role failed to be set. + * Returns -6 if the caller attempted to kick himself. + */ +non_null() +int gc_set_peer_role(const Messenger *m, int group_number, uint32_t peer_id, Group_Role new_role); + +/** @brief Sets the group password and distributes the new shared state to the group. + * + * This function requires that the shared state be re-signed and will only work for the group founder. + * + * If `password` is null or `password_length` is 0 the password will be unset for the group. + * + * Returns 0 on success. + * Returns -1 if the caller does not have sufficient permissions for the action. + * Returns -2 if the password is too long. + * Returns -3 if the packet failed to send. + * Returns -4 if malloc failed. + */ +non_null(1) nullable(2) +int gc_founder_set_password(GC_Chat *chat, const uint8_t *password, uint16_t password_length); + +/** @brief Sets the topic lock and distributes the new shared state to the group. + * + * When the topic lock is enabled, only the group founder and moderators may set the topic. + * When disabled, all peers except those with the observer role may set the topic. + * + * This function requires that the shared state be re-signed and will only work for the group founder. + * + * Returns 0 on success. + * Returns -1 if group_number is invalid. + * Returns -2 if `topic_lock` is an invalid type. + * Returns -3 if the caller does not have sufficient permissions for this action. + * Returns -4 if the group is disconnected. + * Returns -5 if the topic lock could not be set. + * Returns -6 if the packet failed to send. + */ +non_null() +int gc_founder_set_topic_lock(const Messenger *m, int group_number, Group_Topic_Lock new_lock_state); + +/** @brief Sets the group privacy state and distributes the new shared state to the group. + * + * This function requires that the shared state be re-signed and will only work for the group founder. + * + * If an attempt is made to set the privacy state to the same state that the group is already + * in, the function call will be successful and no action will be taken. + * + * Returns 0 on success. + * Returns -1 if group_number is invalid. + * Returns -2 if the caller does not have sufficient permissions for this action. + * Returns -3 if the group is disconnected. + * Returns -4 if the privacy state could not be set. + * Returns -5 if the packet failed to send. + */ +non_null() +int gc_founder_set_privacy_state(const Messenger *m, int group_number, Group_Privacy_State new_privacy_state); + +/** @brief Sets the group voice state and distributes the new shared state to the group. + * + * This function requires that the shared state be re-signed and will only work for the group founder. + * + * If an attempt is made to set the voice state to the same state that the group is already + * in, the function call will be successful and no action will be taken. + * + * Returns 0 on success. + * Returns -1 if group_number is invalid. + * Returns -2 if the caller does not have sufficient permissions for this action. + * Returns -3 if the group is disconnected. + * Returns -4 if the voice state could not be set. + * Returns -5 if the packet failed to send. + */ +non_null() +int gc_founder_set_voice_state(const Messenger *m, int group_number, Group_Voice_State new_voice_state); + +/** @brief Sets the peer limit to maxpeers and distributes the new shared state to the group. + * + * This function requires that the shared state be re-signed and will only work for the group founder. + * + * Returns 0 on success. + * Returns -1 if the caller does not have sufficient permissions for this action. + * Returns -2 if the peer limit could not be set. + * Returns -3 if the packet failed to send. + */ +non_null() +int gc_founder_set_max_peers(GC_Chat *chat, uint16_t max_peers); + +/** @brief Removes peer designated by `peer_id` from peer list and sends a broadcast instructing + * all other peers to remove the peer from their peerlist as well. + * + * This function will not trigger the peer_exit callback for the caller. + * + * Returns 0 on success. + * Returns -1 if the group_number is invalid. + * Returns -2 if the peer_id is invalid. + * Returns -3 if the caller does not have sufficient permissions for this action. + * Returns -4 if the action failed. + * Returns -5 if the packet failed to send. + * Returns -6 if the caller attempted to kick himself. + */ +non_null() +int gc_kick_peer(const Messenger *m, int group_number, uint32_t peer_id); + +/** @brief Copies the chat_id to dest. If dest is null this function has no effect. + * + * `dest` should have room for at least CHAT_ID_SIZE bytes. + */ +non_null(1) nullable(2) +void gc_get_chat_id(const GC_Chat *chat, uint8_t *dest); + + +/** Group callbacks */ +non_null(1) nullable(2) void gc_callback_message(const Messenger *m, gc_message_cb *function); +non_null(1) nullable(2) void gc_callback_private_message(const Messenger *m, gc_private_message_cb *function); +non_null(1) nullable(2) void gc_callback_custom_packet(const Messenger *m, gc_custom_packet_cb *function); +non_null(1) nullable(2) void gc_callback_custom_private_packet(const Messenger *m, + gc_custom_private_packet_cb *function); +non_null(1) nullable(2) void gc_callback_moderation(const Messenger *m, gc_moderation_cb *function); +non_null(1) nullable(2) void gc_callback_nick_change(const Messenger *m, gc_nick_change_cb *function); +non_null(1) nullable(2) void gc_callback_status_change(const Messenger *m, gc_status_change_cb *function); +non_null(1) nullable(2) void gc_callback_topic_change(const Messenger *m, gc_topic_change_cb *function); +non_null(1) nullable(2) void gc_callback_peer_limit(const Messenger *m, gc_peer_limit_cb *function); +non_null(1) nullable(2) void gc_callback_privacy_state(const Messenger *m, gc_privacy_state_cb *function); +non_null(1) nullable(2) void gc_callback_topic_lock(const Messenger *m, gc_topic_lock_cb *function); +non_null(1) nullable(2) void gc_callback_password(const Messenger *m, gc_password_cb *function); +non_null(1) nullable(2) void gc_callback_peer_join(const Messenger *m, gc_peer_join_cb *function); +non_null(1) nullable(2) void gc_callback_peer_exit(const Messenger *m, gc_peer_exit_cb *function); +non_null(1) nullable(2) void gc_callback_self_join(const Messenger *m, gc_self_join_cb *function); +non_null(1) nullable(2) void gc_callback_rejected(const Messenger *m, gc_rejected_cb *function); +non_null(1) nullable(2) void gc_callback_voice_state(const Messenger *m, gc_voice_state_cb *function); + +/** @brief The main loop. Should be called with every Messenger iteration. */ +non_null(1) nullable(2) +void do_gc(GC_Session *c, void *userdata); + +/** + * Make sure that DHT is initialized before calling this. + * Returns a NULL pointer on failure. + */ +nullable(1) +GC_Session *new_dht_groupchats(Messenger *m); + +/** @brief Cleans up groupchat structures and calls `gc_group_exit()` for every group chat */ +nullable(1) +void kill_dht_groupchats(GC_Session *c); + +/** @brief Loads a previously saved group and attempts to join it. + * + * `bu` is the packed group info. + * + * Returns group_number on success. + * Returns -1 on failure. + */ +non_null() +int gc_group_load(GC_Session *c, Bin_Unpack *bu); + +/** + * @brief Saves info from `chat` to `bp` in binary format. + */ +non_null() +void gc_group_save(const GC_Chat *chat, Bin_Pack *bp); + +/** @brief Creates a new group and adds it to the group sessions group array. + * + * The caller of this function has founder role privileges. + * + * The client should initiate its peer list with self info after calling this function, as + * the peer_join callback will not be triggered. + * + * Return -1 if the nick or group name is too long. + * Return -2 if the nick or group name is empty. + * Return -3 if the the group object fails to initialize. + * Return -4 if the group state fails to initialize. + * Return -5 if the Messenger friend connection fails to initialize. + */ +non_null() +int gc_group_add(GC_Session *c, Group_Privacy_State privacy_state, const uint8_t *group_name, + uint16_t group_name_length, + const uint8_t *nick, size_t nick_length); + +/** @brief Joins a group designated by `chat_id`. + * + * This function creates a new GC_Chat object, adds it to the chats array, and sends a DHT + * announcement to find peers in the group associated with `chat_id`. Once a peer has been + * found a join attempt will be initiated. + * + * If the group is not password protected password should be set to NULL and password_length should be 0. + * + * Return group_number on success. + * Return -1 if the group object fails to initialize. + * Return -2 if chat_id is NULL or a group with chat_id already exists in the chats array. + * Return -3 if nick is too long. + * Return -4 if nick is empty or nick length is zero. + * Return -5 if there is an error setting the group password. + * Return -6 if the Messenger friend connection fails to initialize. + */ +non_null(1, 2, 3) nullable(5) +int gc_group_join(GC_Session *c, const uint8_t *chat_id, const uint8_t *nick, size_t nick_length, const uint8_t *passwd, + uint16_t passwd_len); + +/** @brief Disconnects from all peers in a group but saves the group state for later use. + * + * Return true on sucess. + * Return false if the group handler object or chat object is null. + */ +non_null() +bool gc_disconnect_from_group(const GC_Session *c, GC_Chat *chat); + +/** @brief Disconnects from all peers in a group and attempts to reconnect. + * + * All self state and credentials are retained. + * + * Returns 0 on success. + * Returns -1 if the group handler object or chat object is null. + * Returns -2 if the Messenger friend connection fails to initialize. + */ +non_null() +int gc_rejoin_group(GC_Session *c, GC_Chat *chat); + +/** @brief Joins a group using the invite data received in a friend's group invite. + * + * The invite is only valid while the inviter is present in the group. + * + * Return group_number on success. + * Return -1 if the invite data is malformed. + * Return -2 if the group object fails to initialize. + * Return -3 if nick is too long. + * Return -4 if nick is empty or nick length is zero. + * Return -5 if there is an error setting the password. + * Return -6 if friend doesn't exist. + * Return -7 if sending packet failed. + */ +non_null(1, 3, 5) nullable(7) +int gc_accept_invite(GC_Session *c, int32_t friend_number, const uint8_t *data, uint16_t length, const uint8_t *nick, + size_t nick_length, const uint8_t *passwd, uint16_t passwd_len); + +typedef bool gc_send_group_invite_packet_cb(const Messenger *m, uint32_t friendnumber, const uint8_t *packet, + uint16_t length); + +/** @brief Invites friend designated by `friendnumber` to chat. + * Packet includes: Type, chat_id, TCP node or packed IP_Port. + * + * Return 0 on success. + * Return -1 if friendnumber does not exist. + * Return -2 on failure to create the invite data. + * Return -3 if the packet fails to send. + */ +non_null() +int gc_invite_friend(const GC_Session *c, GC_Chat *chat, int32_t friend_number, + gc_send_group_invite_packet_cb *callback); + +/** @brief Leaves a group and sends an exit broadcast packet with an optional parting message. + * + * All group state is permanently lost, including keys and roles. + * + * Return 0 on success. + * Return -1 if the parting message is too long. + * Return -2 if the parting message failed to send. + */ +non_null(1, 2) nullable(3) +int gc_group_exit(GC_Session *c, GC_Chat *chat, const uint8_t *message, uint16_t length); + +/** @brief Returns true if `chat` is a valid group chat. + * + * A valid group chat constitutes an initialized chat instance with a non-zero shared state version. + * The shared state version will be non-zero either if a peer has created the group, or if + * they have ever successfully connected to the group. + */ +non_null() +bool gc_group_is_valid(const GC_Chat *chat); + +/** @brief Returns the number of active groups in `c`. */ +non_null() +uint32_t gc_count_groups(const GC_Session *c); + +/** @brief Returns true if peer_number exists */ +non_null() +bool gc_peer_number_is_valid(const GC_Chat *chat, int peer_number); + +/** @brief Return group_number's GC_Chat pointer on success + * Return NULL on failure + */ +non_null() +GC_Chat *gc_get_group(const GC_Session *c, int group_number); + +/** @brief Sends a lossy message acknowledgement to peer associated with `gconn`. + * + * If `type` is GR_ACK_RECV we send a read-receipt for read_id's packet. If `type` is GR_ACK_REQ + * we send a request for the respective id's packet. + * + * Requests are limited to one per second per peer. + * + * @retval true on success. + */ +non_null() +bool gc_send_message_ack(const GC_Chat *chat, GC_Connection *gconn, uint64_t message_id, Group_Message_Ack_Type type); + +/** @brief Helper function for `handle_gc_lossless_packet()`. + * + * Note: This function may modify the peer list and change peer numbers. + * + * @retval true if packet is successfully handled. + */ +non_null(1, 2) nullable(4, 7) +bool handle_gc_lossless_helper(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, const uint8_t *data, + uint16_t length, uint8_t packet_type, void *userdata); + +/** @brief Handles an invite accept packet. + * + * @retval true on success. + */ +non_null() +bool handle_gc_invite_accepted_packet(const GC_Session *c, int friend_number, const uint8_t *data, uint16_t length); + +/** @brief Return true if `chat_id` is not present in our group sessions array. + * + * `length` must be at least CHAT_ID_SIZE bytes in length. + */ +non_null() +bool group_not_added(const GC_Session *c, const uint8_t *chat_id, uint32_t length); + +/** @brief Handles an invite confirmed packet. + * + * Return 0 on success. + * Return -1 if length is invalid. + * Return -2 if data contains invalid chat_id. + * Return -3 if data contains invalid peer info. + * Return -4 if `friend_number` does not designate a valid friend. + * Return -5 if data contains invalid connection info. + */ +non_null() +int handle_gc_invite_confirmed_packet(const GC_Session *c, int friend_number, const uint8_t *data, uint16_t length); + +/** @brief Returns the group designated by `public_key`. + * Returns null if group does not exist. + */ +non_null() +GC_Chat *gc_get_group_by_public_key(const GC_Session *c, const uint8_t *public_key); + +/** @brief Attempts to add peers from `announces` to our peer list and initiate an invite request. + * + * Returns the number of peers added on success. + * Returns -1 on failure. + */ +non_null() +int gc_add_peers_from_announces(GC_Chat *chat, const GC_Announce *announces, uint8_t gc_announces_count); + +#endif // GROUP_CHATS_H diff --git a/protocols/Tox/libtox/src/toxcore/group_common.h b/protocols/Tox/libtox/src/toxcore/group_common.h new file mode 100644 index 0000000000..ef901e8a3a --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/group_common.h @@ -0,0 +1,409 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Copyright © 2016-2022 The TokTok team. + */ + +/** + * Common groupchat data structures. + */ + +#ifndef GROUP_COMMON_H +#define GROUP_COMMON_H + +#include <stdbool.h> +#include <stdint.h> + +#include "DHT.h" +#include "TCP_connection.h" +#include "group_moderation.h" + +#define MAX_GC_PART_MESSAGE_SIZE 128 +#define MAX_GC_NICK_SIZE 128 +#define MAX_GC_TOPIC_SIZE 512 +#define MAX_GC_GROUP_NAME_SIZE 48 +#define GC_MESSAGE_PSEUDO_ID_SIZE 4 +#define GROUP_MAX_MESSAGE_LENGTH 1372 + +/* Max size of a packet chunk. Packets larger than this must be split up. + * + * For an explanation on why this value was chosen, see the following link: https://archive.ph/vsCOG + */ +#define MAX_GC_PACKET_CHUNK_SIZE 500 + +#define MAX_GC_MESSAGE_SIZE GROUP_MAX_MESSAGE_LENGTH +#define MAX_GC_MESSAGE_RAW_SIZE (MAX_GC_MESSAGE_SIZE + GC_MESSAGE_PSEUDO_ID_SIZE) +#define MAX_GC_CUSTOM_LOSSLESS_PACKET_SIZE 1373 +#define MAX_GC_CUSTOM_LOSSY_PACKET_SIZE MAX_GC_PACKET_CHUNK_SIZE +#define MAX_GC_PASSWORD_SIZE 32 +#define MAX_GC_SAVED_INVITES 10 +#define MAX_GC_PEERS_DEFAULT 100 +#define MAX_GC_SAVED_TIMEOUTS 12 +#define GC_MAX_SAVED_PEERS 100 +#define GC_SAVED_PEER_SIZE (ENC_PUBLIC_KEY_SIZE + sizeof(Node_format) + sizeof(IP_Port)) + +/* Max size of a complete encrypted packet including headers. */ +#define MAX_GC_PACKET_SIZE (MAX_GC_PACKET_CHUNK_SIZE * 100) + +/* Max number of messages to store in the send/recv arrays */ +#define GCC_BUFFER_SIZE 8192 + +/** Self UDP status. Must correspond to return values from `ipport_self_copy()`. */ +typedef enum Self_UDP_Status { + SELF_UDP_STATUS_NONE = 0x00, + SELF_UDP_STATUS_WAN = 0x01, + SELF_UDP_STATUS_LAN = 0x02, +} Self_UDP_Status; + +/** Group exit types. */ +typedef enum Group_Exit_Type { + GC_EXIT_TYPE_QUIT = 0x00, // Peer left the group + GC_EXIT_TYPE_TIMEOUT = 0x01, // Peer connection timed out + GC_EXIT_TYPE_DISCONNECTED = 0x02, // Peer diconnected from group + GC_EXIT_TYPE_SELF_DISCONNECTED = 0x03, // Self disconnected from group + GC_EXIT_TYPE_KICKED = 0x04, // Peer was kicked from the group + GC_EXIT_TYPE_SYNC_ERR = 0x05, // Peer failed to sync with the group + GC_EXIT_TYPE_NO_CALLBACK = 0x06, // The peer exit callback should not be triggered +} Group_Exit_Type; + +typedef struct GC_Exit_Info { + uint8_t part_message[MAX_GC_PART_MESSAGE_SIZE]; + uint16_t length; + Group_Exit_Type exit_type; +} GC_Exit_Info; + +typedef struct GC_PeerAddress { + uint8_t public_key[EXT_PUBLIC_KEY_SIZE]; + IP_Port ip_port; +} GC_PeerAddress; + +typedef struct GC_Message_Array_Entry { + uint8_t *data; + uint16_t data_length; + uint8_t packet_type; + uint64_t message_id; + uint64_t time_added; + uint64_t last_send_try; +} GC_Message_Array_Entry; + +typedef struct GC_Connection { + uint64_t send_message_id; /* message_id of the next message we send to peer */ + + uint16_t send_array_start; /* send_array index of oldest item */ + GC_Message_Array_Entry *send_array; + + uint64_t received_message_id; /* message_id of peer's last message to us */ + GC_Message_Array_Entry *recv_array; + + uint64_t last_chunk_id; /* The message ID of the last packet fragment we received */ + + GC_PeerAddress addr; /* holds peer's extended real public key and ip_port */ + uint32_t public_key_hash; /* Jenkins one at a time hash of peer's real encryption public key */ + + uint8_t session_public_key[ENC_PUBLIC_KEY_SIZE]; /* self session public key for this peer */ + uint8_t session_secret_key[ENC_SECRET_KEY_SIZE]; /* self session secret key for this peer */ + uint8_t session_shared_key[CRYPTO_SHARED_KEY_SIZE]; /* made with our session sk and peer's session pk */ + + int tcp_connection_num; + uint64_t last_sent_tcp_relays_time; /* the last time we attempted to send this peer our tcp relays */ + uint16_t tcp_relay_share_index; + uint64_t last_received_direct_time; /* the last time we received a direct UDP packet from this connection */ + uint64_t last_sent_ip_time; /* the last time we sent our ip info to this peer in a ping packet */ + + Node_format connected_tcp_relays[MAX_FRIEND_TCP_CONNECTIONS]; + uint16_t tcp_relays_count; + + uint64_t last_received_packet_time; /* The last time we successfully processed any packet from this peer */ + uint64_t last_requested_packet_time; /* The last time we requested a missing packet from this peer */ + uint64_t last_sent_ping_time; + uint64_t last_sync_response; /* the last time we sent this peer a sync response */ + uint8_t oob_relay_pk[CRYPTO_PUBLIC_KEY_SIZE]; + bool self_is_closer; /* true if we're "closer" to the chat_id than this peer (uses real pk's) */ + + bool confirmed; /* true if this peer has given us their info */ + bool handshaked; /* true if we've successfully handshaked with this peer */ + uint16_t handshake_attempts; + uint64_t last_handshake_request; + uint64_t last_handshake_response; + uint8_t pending_handshake_type; + bool is_pending_handshake_response; + bool is_oob_handshake; + + uint64_t last_key_rotation; /* the last time we rotated session keys for this peer */ + bool pending_key_rotation_request; + + bool pending_delete; /* true if this peer has been marked for deletion */ + GC_Exit_Info exit_info; +} GC_Connection; + +/*** + * Group roles. Roles are hierarchical in that each role has a set of privileges plus + * all the privileges of the roles below it. + */ +typedef enum Group_Role { + /** Group creator. All-powerful. Cannot be demoted or kicked. */ + GR_FOUNDER = 0x00, + + /** + * May promote or demote peers below them to any role below them. + * May also kick peers below them and set the topic. + */ + GR_MODERATOR = 0x01, + + /** may interact normally with the group. */ + GR_USER = 0x02, + + /** May not interact with the group but may observe. */ + GR_OBSERVER = 0x03, +} Group_Role; + +typedef enum Group_Peer_Status { + GS_NONE = 0x00, + GS_AWAY = 0x01, + GS_BUSY = 0x02, +} Group_Peer_Status; + +/** + * Group voice states. The state determines which Group Roles have permission to speak. + */ +typedef enum Group_Voice_State { + /** Every group role except Observers may speak. */ + GV_ALL = 0x00, + + /** Only Moderators and the Founder may speak. */ + GV_MODS = 0x01, + + /** Only the Founder may speak. */ + GV_FOUNDER = 0x02, +} Group_Voice_State; + +/** Group connection states. */ +typedef enum GC_Conn_State { + CS_NONE = 0x00, // Indicates a group is not initialized + CS_DISCONNECTED = 0x01, // Not receiving or sending any packets + CS_CONNECTING = 0x02, // Attempting to establish a connection with peers in the group + CS_CONNECTED = 0x03, // Has successfully received a sync response from a peer in the group +} GC_Conn_State; + +/** Group privacy states. */ +typedef enum Group_Privacy_State { + GI_PUBLIC = 0x00, // Anyone with the chat ID may join the group + GI_PRIVATE = 0x01, // Peers may only join the group via a friend invite +} Group_Privacy_State; + +/** Handshake join types. */ +typedef enum Group_Handshake_Join_Type { + HJ_PUBLIC = 0x00, // Indicates the group was joined via the DHT + HJ_PRIVATE = 0x01, // Indicates the group was joined via private friend invite +} Group_Handshake_Join_Type; + +typedef struct GC_SavedPeerInfo { + uint8_t public_key[ENC_PUBLIC_KEY_SIZE]; + Node_format tcp_relay; + IP_Port ip_port; +} GC_SavedPeerInfo; + +/** Holds info about peers who recently timed out */ +typedef struct GC_TimedOutPeer { + GC_SavedPeerInfo addr; + uint64_t last_seen; // the time the peer disconnected + uint64_t last_reconn_try; // the last time we tried to establish a new connection +} GC_TimedOutPeer; + +typedef struct GC_Peer { + /* Below state is sent to other peers in peer info exchange */ + uint8_t nick[MAX_GC_NICK_SIZE]; + uint16_t nick_length; + uint8_t status; + + /* Below state is local only */ + Group_Role role; + uint32_t peer_id; // permanent ID (used for the public API) + bool ignore; + + GC_Connection gconn; +} GC_Peer; + +typedef struct GC_SharedState { + uint32_t version; + uint8_t founder_public_key[EXT_PUBLIC_KEY_SIZE]; + uint16_t maxpeers; + uint16_t group_name_len; + uint8_t group_name[MAX_GC_GROUP_NAME_SIZE]; + Group_Privacy_State privacy_state; // GI_PUBLIC (uses DHT) or GI_PRIVATE (invite only) + uint16_t password_length; + uint8_t password[MAX_GC_PASSWORD_SIZE]; + uint8_t mod_list_hash[MOD_MODERATION_HASH_SIZE]; + uint32_t topic_lock; // equal to GC_TOPIC_LOCK_ENABLED when lock is enabled + Group_Voice_State voice_state; +} GC_SharedState; + +typedef struct GC_TopicInfo { + uint32_t version; + uint16_t length; + uint16_t checksum; // used for syncing problems. the checksum with the highest value gets priority. + uint8_t topic[MAX_GC_TOPIC_SIZE]; + uint8_t public_sig_key[SIG_PUBLIC_KEY_SIZE]; // Public signature key of the topic setter +} GC_TopicInfo; + +typedef struct GC_Chat { + Mono_Time *mono_time; + const Logger *log; + const Random *rng; + + uint32_t connected_tcp_relays; + Self_UDP_Status self_udp_status; + IP_Port self_ip_port; + + Networking_Core *net; + TCP_Connections *tcp_conn; + + uint64_t last_checked_tcp_relays; + Group_Handshake_Join_Type join_type; + + GC_Peer *group; + Moderation moderation; + + GC_Conn_State connection_state; + + GC_SharedState shared_state; + uint8_t shared_state_sig[SIGNATURE_SIZE]; // signed by founder using the chat secret key + + GC_TopicInfo topic_info; + uint8_t topic_sig[SIGNATURE_SIZE]; // signed by the peer who set the current topic + uint16_t topic_prev_checksum; // checksum of the previous topic + uint64_t topic_time_set; + + uint16_t peers_checksum; // sum of the public key hash of every confirmed peer in the group + uint16_t roles_checksum; // sum of every confirmed peer's role plus the first byte of their public key + + uint32_t numpeers; + int group_number; + + uint8_t chat_public_key[EXT_PUBLIC_KEY_SIZE]; // the chat_id is the sig portion + uint8_t chat_secret_key[EXT_SECRET_KEY_SIZE]; // only used by the founder + + uint8_t self_public_key[EXT_PUBLIC_KEY_SIZE]; + uint8_t self_secret_key[EXT_SECRET_KEY_SIZE]; + + uint64_t time_connected; + uint64_t last_ping_interval; + uint64_t last_sync_request; // The last time we sent a sync request to any peer + uint64_t last_sync_response_peer_list; // The last time we sent the peer list to any peer + uint64_t last_time_peers_loaded; + + /* keeps track of frequency of new inbound connections */ + uint8_t connection_O_metre; + uint64_t connection_cooldown_timer; + bool block_handshakes; + + int32_t saved_invites[MAX_GC_SAVED_INVITES]; + uint8_t saved_invites_index; + + /** A list of recently seen peers in case we disconnect from a private group. + * Peers are added once they're confirmed, and only if there are vacant + * spots (older connections get priority). An entry is removed only when the list + * is full, its respective peer goes offline, and an online peer who isn't yet + * present in the list can be added. + */ + GC_SavedPeerInfo saved_peers[GC_MAX_SAVED_PEERS]; + + GC_TimedOutPeer timeout_list[MAX_GC_SAVED_TIMEOUTS]; + size_t timeout_list_index; + uint64_t last_timed_out_reconn_try; // the last time we tried to reconnect to timed out peers + + bool update_self_announces; // true if we should try to update our announcements + uint64_t last_self_announce_check; // the last time we checked if we should update our announcements + uint64_t last_time_self_announce; // the last time we announced the group + uint8_t announced_tcp_relay_pk[CRYPTO_PUBLIC_KEY_SIZE]; // The pk of the last TCP relay we announced + + uint8_t m_group_public_key[CRYPTO_PUBLIC_KEY_SIZE]; // public key for group's messenger friend connection + int friend_connection_id; // identifier for group's messenger friend connection +} GC_Chat; + +#ifndef MESSENGER_DEFINED +#define MESSENGER_DEFINED +typedef struct Messenger Messenger; +#endif /* MESSENGER_DEFINED */ + +typedef void gc_message_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, unsigned int type, + const uint8_t *data, size_t length, uint32_t message_id, void *user_data); +typedef void gc_private_message_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, unsigned int type, + const uint8_t *data, size_t length, void *user_data); +typedef void gc_custom_packet_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, const uint8_t *data, + size_t length, void *user_data); +typedef void gc_custom_private_packet_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, + const uint8_t *data, + size_t length, void *user_data); +typedef void gc_moderation_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, uint32_t target_peer, + unsigned int mod_event, void *user_data); +typedef void gc_nick_change_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, const uint8_t *data, + size_t length, void *user_data); +typedef void gc_status_change_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, unsigned int status, + void *user_data); +typedef void gc_topic_change_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, const uint8_t *data, + size_t length, void *user_data); +typedef void gc_topic_lock_cb(const Messenger *m, uint32_t group_number, unsigned int topic_lock, void *user_data); +typedef void gc_voice_state_cb(const Messenger *m, uint32_t group_number, unsigned int voice_state, void *user_data); +typedef void gc_peer_limit_cb(const Messenger *m, uint32_t group_number, uint32_t max_peers, void *user_data); +typedef void gc_privacy_state_cb(const Messenger *m, uint32_t group_number, unsigned int state, void *user_data); +typedef void gc_password_cb(const Messenger *m, uint32_t group_number, const uint8_t *data, size_t length, + void *user_data); +typedef void gc_peer_join_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, void *user_data); +typedef void gc_peer_exit_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, unsigned int exit_type, + const uint8_t *nick, size_t nick_len, const uint8_t *data, size_t length, void *user_data); +typedef void gc_self_join_cb(const Messenger *m, uint32_t group_number, void *user_data); +typedef void gc_rejected_cb(const Messenger *m, uint32_t group_number, unsigned int type, void *user_data); + +typedef struct GC_Session { + Messenger *messenger; + GC_Chat *chats; + struct GC_Announces_List *announces_list; + + uint32_t chats_index; + + gc_message_cb *message; + gc_private_message_cb *private_message; + gc_custom_packet_cb *custom_packet; + gc_custom_private_packet_cb *custom_private_packet; + gc_moderation_cb *moderation; + gc_nick_change_cb *nick_change; + gc_status_change_cb *status_change; + gc_topic_change_cb *topic_change; + gc_topic_lock_cb *topic_lock; + gc_voice_state_cb *voice_state; + gc_peer_limit_cb *peer_limit; + gc_privacy_state_cb *privacy_state; + gc_password_cb *password; + gc_peer_join_cb *peer_join; + gc_peer_exit_cb *peer_exit; + gc_self_join_cb *self_join; + gc_rejected_cb *rejected; +} GC_Session; + +/** @brief Adds a new peer to group_number's peer list. + * + * Return peer_number on success. + * Return -1 on failure. + * Return -2 if a peer with public_key is already in our peerlist. + */ +non_null(1, 3) nullable(2) +int peer_add(GC_Chat *chat, const IP_Port *ipp, const uint8_t *public_key); + +/** @brief Unpacks saved peers from `data` of size `length` into `chat`. + * + * Returns the number of unpacked peers on success. + * Returns -1 on failure. + */ +non_null() +int unpack_gc_saved_peers(GC_Chat *chat, const uint8_t *data, uint16_t length); + +/** @brief Packs all valid entries from saved peerlist into `data`. + * + * If `processed` is non-null it will be set to the length of the packed data. + * + * Return the number of packed saved peers on success. + * Return -1 if buffer is too small. + */ +non_null(1, 2) nullable(4) +int pack_gc_saved_peers(const GC_Chat *chat, uint8_t *data, uint16_t length, uint16_t *processed); + +#endif // GROUP_COMMON_H diff --git a/protocols/Tox/libtox/src/toxcore/group_connection.c b/protocols/Tox/libtox/src/toxcore/group_connection.c new file mode 100644 index 0000000000..86c353c00c --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/group_connection.c @@ -0,0 +1,707 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Copyright © 2016-2020 The TokTok team. + * Copyright © 2015 Tox project. + */ + +/** + * An implementation of massive text only group chats. + */ + +#include "group_connection.h" + +#include <assert.h> +#include <stdint.h> +#include <stdlib.h> +#include <string.h> + +#include "DHT.h" +#include "ccompat.h" +#include "crypto_core.h" +#include "group_chats.h" +#include "group_common.h" +#include "mono_time.h" +#include "util.h" + +#ifndef VANILLA_NACL + +/** Seconds since last direct UDP packet was received before the connection is considered dead */ +#define GCC_UDP_DIRECT_TIMEOUT (GC_PING_TIMEOUT + 4) + +/** Returns true if array entry does not contain an active packet. */ +non_null() +static bool array_entry_is_empty(const GC_Message_Array_Entry *array_entry) +{ + assert(array_entry != nullptr); + return array_entry->time_added == 0; +} + +/** @brief Clears an array entry. */ +non_null() +static void clear_array_entry(GC_Message_Array_Entry *const array_entry) +{ + if (array_entry->data != nullptr) { + free(array_entry->data); + } + + *array_entry = (GC_Message_Array_Entry) { + nullptr + }; +} + +/** + * Clears every send array message from queue starting at the index designated by + * `start_id` and ending at `end_id`, and sets the send_message_id for `gconn` + * to `start_id`. + */ +non_null() +static void clear_send_queue_id_range(GC_Connection *gconn, uint64_t start_id, uint64_t end_id) +{ + const uint16_t start_idx = gcc_get_array_index(start_id); + const uint16_t end_idx = gcc_get_array_index(end_id); + + for (uint16_t i = start_idx; i != end_idx; i = (i + 1) % GCC_BUFFER_SIZE) { + GC_Message_Array_Entry *entry = &gconn->send_array[i]; + clear_array_entry(entry); + } + + gconn->send_message_id = start_id; +} + +uint16_t gcc_get_array_index(uint64_t message_id) +{ + return message_id % GCC_BUFFER_SIZE; +} + +void gcc_set_send_message_id(GC_Connection *gconn, uint64_t id) +{ + gconn->send_message_id = id; + gconn->send_array_start = id % GCC_BUFFER_SIZE; +} + +void gcc_set_recv_message_id(GC_Connection *gconn, uint64_t id) +{ + gconn->received_message_id = id; +} + +/** @brief Puts packet data in array_entry. + * + * Return true on success. + */ +non_null(1, 2) nullable(3) +static bool create_array_entry(const Mono_Time *mono_time, GC_Message_Array_Entry *array_entry, const uint8_t *data, + uint16_t length, uint8_t packet_type, uint64_t message_id) +{ + if (length > 0) { + if (data == nullptr) { + return false; + } + + array_entry->data = (uint8_t *)malloc(sizeof(uint8_t) * length); + + if (array_entry->data == nullptr) { + return false; + } + + memcpy(array_entry->data, data, length); + } + + const uint64_t tm = mono_time_get(mono_time); + + array_entry->data_length = length; + array_entry->packet_type = packet_type; + array_entry->message_id = message_id; + array_entry->time_added = tm; + array_entry->last_send_try = tm; + + return true; +} + +/** @brief Adds data of length to gconn's send_array. + * + * Returns true on success and increments gconn's send_message_id. + */ +non_null(1, 2, 3) nullable(4) +static bool add_to_send_array(const Logger *log, const Mono_Time *mono_time, GC_Connection *gconn, const uint8_t *data, + uint16_t length, uint8_t packet_type) +{ + /* check if send_array is full */ + if ((gconn->send_message_id % GCC_BUFFER_SIZE) == (uint16_t)(gconn->send_array_start - 1)) { + LOGGER_DEBUG(log, "Send array overflow"); + return false; + } + + const uint16_t idx = gcc_get_array_index(gconn->send_message_id); + GC_Message_Array_Entry *array_entry = &gconn->send_array[idx]; + + if (!array_entry_is_empty(array_entry)) { + LOGGER_DEBUG(log, "Send array entry isn't empty"); + return false; + } + + if (!create_array_entry(mono_time, array_entry, data, length, packet_type, gconn->send_message_id)) { + LOGGER_WARNING(log, "Failed to create array entry"); + return false; + } + + ++gconn->send_message_id; + + return true; +} + +int gcc_send_lossless_packet(const GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, uint16_t length, + uint8_t packet_type) +{ + const uint64_t message_id = gconn->send_message_id; + + if (!add_to_send_array(chat->log, chat->mono_time, gconn, data, length, packet_type)) { + LOGGER_WARNING(chat->log, "Failed to add payload to send array: (type: 0x%02x, length: %d)", packet_type, length); + return -1; + } + + if (!gcc_encrypt_and_send_lossless_packet(chat, gconn, data, length, message_id, packet_type)) { + LOGGER_DEBUG(chat->log, "Failed to send payload: (type: 0x%02x, length: %d)", packet_type, length); + return -2; + } + + return 0; +} + + +bool gcc_send_lossless_packet_fragments(const GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, + uint16_t length, uint8_t packet_type) +{ + if (length <= MAX_GC_PACKET_CHUNK_SIZE || data == nullptr) { + LOGGER_FATAL(chat->log, "invalid length or null data pointer"); + return false; + } + + const uint16_t start_id = gconn->send_message_id; + + // First packet segment is comprised of packet type + first chunk of payload + uint8_t chunk[MAX_GC_PACKET_CHUNK_SIZE]; + chunk[0] = packet_type; + memcpy(chunk + 1, data, MAX_GC_PACKET_CHUNK_SIZE - 1); + + if (!add_to_send_array(chat->log, chat->mono_time, gconn, chunk, MAX_GC_PACKET_CHUNK_SIZE, GP_FRAGMENT)) { + return false; + } + + uint16_t processed = MAX_GC_PACKET_CHUNK_SIZE - 1; + + // The rest of the segments are added in chunks + while (length > processed) { + const uint16_t chunk_len = min_u16(MAX_GC_PACKET_CHUNK_SIZE, length - processed); + + memcpy(chunk, data + processed, chunk_len); + processed += chunk_len; + + if (!add_to_send_array(chat->log, chat->mono_time, gconn, chunk, chunk_len, GP_FRAGMENT)) { + clear_send_queue_id_range(gconn, start_id, gconn->send_message_id); + return false; + } + } + + // empty packet signals the end of the sequence + if (!add_to_send_array(chat->log, chat->mono_time, gconn, nullptr, 0, GP_FRAGMENT)) { + clear_send_queue_id_range(gconn, start_id, gconn->send_message_id); + return false; + } + + const uint16_t start_idx = gcc_get_array_index(start_id); + const uint16_t end_idx = gcc_get_array_index(gconn->send_message_id); + + for (uint16_t i = start_idx; i != end_idx; i = (i + 1) % GCC_BUFFER_SIZE) { + GC_Message_Array_Entry *entry = &gconn->send_array[i]; + + if (array_entry_is_empty(entry)) { + LOGGER_FATAL(chat->log, "array entry for packet chunk is empty"); + return false; + } + + assert(entry->packet_type == GP_FRAGMENT); + + gcc_encrypt_and_send_lossless_packet(chat, gconn, entry->data, entry->data_length, + entry->message_id, entry->packet_type); + } + + return true; +} + +bool gcc_handle_ack(const Logger *log, GC_Connection *gconn, uint64_t message_id) +{ + uint16_t idx = gcc_get_array_index(message_id); + GC_Message_Array_Entry *array_entry = &gconn->send_array[idx]; + + if (array_entry_is_empty(array_entry)) { + return true; + } + + if (array_entry->message_id != message_id) { // wrap-around indicates a connection problem + LOGGER_DEBUG(log, "Wrap-around on message %llu", (unsigned long long)message_id); + return false; + } + + clear_array_entry(array_entry); + + /* Put send_array_start in proper position */ + if (idx == gconn->send_array_start) { + const uint16_t end = gconn->send_message_id % GCC_BUFFER_SIZE; + + while (array_entry_is_empty(&gconn->send_array[idx]) && gconn->send_array_start != end) { + gconn->send_array_start = (gconn->send_array_start + 1) % GCC_BUFFER_SIZE; + idx = (idx + 1) % GCC_BUFFER_SIZE; + } + } + + return true; +} + +bool gcc_ip_port_is_set(const GC_Connection *gconn) +{ + return ipport_isset(&gconn->addr.ip_port); +} + +void gcc_set_ip_port(GC_Connection *gconn, const IP_Port *ipp) +{ + if (ipp != nullptr && ipport_isset(ipp)) { + gconn->addr.ip_port = *ipp; + } +} + +bool gcc_copy_tcp_relay(const Random *rng, Node_format *tcp_node, const GC_Connection *gconn) +{ + if (gconn == nullptr || tcp_node == nullptr) { + return false; + } + + if (gconn->tcp_relays_count == 0) { + return false; + } + + const uint32_t rand_idx = random_range_u32(rng, gconn->tcp_relays_count); + + if (!ipport_isset(&gconn->connected_tcp_relays[rand_idx].ip_port)) { + return false; + } + + *tcp_node = gconn->connected_tcp_relays[rand_idx]; + + return true; +} + +int gcc_save_tcp_relay(const Random *rng, GC_Connection *gconn, const Node_format *tcp_node) +{ + if (gconn == nullptr || tcp_node == nullptr) { + return -1; + } + + if (!ipport_isset(&tcp_node->ip_port)) { + return -1; + } + + for (uint16_t i = 0; i < gconn->tcp_relays_count; ++i) { + if (pk_equal(gconn->connected_tcp_relays[i].public_key, tcp_node->public_key)) { + return -2; + } + } + + uint32_t idx = gconn->tcp_relays_count; + + if (gconn->tcp_relays_count >= MAX_FRIEND_TCP_CONNECTIONS) { + idx = random_range_u32(rng, gconn->tcp_relays_count); + } else { + ++gconn->tcp_relays_count; + } + + gconn->connected_tcp_relays[idx] = *tcp_node; + + return 0; +} + +/** @brief Stores `data` of length `length` in the receive array for `gconn`. + * + * Return true on success. + */ +non_null(1, 2, 3) nullable(4) +static bool store_in_recv_array(const Logger *log, const Mono_Time *mono_time, GC_Connection *gconn, + const uint8_t *data, + uint16_t length, uint8_t packet_type, uint64_t message_id) +{ + const uint16_t idx = gcc_get_array_index(message_id); + GC_Message_Array_Entry *ary_entry = &gconn->recv_array[idx]; + + if (!array_entry_is_empty(ary_entry)) { + LOGGER_DEBUG(log, "Recv array is not empty"); + return false; + } + + if (!create_array_entry(mono_time, ary_entry, data, length, packet_type, message_id)) { + LOGGER_WARNING(log, "Failed to create array entry"); + return false; + } + + return true; +} + +/** + * Reassembles a fragmented packet sequence ending with the data in the receive + * array at slot `message_id - 1` and starting with the last found slot containing + * a GP_FRAGMENT packet when searching backwards in the array. + * + * The fully reassembled packet is stored in `payload`, which must be passed as a + * null pointer, and must be free'd by the caller. + * + * Return the length of the fully reassembled packet on success. + * Return 0 on failure. + */ +non_null(1, 3) nullable(2) +static uint16_t reassemble_packet(const Logger *log, GC_Connection *gconn, uint8_t **payload, uint64_t message_id) +{ + uint16_t end_idx = gcc_get_array_index(message_id - 1); + uint16_t start_idx = end_idx; + uint16_t packet_length = 0; + + GC_Message_Array_Entry *entry = &gconn->recv_array[end_idx]; + + // search backwards in recv array until we find an empty slot or a non-fragment packet type + while (!array_entry_is_empty(entry) && entry->packet_type == GP_FRAGMENT) { + assert(entry->data != nullptr); + assert(entry->data_length <= MAX_GC_PACKET_CHUNK_SIZE); + + const uint16_t diff = packet_length + entry->data_length; + + assert(diff > packet_length); // overflow check + packet_length = diff; + + if (packet_length > MAX_GC_PACKET_SIZE) { + LOGGER_ERROR(log, "Payload of size %u exceeded max packet size", packet_length); // should never happen + return 0; + } + + start_idx = start_idx > 0 ? start_idx - 1 : GCC_BUFFER_SIZE - 1; + entry = &gconn->recv_array[start_idx]; + + if (start_idx == end_idx) { + LOGGER_ERROR(log, "Packet reassemble wrap-around"); + return 0; + } + } + + if (packet_length == 0) { + return 0; + } + + assert(*payload == nullptr); + *payload = (uint8_t *)malloc(packet_length); + + if (*payload == nullptr) { + LOGGER_ERROR(log, "Failed to allocate %u bytes for payload buffer", packet_length); + return 0; + } + + start_idx = (start_idx + 1) % GCC_BUFFER_SIZE; + end_idx = (end_idx + 1) % GCC_BUFFER_SIZE; + + uint16_t processed = 0; + + for (uint16_t i = start_idx; i != end_idx; i = (i + 1) % GCC_BUFFER_SIZE) { + entry = &gconn->recv_array[i]; + + assert(processed + entry->data_length <= packet_length); + memcpy(*payload + processed, entry->data, entry->data_length); + processed += entry->data_length; + + clear_array_entry(entry); + } + + return processed; +} + +int gcc_handle_packet_fragment(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, + GC_Connection *gconn, const uint8_t *chunk, uint16_t length, uint8_t packet_type, + uint64_t message_id, void *userdata) +{ + if (length > 0) { + if (!store_in_recv_array(chat->log, chat->mono_time, gconn, chunk, length, packet_type, message_id)) { + return -1; + } + + gcc_set_recv_message_id(gconn, gconn->received_message_id + 1); + gconn->last_chunk_id = message_id; + + return 1; + } + + uint8_t sender_pk[ENC_PUBLIC_KEY_SIZE]; + memcpy(sender_pk, get_enc_key(gconn->addr.public_key), ENC_PUBLIC_KEY_SIZE); + + uint8_t *payload = nullptr; + const uint16_t processed_len = reassemble_packet(chat->log, gconn, &payload, message_id); + + if (processed_len == 0) { + free(payload); + return -1; + } + + if (!handle_gc_lossless_helper(c, chat, peer_number, payload + 1, processed_len - 1, payload[0], userdata)) { + free(payload); + return -1; + } + + /* peer number can change from peer add operations in packet handlers */ + peer_number = get_peer_number_of_enc_pk(chat, sender_pk, false); + gconn = get_gc_connection(chat, peer_number); + + if (gconn == nullptr) { + return 0; + } + + gcc_set_recv_message_id(gconn, gconn->received_message_id + 1); + gconn->last_chunk_id = 0; + + free(payload); + + return 0; +} + +int gcc_handle_received_message(const Logger *log, const Mono_Time *mono_time, GC_Connection *gconn, + const uint8_t *data, uint16_t length, uint8_t packet_type, uint64_t message_id, + bool direct_conn) +{ + if (direct_conn) { + gconn->last_received_direct_time = mono_time_get(mono_time); + } + + /* Appears to be a duplicate packet so we discard it */ + if (message_id < gconn->received_message_id + 1) { + return 0; + } + + if (packet_type == GP_FRAGMENT) { // we handle packet fragments as a special case + return 3; + } + + /* we're missing an older message from this peer so we store it in recv_array */ + if (message_id > gconn->received_message_id + 1) { + if (!store_in_recv_array(log, mono_time, gconn, data, length, packet_type, message_id)) { + return -1; + } + + return 1; + } + + gcc_set_recv_message_id(gconn, gconn->received_message_id + 1); + + return 2; +} + +/** @brief Handles peer_number's array entry with appropriate handler and clears it from array. + * + * This function increments the received message ID for `gconn`. + * + * Return true on success. + */ +non_null(1, 2, 3, 5) nullable(6) +static bool process_recv_array_entry(const GC_Session *c, GC_Chat *chat, GC_Connection *gconn, uint32_t peer_number, + GC_Message_Array_Entry *const array_entry, void *userdata) +{ + uint8_t sender_pk[ENC_PUBLIC_KEY_SIZE]; + memcpy(sender_pk, get_enc_key(gconn->addr.public_key), ENC_PUBLIC_KEY_SIZE); + + const bool ret = handle_gc_lossless_helper(c, chat, peer_number, array_entry->data, array_entry->data_length, + array_entry->packet_type, userdata); + + /* peer number can change from peer add operations in packet handlers */ + peer_number = get_peer_number_of_enc_pk(chat, sender_pk, false); + gconn = get_gc_connection(chat, peer_number); + + clear_array_entry(array_entry); + + if (gconn == nullptr) { + return true; + } + + if (!ret) { + gc_send_message_ack(chat, gconn, array_entry->message_id, GR_ACK_REQ); + return false; + } + + gc_send_message_ack(chat, gconn, array_entry->message_id, GR_ACK_RECV); + + gcc_set_recv_message_id(gconn, gconn->received_message_id + 1); + + return true; +} + +void gcc_check_recv_array(const GC_Session *c, GC_Chat *chat, GC_Connection *gconn, uint32_t peer_number, + void *userdata) +{ + if (gconn->last_chunk_id != 0) { // dont check array if we have an unfinished fragment sequence + return; + } + + const uint16_t idx = (gconn->received_message_id + 1) % GCC_BUFFER_SIZE; + GC_Message_Array_Entry *const array_entry = &gconn->recv_array[idx]; + + if (!array_entry_is_empty(array_entry)) { + process_recv_array_entry(c, chat, gconn, peer_number, array_entry, userdata); + } +} + +void gcc_resend_packets(const GC_Chat *chat, GC_Connection *gconn) +{ + const uint64_t tm = mono_time_get(chat->mono_time); + const uint16_t start = gconn->send_array_start; + const uint16_t end = gconn->send_message_id % GCC_BUFFER_SIZE; + + GC_Message_Array_Entry *array_entry = &gconn->send_array[start]; + + if (array_entry_is_empty(array_entry)) { + return; + } + + if (mono_time_is_timeout(chat->mono_time, array_entry->time_added, GC_CONFIRMED_PEER_TIMEOUT)) { + gcc_mark_for_deletion(gconn, chat->tcp_conn, GC_EXIT_TYPE_TIMEOUT, nullptr, 0); + LOGGER_DEBUG(chat->log, "Send array stuck; timing out peer"); + return; + } + + for (uint16_t i = start; i != end; i = (i + 1) % GCC_BUFFER_SIZE) { + array_entry = &gconn->send_array[i]; + + if (array_entry_is_empty(array_entry)) { + continue; + } + + if (tm == array_entry->last_send_try) { + continue; + } + + const uint64_t delta = array_entry->last_send_try - array_entry->time_added; + array_entry->last_send_try = tm; + + /* if this occurrs less than once per second this won't be reliable */ + if (delta > 1 && is_power_of_2(delta)) { + gcc_encrypt_and_send_lossless_packet(chat, gconn, array_entry->data, array_entry->data_length, + array_entry->message_id, array_entry->packet_type); + } + } +} + +bool gcc_send_packet(const GC_Chat *chat, const GC_Connection *gconn, const uint8_t *packet, uint16_t length) +{ + if (packet == nullptr || length == 0) { + return false; + } + + bool direct_send_attempt = false; + + if (gcc_direct_conn_is_possible(chat, gconn)) { + if (gcc_conn_is_direct(chat->mono_time, gconn)) { + return (uint16_t) sendpacket(chat->net, &gconn->addr.ip_port, packet, length) == length; + } + + if ((uint16_t) sendpacket(chat->net, &gconn->addr.ip_port, packet, length) == length) { + direct_send_attempt = true; + } + } + + const int ret = send_packet_tcp_connection(chat->tcp_conn, gconn->tcp_connection_num, packet, length); + return ret == 0 || direct_send_attempt; +} + +bool gcc_encrypt_and_send_lossless_packet(const GC_Chat *chat, const GC_Connection *gconn, const uint8_t *data, + uint16_t length, uint64_t message_id, uint8_t packet_type) +{ + const uint16_t packet_size = gc_get_wrapped_packet_size(length, NET_PACKET_GC_LOSSLESS); + uint8_t *packet = (uint8_t *)malloc(packet_size); + + if (packet == nullptr) { + LOGGER_ERROR(chat->log, "Failed to allocate memory for packet buffer"); + return false; + } + + const int enc_len = group_packet_wrap( + chat->log, chat->rng, chat->self_public_key, gconn->session_shared_key, packet, + packet_size, data, length, message_id, packet_type, NET_PACKET_GC_LOSSLESS); + + if (enc_len < 0) { + LOGGER_ERROR(chat->log, "Failed to wrap packet (type: 0x%02x, error: %d)", packet_type, enc_len); + free(packet); + return false; + } + + if (!gcc_send_packet(chat, gconn, packet, (uint16_t)enc_len)) { + LOGGER_DEBUG(chat->log, "Failed to send packet (type: 0x%02x, enc_len: %d)", packet_type, enc_len); + free(packet); + return false; + } + + free(packet); + + return true; +} + +void gcc_make_session_shared_key(GC_Connection *gconn, const uint8_t *sender_pk) +{ + encrypt_precompute(sender_pk, gconn->session_secret_key, gconn->session_shared_key); +} + +bool gcc_conn_is_direct(const Mono_Time *mono_time, const GC_Connection *gconn) +{ + return GCC_UDP_DIRECT_TIMEOUT + gconn->last_received_direct_time > mono_time_get(mono_time); +} + +bool gcc_direct_conn_is_possible(const GC_Chat *chat, const GC_Connection *gconn) +{ + return !net_family_is_unspec(gconn->addr.ip_port.ip.family) && !net_family_is_unspec(net_family(chat->net)); +} + +void gcc_mark_for_deletion(GC_Connection *gconn, TCP_Connections *tcp_conn, Group_Exit_Type type, + const uint8_t *part_message, uint16_t length) +{ + if (gconn == nullptr) { + return; + } + + if (gconn->pending_delete) { + return; + } + + gconn->pending_delete = true; + gconn->exit_info.exit_type = type; + + kill_tcp_connection_to(tcp_conn, gconn->tcp_connection_num); + + if (length > 0 && length <= MAX_GC_PART_MESSAGE_SIZE && part_message != nullptr) { + memcpy(gconn->exit_info.part_message, part_message, length); + gconn->exit_info.length = length; + } +} + +void gcc_peer_cleanup(GC_Connection *gconn) +{ + for (size_t i = 0; i < GCC_BUFFER_SIZE; ++i) { + free(gconn->send_array[i].data); + free(gconn->recv_array[i].data); + } + + free(gconn->recv_array); + free(gconn->send_array); + + crypto_memunlock(gconn->session_secret_key, sizeof(gconn->session_secret_key)); + crypto_memunlock(gconn->session_shared_key, sizeof(gconn->session_shared_key)); + crypto_memzero(gconn, sizeof(GC_Connection)); +} + +void gcc_cleanup(const GC_Chat *chat) +{ + for (uint32_t i = 0; i < chat->numpeers; ++i) { + GC_Connection *gconn = get_gc_connection(chat, i); + assert(gconn != nullptr); + + gcc_peer_cleanup(gconn); + } +} + +#endif // VANILLA_NACL diff --git a/protocols/Tox/libtox/src/toxcore/group_connection.h b/protocols/Tox/libtox/src/toxcore/group_connection.h new file mode 100644 index 0000000000..2202c7ab36 --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/group_connection.h @@ -0,0 +1,189 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Copyright © 2016-2020 The TokTok team. + * Copyright © 2015 Tox project. + */ + +/** + * An implementation of massive text only group chats. + */ + +#ifndef GROUP_CONNECTION_H +#define GROUP_CONNECTION_H + +#include "group_common.h" + +/* Max number of TCP relays we share with a peer on handshake */ +#define GCC_MAX_TCP_SHARED_RELAYS 3 + +/** Marks a peer for deletion. If gconn is null or already marked for deletion this function has no effect. */ +non_null(1, 2) nullable(4) +void gcc_mark_for_deletion(GC_Connection *gconn, TCP_Connections *tcp_conn, Group_Exit_Type type, + const uint8_t *part_message, uint16_t length); + +/** @brief Decides if message need to be put in recv_array or immediately handled. + * + * Return 3 if message is in correct sequence and is a fragment packet. + * Return 2 if message is in correct sequence and may be handled immediately. + * Return 1 if packet is out of sequence and added to recv_array. + * Return 0 if message is a duplicate. + * Return -1 on failure + */ +non_null(1, 2, 3) nullable(4) +int gcc_handle_received_message(const Logger *log, const Mono_Time *mono_time, GC_Connection *gconn, + const uint8_t *data, uint16_t length, uint8_t packet_type, uint64_t message_id, + bool direct_conn); + +/** @brief Handles a packet fragment. + * + * If the fragment is incomplete, it gets stored in the recv + * array. Otherwise the segment is re-assembled into a complete + * payload and processed. + * + * Return 1 if fragment is successfully handled and is not the end of the sequence. + * Return 0 if fragment is the end of a sequence and successfully handled. + * Return -1 on failure. + */ +non_null(1, 2, 4) nullable(5, 9) +int gcc_handle_packet_fragment(const GC_Session *c, GC_Chat *chat, uint32_t peer_number, GC_Connection *gconn, + const uint8_t *chunk, uint16_t length, uint8_t packet_type, uint64_t message_id, + void *userdata); + +/** @brief Return array index for message_id */ +uint16_t gcc_get_array_index(uint64_t message_id); + +/** @brief Removes send_array item with message_id. + * + * Return true on success. + */ +non_null() +bool gcc_handle_ack(const Logger *log, GC_Connection *gconn, uint64_t message_id); + +/** @brief Sets the send_message_id and send_array_start for `gconn` to `id`. + * + * This should only be used to initialize a new lossless connection. + */ +non_null() +void gcc_set_send_message_id(GC_Connection *gconn, uint64_t id); + +/** @brief Sets the received_message_id for `gconn` to `id`. */ +non_null() +void gcc_set_recv_message_id(GC_Connection *gconn, uint64_t id); + +/** + * @brief Returns true if the ip_port is set for gconn. + */ +non_null() +bool gcc_ip_port_is_set(const GC_Connection *gconn); + +/** + * @brief Sets the ip_port for gconn to ipp. + * + * If ipp is not set this function has no effect. + */ +non_null(1) nullable(2) +void gcc_set_ip_port(GC_Connection *gconn, const IP_Port *ipp); + +/** @brief Copies a random TCP relay node from gconn to tcp_node. + * + * Return true on success. + */ +non_null() +bool gcc_copy_tcp_relay(const Random *rng, Node_format *tcp_node, const GC_Connection *gconn); + +/** @brief Saves tcp_node to gconn's list of connected tcp relays. + * + * If relays list is full a random node is overwritten with the new node. + * + * Return 0 on success. + * Return -1 on failure. + * Return -2 if node is already in list. + */ +non_null() +int gcc_save_tcp_relay(const Random *rng, GC_Connection *gconn, const Node_format *tcp_node); + +/** @brief Checks for and handles messages that are in proper sequence in gconn's recv_array. + * This should always be called after a new packet is successfully handled. + */ +non_null(1, 2, 3) nullable(5) +void gcc_check_recv_array(const GC_Session *c, GC_Chat *chat, GC_Connection *gconn, uint32_t peer_number, + void *userdata); + +/** @brief Attempts to re-send lossless packets that have not yet received an ack. */ +non_null() +void gcc_resend_packets(const GC_Chat *chat, GC_Connection *gconn); + +/** + * Uses public encryption key `sender_pk` and the shared secret key associated with `gconn` + * to generate a shared 32-byte encryption key that can be used by the owners of both keys for symmetric + * encryption and decryption. + * + * Puts the result in the shared session key buffer for `gconn`, which must have room for + * CRYPTO_SHARED_KEY_SIZE bytes. This resulting shared key should be treated as a secret key. + */ +non_null() +void gcc_make_session_shared_key(GC_Connection *gconn, const uint8_t *sender_pk); + +/** @brief Return true if we have a direct connection with `gconn`. */ +non_null() +bool gcc_conn_is_direct(const Mono_Time *mono_time, const GC_Connection *gconn); + +/** @brief Return true if a direct UDP connection is possible with `gconn`. */ +non_null() +bool gcc_direct_conn_is_possible(const GC_Chat *chat, const GC_Connection *gconn); + +/** @brief Sends a packet to the peer associated with gconn. + * + * This is a lower level function that does not encrypt or wrap the packet. + * + * Return true on success. + */ +non_null() +bool gcc_send_packet(const GC_Chat *chat, const GC_Connection *gconn, const uint8_t *packet, uint16_t length); + +/** @brief Sends a lossless packet to `gconn` comprised of `data` of size `length`. + * + * This function will add the packet to the lossless send array, encrypt/wrap it using the + * shared key associated with `gconn`, and send it over the wire. + * + * Return 0 on success. + * Return -1 if the packet couldn't be added to the send array. + * Return -2 if the packet failed to be encrypted or failed to send. + */ +non_null(1, 2) nullable(3) +int gcc_send_lossless_packet(const GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, uint16_t length, + uint8_t packet_type); + +/** @brief Splits a lossless packet up into fragments, wraps each fragment in a GP_FRAGMENT + * header, encrypts them, and send them in succession. + * + * This function will first try to add each packet fragment to the send array as an atomic + * unit. If any chunk fails to be added the process will be reversed and an error will be + * returned. Otherwise it will then try to send all the fragments in succession. + * + * Return true if all fragments are successfully added to the send array. + */ +non_null() +bool gcc_send_lossless_packet_fragments(const GC_Chat *chat, GC_Connection *gconn, const uint8_t *data, + uint16_t length, uint8_t packet_type); + + +/** @brief Encrypts `data` of `length` bytes, designated by `message_id`, using the shared key + * associated with `gconn` and sends lossless packet over the wire. + * + * This function does not add the packet to the send array. + * + * Return true on success. + */ +non_null(1, 2) nullable(3) +bool gcc_encrypt_and_send_lossless_packet(const GC_Chat *chat, const GC_Connection *gconn, const uint8_t *data, + uint16_t length, uint64_t message_id, uint8_t packet_type); + +/** @brief Called when a peer leaves the group. */ +non_null() +void gcc_peer_cleanup(GC_Connection *gconn); + +/** @brief Called on group exit. */ +non_null() +void gcc_cleanup(const GC_Chat *chat); + +#endif // GROUP_CONNECTION_H diff --git a/protocols/Tox/libtox/src/toxcore/group_moderation.c b/protocols/Tox/libtox/src/toxcore/group_moderation.c index dea38a648b..b16c397cbe 100644 --- a/protocols/Tox/libtox/src/toxcore/group_moderation.c +++ b/protocols/Tox/libtox/src/toxcore/group_moderation.c @@ -27,6 +27,10 @@ static_assert(MOD_MAX_NUM_SANCTIONS * MOD_SANCTION_PACKED_SIZE + MOD_SANCTIONS_C "MOD_MAX_NUM_SANCTIONS must be able to fit inside the maximum allowed payload size"); static_assert(MOD_MAX_NUM_MODERATORS * MOD_LIST_ENTRY_SIZE <= MAX_PACKET_SIZE_NO_HEADERS, "MOD_MAX_NUM_MODERATORS must be able to fit insize the maximum allowed payload size"); +static_assert(MOD_MAX_NUM_MODERATORS <= MOD_MAX_NUM_MODERATORS_LIMIT, + "MOD_MAX_NUM_MODERATORS must be <= MOD_MAX_NUM_MODERATORS_LIMIT"); +static_assert(MOD_MAX_NUM_SANCTIONS <= MOD_MAX_NUM_SANCTIONS_LIMIT, + "MOD_MAX_NUM_SANCTIONS must be <= MOD_MAX_NUM_SANCTIONS_LIMIT"); uint16_t mod_list_packed_size(const Moderation *moderation) { @@ -398,7 +402,7 @@ int sanctions_list_unpack(Mod_Sanction *sanctions, Mod_Sanction_Creds *creds, ui */ non_null(4) nullable(1) static bool sanctions_list_make_hash(const Mod_Sanction *sanctions, uint32_t new_version, uint16_t num_sanctions, - uint8_t *hash) + uint8_t *hash) { if (num_sanctions == 0 || sanctions == nullptr) { memset(hash, 0, MOD_SANCTION_HASH_SIZE); @@ -568,7 +572,7 @@ bool sanctions_list_check_integrity(const Moderation *moderation, const Mod_Sanc } /** @brief Validates a sanctions list if credentials are supplied. If successful, - * or if no credentials are supplid, assigns new sanctions list and credentials + * or if no credentials are supplied, assigns new sanctions list and credentials * to moderation object. * * @param moderation The moderation object being operated on. diff --git a/protocols/Tox/libtox/src/toxcore/group_moderation.h b/protocols/Tox/libtox/src/toxcore/group_moderation.h index 36b44a42f0..8b2a73869a 100644 --- a/protocols/Tox/libtox/src/toxcore/group_moderation.h +++ b/protocols/Tox/libtox/src/toxcore/group_moderation.h @@ -36,9 +36,17 @@ extern "C" { /* The max size of a groupchat packet with 100 bytes reserved for header data */ #define MAX_PACKET_SIZE_NO_HEADERS 49900 -/* These values must take into account the maximum allowed packet size and headers. */ -#define MOD_MAX_NUM_MODERATORS (((MAX_PACKET_SIZE_NO_HEADERS) / (MOD_LIST_ENTRY_SIZE))) -#define MOD_MAX_NUM_SANCTIONS (((MAX_PACKET_SIZE_NO_HEADERS - (MOD_SANCTIONS_CREDS_SIZE)) / (MOD_SANCTION_PACKED_SIZE))) +/* The maximum possible number of moderators that can be sent in a group packet sequence. */ +#define MOD_MAX_NUM_MODERATORS_LIMIT (((MAX_PACKET_SIZE_NO_HEADERS) / (MOD_LIST_ENTRY_SIZE))) + +/* The maximum number of moderators that we allow in a group: 100 */ +#define MOD_MAX_NUM_MODERATORS ((MOD_MAX_NUM_MODERATORS_LIMIT / 16) + 3) + +/* The maximum number of sanctions that be sent in a group packet sequence. */ +#define MOD_MAX_NUM_SANCTIONS_LIMIT (((MAX_PACKET_SIZE_NO_HEADERS - (MOD_SANCTIONS_CREDS_SIZE)) / (MOD_SANCTION_PACKED_SIZE))) + +/* The maximum number of sanctions that we allow in a group: 30 */ +#define MOD_MAX_NUM_SANCTIONS (MOD_MAX_NUM_SANCTIONS_LIMIT / 12) typedef enum Mod_Sanction_Type { SA_OBSERVER = 0x00, diff --git a/protocols/Tox/libtox/src/toxcore/group_onion_announce.c b/protocols/Tox/libtox/src/toxcore/group_onion_announce.c new file mode 100644 index 0000000000..b797770e52 --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/group_onion_announce.c @@ -0,0 +1,115 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Copyright © 2016-2020 The TokTok team. + * Copyright © 2015 Tox project. + */ + +#include "group_onion_announce.h" + +#include <assert.h> +#include <string.h> + +#include "ccompat.h" + +static_assert(GCA_ANNOUNCE_MAX_SIZE <= ONION_MAX_EXTRA_DATA_SIZE, + "GC_Announce does not fit into the onion packet extra data"); + +static pack_extra_data_cb pack_group_announces; +non_null() +static int pack_group_announces(void *object, const Logger *logger, const Mono_Time *mono_time, + uint8_t num_nodes, uint8_t *plain, uint16_t plain_size, + uint8_t *response, uint16_t response_size, uint16_t offset) +{ + GC_Announces_List *gc_announces_list = (GC_Announces_List *)object; + GC_Public_Announce public_announce; + + if (gca_unpack_public_announce(logger, plain, plain_size, + &public_announce) == -1) { + LOGGER_WARNING(logger, "Failed to unpack public group announce"); + return -1; + } + + const GC_Peer_Announce *new_announce = gca_add_announce(mono_time, gc_announces_list, &public_announce); + + if (new_announce == nullptr) { + LOGGER_ERROR(logger, "Failed to add group announce"); + return -1; + } + + GC_Announce gc_announces[GCA_MAX_SENT_ANNOUNCES]; + const int num_ann = gca_get_announces(gc_announces_list, + gc_announces, + GCA_MAX_SENT_ANNOUNCES, + public_announce.chat_public_key, + new_announce->base_announce.peer_public_key); + + if (num_ann < 0) { + LOGGER_ERROR(logger, "failed to get group announce"); + return -1; + } + + assert(num_ann <= UINT8_MAX); + + size_t announces_length = 0; + + if (gca_pack_announces_list(logger, response + offset, response_size - offset, gc_announces, (uint8_t)num_ann, + &announces_length) != num_ann) { + LOGGER_WARNING(logger, "Failed to pack group announces list"); + return -1; + } + + return announces_length; +} + +void gca_onion_init(GC_Announces_List *group_announce, Onion_Announce *onion_a) +{ + onion_announce_extra_data_callback(onion_a, GCA_MAX_SENT_ANNOUNCES * sizeof(GC_Announce), pack_group_announces, + group_announce); +} + +#ifndef VANILLA_NACL + +int create_gca_announce_request( + const Random *rng, uint8_t *packet, uint16_t max_packet_length, const uint8_t *dest_client_id, + const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *ping_id, + const uint8_t *client_id, const uint8_t *data_public_key, uint64_t sendback_data, + const uint8_t *gc_data, uint16_t gc_data_length) +{ + if (max_packet_length < ONION_ANNOUNCE_REQUEST_MAX_SIZE || gc_data_length == 0) { + return -1; + } + + uint8_t plain[ONION_PING_ID_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_PUBLIC_KEY_SIZE + + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + GCA_ANNOUNCE_MAX_SIZE]; + uint8_t *position_in_plain = plain; + const size_t encrypted_size = sizeof(plain) - GCA_ANNOUNCE_MAX_SIZE + gc_data_length; + + memcpy(plain, ping_id, ONION_PING_ID_SIZE); + position_in_plain += ONION_PING_ID_SIZE; + + memcpy(position_in_plain, client_id, CRYPTO_PUBLIC_KEY_SIZE); + position_in_plain += CRYPTO_PUBLIC_KEY_SIZE; + + memcpy(position_in_plain, data_public_key, CRYPTO_PUBLIC_KEY_SIZE); + position_in_plain += CRYPTO_PUBLIC_KEY_SIZE; + + memcpy(position_in_plain, &sendback_data, sizeof(sendback_data)); + position_in_plain += sizeof(sendback_data); + + memcpy(position_in_plain, gc_data, gc_data_length); + + packet[0] = NET_PACKET_ANNOUNCE_REQUEST; + random_nonce(rng, packet + 1); + memcpy(packet + 1 + CRYPTO_NONCE_SIZE, public_key, CRYPTO_PUBLIC_KEY_SIZE); + + const int len = encrypt_data(dest_client_id, secret_key, packet + 1, plain, + encrypted_size, packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE); + + const uint32_t full_length = (uint32_t)len + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE; + + if (full_length != ONION_ANNOUNCE_REQUEST_MIN_SIZE + gc_data_length) { + return -1; + } + + return full_length; +} +#endif // VANILLA_NACL diff --git a/protocols/Tox/libtox/src/toxcore/group_onion_announce.h b/protocols/Tox/libtox/src/toxcore/group_onion_announce.h new file mode 100644 index 0000000000..5c6d64ec59 --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/group_onion_announce.h @@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Copyright © 2016-2020 The TokTok team. + * Copyright © 2015 Tox project. + */ + +#ifndef C_TOXCORE_TOXCORE_GROUP_ONION_ANNOUNCE_H +#define C_TOXCORE_TOXCORE_GROUP_ONION_ANNOUNCE_H + +#include "group_announce.h" +#include "onion_announce.h" + +non_null() +void gca_onion_init(GC_Announces_List *group_announce, Onion_Announce *onion_a); + +non_null() +int create_gca_announce_request( + const Random *rng, uint8_t *packet, uint16_t max_packet_length, const uint8_t *dest_client_id, + const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *ping_id, + const uint8_t *client_id, const uint8_t *data_public_key, uint64_t sendback_data, + const uint8_t *gc_data, uint16_t gc_data_length); + +#endif // C_TOXCORE_TOXCORE_GROUP_ONION_ANNOUNCE_H diff --git a/protocols/Tox/libtox/src/toxcore/group_pack.c b/protocols/Tox/libtox/src/toxcore/group_pack.c new file mode 100644 index 0000000000..ecdd965610 --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/group_pack.c @@ -0,0 +1,423 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Copyright © 2016-2020 The TokTok team. + * Copyright © 2015 Tox project. + */ + +/** + * Packer and unpacker functions for saving and loading groups. + */ + +#include "group_pack.h" + +#include <assert.h> +#include <stdint.h> +#include <stdlib.h> +#include <string.h> + +#include "bin_pack.h" +#include "bin_unpack.h" +#include "ccompat.h" +#include "util.h" + +non_null() +static bool load_unpack_state_values(GC_Chat *chat, Bin_Unpack *bu) +{ + if (!bin_unpack_array_fixed(bu, 8)) { + LOGGER_ERROR(chat->log, "Group state values array malformed"); + return false; + } + + bool manually_disconnected = false; + uint8_t privacy_state = 0; + uint8_t voice_state = 0; + + if (!(bin_unpack_bool(bu, &manually_disconnected) + && bin_unpack_u16(bu, &chat->shared_state.group_name_len) + && bin_unpack_u08(bu, &privacy_state) + && bin_unpack_u16(bu, &chat->shared_state.maxpeers) + && bin_unpack_u16(bu, &chat->shared_state.password_length) + && bin_unpack_u32(bu, &chat->shared_state.version) + && bin_unpack_u32(bu, &chat->shared_state.topic_lock) + && bin_unpack_u08(bu, &voice_state))) { + LOGGER_ERROR(chat->log, "Failed to unpack state value"); + return false; + } + + chat->connection_state = manually_disconnected ? CS_DISCONNECTED : CS_CONNECTING; + chat->shared_state.privacy_state = (Group_Privacy_State)privacy_state; + chat->shared_state.voice_state = (Group_Voice_State)voice_state; + + // we always load saved groups as private in case the group became private while we were offline. + // this will have no detrimental effect if the group is public, as the correct privacy + // state will be set via sync. + chat->join_type = HJ_PRIVATE; + + return true; +} + +non_null() +static bool load_unpack_state_bin(GC_Chat *chat, Bin_Unpack *bu) +{ + if (!bin_unpack_array_fixed(bu, 5)) { + LOGGER_ERROR(chat->log, "Group state binary array malformed"); + return false; + } + + if (!(bin_unpack_bin_fixed(bu, chat->shared_state_sig, SIGNATURE_SIZE) + && bin_unpack_bin_fixed(bu, chat->shared_state.founder_public_key, EXT_PUBLIC_KEY_SIZE) + && bin_unpack_bin_fixed(bu, chat->shared_state.group_name, chat->shared_state.group_name_len) + && bin_unpack_bin_fixed(bu, chat->shared_state.password, chat->shared_state.password_length) + && bin_unpack_bin_fixed(bu, chat->shared_state.mod_list_hash, MOD_MODERATION_HASH_SIZE))) { + LOGGER_ERROR(chat->log, "Failed to unpack state binary data"); + return false; + } + + return true; +} + +non_null() +static bool load_unpack_topic_info(GC_Chat *chat, Bin_Unpack *bu) +{ + if (!bin_unpack_array_fixed(bu, 6)) { + LOGGER_ERROR(chat->log, "Group topic array malformed"); + return false; + } + + if (!(bin_unpack_u32(bu, &chat->topic_info.version) + && bin_unpack_u16(bu, &chat->topic_info.length) + && bin_unpack_u16(bu, &chat->topic_info.checksum) + && bin_unpack_bin_fixed(bu, chat->topic_info.topic, chat->topic_info.length) + && bin_unpack_bin_fixed(bu, chat->topic_info.public_sig_key, SIG_PUBLIC_KEY_SIZE) + && bin_unpack_bin_fixed(bu, chat->topic_sig, SIGNATURE_SIZE))) { + LOGGER_ERROR(chat->log, "Failed to unpack topic info"); + return false; + } + + return true; +} + +non_null() +static bool load_unpack_mod_list(GC_Chat *chat, Bin_Unpack *bu) +{ + if (!bin_unpack_array_fixed(bu, 2)) { + LOGGER_ERROR(chat->log, "Group mod list array malformed"); + return false; + } + + if (!bin_unpack_u16(bu, &chat->moderation.num_mods)) { + LOGGER_ERROR(chat->log, "Failed to unpack mod list value"); + return false; + } + + if (chat->moderation.num_mods == 0) { + bin_unpack_nil(bu); + return true; + } + + if (chat->moderation.num_mods > MOD_MAX_NUM_MODERATORS) { + LOGGER_ERROR(chat->log, "moderation count %u exceeds maximum %u", chat->moderation.num_mods, MOD_MAX_NUM_MODERATORS); + return false; + } + + uint8_t *packed_mod_list = (uint8_t *)malloc(chat->moderation.num_mods * MOD_LIST_ENTRY_SIZE); + + if (packed_mod_list == nullptr) { + LOGGER_ERROR(chat->log, "Failed to allocate memory for packed mod list"); + return false; + } + + const size_t packed_size = chat->moderation.num_mods * MOD_LIST_ENTRY_SIZE; + + if (!bin_unpack_bin_fixed(bu, packed_mod_list, packed_size)) { + LOGGER_ERROR(chat->log, "Failed to unpack mod list binary data"); + free(packed_mod_list); + return false; + } + + if (mod_list_unpack(&chat->moderation, packed_mod_list, packed_size, chat->moderation.num_mods) == -1) { + LOGGER_ERROR(chat->log, "Failed to unpack mod list info"); + free(packed_mod_list); + return false; + } + + free(packed_mod_list); + + return true; +} + +non_null() +static bool load_unpack_keys(GC_Chat *chat, Bin_Unpack *bu) +{ + if (!bin_unpack_array_fixed(bu, 4)) { + LOGGER_ERROR(chat->log, "Group keys array malformed"); + return false; + } + + if (!(bin_unpack_bin_fixed(bu, chat->chat_public_key, EXT_PUBLIC_KEY_SIZE) + && bin_unpack_bin_fixed(bu, chat->chat_secret_key, EXT_SECRET_KEY_SIZE) + && bin_unpack_bin_fixed(bu, chat->self_public_key, EXT_PUBLIC_KEY_SIZE) + && bin_unpack_bin_fixed(bu, chat->self_secret_key, EXT_SECRET_KEY_SIZE))) { + LOGGER_ERROR(chat->log, "Failed to unpack keys"); + return false; + } + + return true; +} + +non_null() +static bool load_unpack_self_info(GC_Chat *chat, Bin_Unpack *bu) +{ + if (!bin_unpack_array_fixed(bu, 4)) { + LOGGER_ERROR(chat->log, "Group self info array malformed"); + return false; + } + + uint8_t self_nick[MAX_GC_NICK_SIZE]; + uint16_t self_nick_len = 0; + uint8_t self_role = GR_USER; + uint8_t self_status = GS_NONE; + + if (!(bin_unpack_u16(bu, &self_nick_len) + && bin_unpack_u08(bu, &self_role) + && bin_unpack_u08(bu, &self_status))) { + LOGGER_ERROR(chat->log, "Failed to unpack self values"); + return false; + } + + assert(self_nick_len <= MAX_GC_NICK_SIZE); + + if (!bin_unpack_bin_fixed(bu, self_nick, self_nick_len)) { + LOGGER_ERROR(chat->log, "Failed to unpack self nick bytes"); + return false; + } + + // we have to add ourself before setting self info + if (peer_add(chat, nullptr, chat->self_public_key) != 0) { + LOGGER_ERROR(chat->log, "Failed to add self to peer list"); + return false; + } + + assert(chat->numpeers > 0); + + GC_Peer *self = &chat->group[0]; + + memcpy(self->gconn.addr.public_key, chat->self_public_key, EXT_PUBLIC_KEY_SIZE); + memcpy(self->nick, self_nick, self_nick_len); + self->nick_length = self_nick_len; + self->role = (Group_Role)self_role; + self->status = (Group_Peer_Status)self_status; + self->gconn.confirmed = true; + + return true; +} + +non_null() +static bool load_unpack_saved_peers(GC_Chat *chat, Bin_Unpack *bu) +{ + if (!bin_unpack_array_fixed(bu, 2)) { + LOGGER_ERROR(chat->log, "Group saved peers array malformed"); + return false; + } + + // Saved peers + uint16_t saved_peers_size = 0; + + if (!bin_unpack_u16(bu, &saved_peers_size)) { + LOGGER_ERROR(chat->log, "Failed to unpack saved peers value"); + return false; + } + + if (saved_peers_size == 0) { + bin_unpack_nil(bu); + return true; + } + + uint8_t *saved_peers = (uint8_t *)malloc(saved_peers_size * GC_SAVED_PEER_SIZE); + + if (saved_peers == nullptr) { + LOGGER_ERROR(chat->log, "Failed to allocate memory for saved peer list"); + return false; + } + + if (!bin_unpack_bin_fixed(bu, saved_peers, saved_peers_size)) { + LOGGER_ERROR(chat->log, "Failed to unpack saved peers binary data"); + free(saved_peers); + return false; + } + + if (unpack_gc_saved_peers(chat, saved_peers, saved_peers_size) == -1) { + LOGGER_ERROR(chat->log, "Failed to unpack saved peers"); // recoverable error + } + + free(saved_peers); + + return true; +} + +bool gc_load_unpack_group(GC_Chat *chat, Bin_Unpack *bu) +{ + if (!bin_unpack_array_fixed(bu, 7)) { + LOGGER_ERROR(chat->log, "Group info array malformed"); + return false; + } + + return load_unpack_state_values(chat, bu) + && load_unpack_state_bin(chat, bu) + && load_unpack_topic_info(chat, bu) + && load_unpack_mod_list(chat, bu) + && load_unpack_keys(chat, bu) + && load_unpack_self_info(chat, bu) + && load_unpack_saved_peers(chat, bu); +} + +non_null() +static void save_pack_state_values(const GC_Chat *chat, Bin_Pack *bp) +{ + bin_pack_array(bp, 8); + bin_pack_bool(bp, chat->connection_state == CS_DISCONNECTED); // 1 + bin_pack_u16(bp, chat->shared_state.group_name_len); // 2 + bin_pack_u08(bp, chat->shared_state.privacy_state); // 3 + bin_pack_u16(bp, chat->shared_state.maxpeers); // 4 + bin_pack_u16(bp, chat->shared_state.password_length); // 5 + bin_pack_u32(bp, chat->shared_state.version); // 6 + bin_pack_u32(bp, chat->shared_state.topic_lock); // 7 + bin_pack_u08(bp, chat->shared_state.voice_state); // 8 +} + +non_null() +static void save_pack_state_bin(const GC_Chat *chat, Bin_Pack *bp) +{ + bin_pack_array(bp, 5); + + bin_pack_bin(bp, chat->shared_state_sig, SIGNATURE_SIZE); // 1 + bin_pack_bin(bp, chat->shared_state.founder_public_key, EXT_PUBLIC_KEY_SIZE); // 2 + bin_pack_bin(bp, chat->shared_state.group_name, chat->shared_state.group_name_len); // 3 + bin_pack_bin(bp, chat->shared_state.password, chat->shared_state.password_length); // 4 + bin_pack_bin(bp, chat->shared_state.mod_list_hash, MOD_MODERATION_HASH_SIZE); // 5 +} + +non_null() +static void save_pack_topic_info(const GC_Chat *chat, Bin_Pack *bp) +{ + bin_pack_array(bp, 6); + + bin_pack_u32(bp, chat->topic_info.version); // 1 + bin_pack_u16(bp, chat->topic_info.length); // 2 + bin_pack_u16(bp, chat->topic_info.checksum); // 3 + bin_pack_bin(bp, chat->topic_info.topic, chat->topic_info.length); // 4 + bin_pack_bin(bp, chat->topic_info.public_sig_key, SIG_PUBLIC_KEY_SIZE); // 5 + bin_pack_bin(bp, chat->topic_sig, SIGNATURE_SIZE); // 6 +} + +non_null() +static void save_pack_mod_list(const GC_Chat *chat, Bin_Pack *bp) +{ + bin_pack_array(bp, 2); + + const uint16_t num_mods = min_u16(chat->moderation.num_mods, MOD_MAX_NUM_MODERATORS); + + if (num_mods == 0) { + bin_pack_u16(bp, num_mods); // 1 + bin_pack_nil(bp); // 2 + return; + } + + uint8_t *packed_mod_list = (uint8_t *)malloc(num_mods * MOD_LIST_ENTRY_SIZE); + + // we can still recover without the mod list + if (packed_mod_list == nullptr) { + bin_pack_u16(bp, 0); // 1 + bin_pack_nil(bp); // 2 + LOGGER_ERROR(chat->log, "Failed to allocate memory for moderation list"); + return; + } + + bin_pack_u16(bp, num_mods); // 1 + + mod_list_pack(&chat->moderation, packed_mod_list); + + const size_t packed_size = num_mods * MOD_LIST_ENTRY_SIZE; + + bin_pack_bin(bp, packed_mod_list, packed_size); // 2 + + free(packed_mod_list); +} + +non_null() +static void save_pack_keys(const GC_Chat *chat, Bin_Pack *bp) +{ + bin_pack_array(bp, 4); + + bin_pack_bin(bp, chat->chat_public_key, EXT_PUBLIC_KEY_SIZE); // 1 + bin_pack_bin(bp, chat->chat_secret_key, EXT_SECRET_KEY_SIZE); // 2 + bin_pack_bin(bp, chat->self_public_key, EXT_PUBLIC_KEY_SIZE); // 3 + bin_pack_bin(bp, chat->self_secret_key, EXT_SECRET_KEY_SIZE); // 4 +} + +non_null() +static void save_pack_self_info(const GC_Chat *chat, Bin_Pack *bp) +{ + bin_pack_array(bp, 4); + + const GC_Peer *self = &chat->group[0]; + + assert(self->nick_length <= MAX_GC_NICK_SIZE); + + bin_pack_u16(bp, self->nick_length); // 1 + bin_pack_u08(bp, (uint8_t)self->role); // 2 + bin_pack_u08(bp, (uint8_t)self->status); // 3 + bin_pack_bin(bp, self->nick, self->nick_length); // 4 +} + +non_null() +static void save_pack_saved_peers(const GC_Chat *chat, Bin_Pack *bp) +{ + bin_pack_array(bp, 2); + + uint8_t *saved_peers = (uint8_t *)malloc(GC_MAX_SAVED_PEERS * GC_SAVED_PEER_SIZE); + + // we can still recover without the saved peers list + if (saved_peers == nullptr) { + bin_pack_u16(bp, 0); // 1 + bin_pack_nil(bp); // 2 + LOGGER_ERROR(chat->log, "Failed to allocate memory for saved peers list"); + return; + } + + uint16_t packed_size = 0; + const int count = pack_gc_saved_peers(chat, saved_peers, GC_MAX_SAVED_PEERS * GC_SAVED_PEER_SIZE, &packed_size); + + if (count < 0) { + LOGGER_ERROR(chat->log, "Failed to pack saved peers"); + } + + bin_pack_u16(bp, packed_size); // 1 + + if (packed_size == 0) { + bin_pack_nil(bp); // 2 + free(saved_peers); + return; + } + + bin_pack_bin(bp, saved_peers, packed_size); // 2 + + free(saved_peers); +} + +void gc_save_pack_group(const GC_Chat *chat, Bin_Pack *bp) +{ + if (chat->numpeers == 0) { + LOGGER_ERROR(chat->log, "Failed to pack group: numpeers is 0"); + return; + } + + bin_pack_array(bp, 7); + + save_pack_state_values(chat, bp); // 1 + save_pack_state_bin(chat, bp); // 2 + save_pack_topic_info(chat, bp); // 3 + save_pack_mod_list(chat, bp); // 4 + save_pack_keys(chat, bp); // 5 + save_pack_self_info(chat, bp); // 6 + save_pack_saved_peers(chat, bp); // 7 +} diff --git a/protocols/Tox/libtox/src/toxcore/group_pack.h b/protocols/Tox/libtox/src/toxcore/group_pack.h new file mode 100644 index 0000000000..ae831ac708 --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/group_pack.h @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Copyright © 2016-2020 The TokTok team. + * Copyright © 2015 Tox project. + */ + +/** + * Packer and unpacker functions for saving and loading groups. + */ + +#ifndef GROUP_PACK_H +#define GROUP_PACK_H + +#include <stdbool.h> + +#include "bin_pack.h" +#include "bin_unpack.h" +#include "group_common.h" + +/** + * Packs group data from `chat` into `mp` in binary format. Parallel to the + * `gc_load_unpack_group` function. + */ +non_null() +void gc_save_pack_group(const GC_Chat *chat, Bin_Pack *bp); + +/** + * Unpacks binary group data from `obj` into `chat`. Parallel to the `gc_save_pack_group` + * function. + * + * Return true if unpacking is successful. + */ +non_null() +bool gc_load_unpack_group(GC_Chat *chat, Bin_Unpack *bu); + +#endif // GROUP_PACK_H diff --git a/protocols/Tox/libtox/src/toxcore/net_crypto.c b/protocols/Tox/libtox/src/toxcore/net_crypto.c index c34a45734c..71f6e39e64 100644 --- a/protocols/Tox/libtox/src/toxcore/net_crypto.c +++ b/protocols/Tox/libtox/src/toxcore/net_crypto.c @@ -223,15 +223,15 @@ static int create_cookie_request(const Net_Crypto *c, uint8_t *packet, const uin memcpy(plain, c->self_public_key, CRYPTO_PUBLIC_KEY_SIZE); memcpy(plain + CRYPTO_PUBLIC_KEY_SIZE, padding, CRYPTO_PUBLIC_KEY_SIZE); memcpy(plain + (CRYPTO_PUBLIC_KEY_SIZE * 2), &number, sizeof(uint64_t)); - - dht_get_shared_key_sent(c->dht, shared_key, dht_public_key); + const uint8_t *tmp_shared_key = dht_get_shared_key_sent(c->dht, dht_public_key); + memcpy(shared_key, tmp_shared_key, CRYPTO_SHARED_KEY_SIZE); uint8_t nonce[CRYPTO_NONCE_SIZE]; random_nonce(c->rng, nonce); packet[0] = NET_PACKET_COOKIE_REQUEST; memcpy(packet + 1, dht_get_self_public_key(c->dht), CRYPTO_PUBLIC_KEY_SIZE); memcpy(packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, nonce, CRYPTO_NONCE_SIZE); const int len = encrypt_data_symmetric(shared_key, nonce, plain, sizeof(plain), - packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE); + packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE); if (len != COOKIE_REQUEST_PLAIN_LENGTH + CRYPTO_MAC_SIZE) { return -1; @@ -341,10 +341,11 @@ static int handle_cookie_request(const Net_Crypto *c, uint8_t *request_plain, ui } memcpy(dht_public_key, packet + 1, CRYPTO_PUBLIC_KEY_SIZE); - dht_get_shared_key_sent(c->dht, shared_key, dht_public_key); + const uint8_t *tmp_shared_key = dht_get_shared_key_sent(c->dht, dht_public_key); + memcpy(shared_key, tmp_shared_key, CRYPTO_SHARED_KEY_SIZE); const int len = decrypt_data_symmetric(shared_key, packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, - packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE, COOKIE_REQUEST_PLAIN_LENGTH + CRYPTO_MAC_SIZE, - request_plain); + packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE, COOKIE_REQUEST_PLAIN_LENGTH + CRYPTO_MAC_SIZE, + request_plain); if (len != COOKIE_REQUEST_PLAIN_LENGTH) { return -1; @@ -488,7 +489,7 @@ static int create_crypto_handshake(const Net_Crypto *c, uint8_t *packet, const u random_nonce(c->rng, packet + 1 + COOKIE_LENGTH); const int len = encrypt_data(peer_real_pk, c->self_secret_key, packet + 1 + COOKIE_LENGTH, plain, sizeof(plain), - packet + 1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE); + packet + 1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE); if (len != HANDSHAKE_PACKET_LENGTH - (1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE)) { return -1; @@ -541,8 +542,8 @@ static bool handle_crypto_handshake(const Net_Crypto *c, uint8_t *nonce, uint8_t uint8_t plain[CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SHA512_SIZE + COOKIE_LENGTH]; const int len = decrypt_data(cookie_plain, c->self_secret_key, packet + 1 + COOKIE_LENGTH, - packet + 1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE, - HANDSHAKE_PACKET_LENGTH - (1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE), plain); + packet + 1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE, + HANDSHAKE_PACKET_LENGTH - (1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE), plain); if (len != sizeof(plain)) { return false; @@ -1273,7 +1274,7 @@ static int handle_data_packet(const Net_Crypto *c, int crypt_connection_id, uint const uint16_t diff = num - num_cur_nonce; increment_nonce_number(nonce, diff); const int len = decrypt_data_symmetric(conn->shared_key, nonce, packet + 1 + sizeof(uint16_t), - length - (1 + sizeof(uint16_t)), data); + length - (1 + sizeof(uint16_t)), data); if ((unsigned int)len != length - crypto_packet_overhead) { return -1; @@ -1515,7 +1516,7 @@ static void connection_kill(Net_Crypto *c, int crypt_connection_id, void *userda if (conn->connection_status_callback != nullptr) { conn->connection_status_callback(conn->connection_status_callback_object, conn->connection_status_callback_id, - false, userdata); + false, userdata); } while (true) { /* TODO(irungentoo): is this really the best way to do this? */ @@ -1602,7 +1603,7 @@ static int handle_data_packet_core(Net_Crypto *c, int crypt_connection_id, const if (conn->connection_status_callback != nullptr) { conn->connection_status_callback(conn->connection_status_callback_object, conn->connection_status_callback_id, - true, userdata); + true, userdata); } } @@ -1616,8 +1617,8 @@ static int handle_data_packet_core(Net_Crypto *c, int crypt_connection_id, const } const int requested = handle_request_packet(c->mono_time, &conn->send_array, - real_data, real_length, - &rtt_calc_time, rtt_time); + real_data, real_length, + &rtt_calc_time, rtt_time); if (requested == -1) { return -1; @@ -2657,7 +2658,7 @@ static void send_crypto_packets(Net_Crypto *c) &conn->recv_array) + 1.0) / (conn->packet_recv_rate + 1.0)); const double request_packet_interval2 = ((CRYPTO_PACKET_MIN_RATE / conn->packet_recv_rate) * - (double)CRYPTO_SEND_PACKET_INTERVAL) + (double)PACKET_COUNTER_AVERAGE_INTERVAL; + (double)CRYPTO_SEND_PACKET_INTERVAL) + (double)PACKET_COUNTER_AVERAGE_INTERVAL; if (request_packet_interval2 < request_packet_interval) { request_packet_interval = request_packet_interval2; @@ -2750,7 +2751,7 @@ static void send_crypto_packets(Net_Crypto *c) PACKET_COUNTER_AVERAGE_INTERVAL)); const double min_speed_request = 1000.0 * (((double)(total_sent + total_resent)) / ( - (double)CONGESTION_QUEUE_ARRAY_SIZE * PACKET_COUNTER_AVERAGE_INTERVAL)); + (double)CONGESTION_QUEUE_ARRAY_SIZE * PACKET_COUNTER_AVERAGE_INTERVAL)); if (min_speed < CRYPTO_PACKET_MIN_RATE) { min_speed = CRYPTO_PACKET_MIN_RATE; diff --git a/protocols/Tox/libtox/src/toxcore/net_crypto.h b/protocols/Tox/libtox/src/toxcore/net_crypto.h index f6e062f3be..0c3dfd0d45 100644 --- a/protocols/Tox/libtox/src/toxcore/net_crypto.h +++ b/protocols/Tox/libtox/src/toxcore/net_crypto.h @@ -59,6 +59,7 @@ #define PACKET_ID_FILE_SENDREQUEST 80 #define PACKET_ID_FILE_CONTROL 81 #define PACKET_ID_FILE_DATA 82 +#define PACKET_ID_INVITE_GROUPCHAT 95 #define PACKET_ID_INVITE_CONFERENCE 96 #define PACKET_ID_ONLINE_PACKET 97 #define PACKET_ID_DIRECT_CONFERENCE 98 diff --git a/protocols/Tox/libtox/src/toxcore/network.c b/protocols/Tox/libtox/src/toxcore/network.c index 35893b73dc..8544496c1c 100644 --- a/protocols/Tox/libtox/src/toxcore/network.c +++ b/protocols/Tox/libtox/src/toxcore/network.c @@ -655,6 +655,121 @@ static uint32_t data_1(uint16_t buflen, const uint8_t *buffer) return data; } +static const char *net_packet_type_name(Net_Packet_Type type) +{ + switch (type) { + case NET_PACKET_PING_REQUEST: + return "PING_REQUEST"; + + case NET_PACKET_PING_RESPONSE: + return "PING_RESPONSE"; + + case NET_PACKET_GET_NODES: + return "GET_NODES"; + + case NET_PACKET_SEND_NODES_IPV6: + return "SEND_NODES_IPV6"; + + case NET_PACKET_COOKIE_REQUEST: + return "COOKIE_REQUEST"; + + case NET_PACKET_COOKIE_RESPONSE: + return "COOKIE_RESPONSE"; + + case NET_PACKET_CRYPTO_HS: + return "CRYPTO_HS"; + + case NET_PACKET_CRYPTO_DATA: + return "CRYPTO_DATA"; + + case NET_PACKET_CRYPTO: + return "CRYPTO"; + + case NET_PACKET_GC_HANDSHAKE: + return "GC_HANDSHAKE"; + + case NET_PACKET_GC_LOSSLESS: + return "GC_LOSSLESS"; + + case NET_PACKET_GC_LOSSY: + return "GC_LOSSY"; + + case NET_PACKET_LAN_DISCOVERY: + return "LAN_DISCOVERY"; + + case NET_PACKET_ONION_SEND_INITIAL: + return "ONION_SEND_INITIAL"; + + case NET_PACKET_ONION_SEND_1: + return "ONION_SEND_1"; + + case NET_PACKET_ONION_SEND_2: + return "ONION_SEND_2"; + + case NET_PACKET_ANNOUNCE_REQUEST_OLD: + return "ANNOUNCE_REQUEST_OLD"; + + case NET_PACKET_ANNOUNCE_RESPONSE_OLD: + return "ANNOUNCE_RESPONSE_OLD"; + + case NET_PACKET_ONION_DATA_REQUEST: + return "ONION_DATA_REQUEST"; + + case NET_PACKET_ONION_DATA_RESPONSE: + return "ONION_DATA_RESPONSE"; + + case NET_PACKET_ANNOUNCE_REQUEST: + return "ANNOUNCE_REQUEST"; + + case NET_PACKET_ANNOUNCE_RESPONSE: + return "ANNOUNCE_RESPONSE"; + + case NET_PACKET_ONION_RECV_3: + return "ONION_RECV_3"; + + case NET_PACKET_ONION_RECV_2: + return "ONION_RECV_2"; + + case NET_PACKET_ONION_RECV_1: + return "ONION_RECV_1"; + + case NET_PACKET_FORWARD_REQUEST: + return "FORWARD_REQUEST"; + + case NET_PACKET_FORWARDING: + return "FORWARDING"; + + case NET_PACKET_FORWARD_REPLY: + return "FORWARD_REPLY"; + + case NET_PACKET_DATA_SEARCH_REQUEST: + return "DATA_SEARCH_REQUEST"; + + case NET_PACKET_DATA_SEARCH_RESPONSE: + return "DATA_SEARCH_RESPONSE"; + + case NET_PACKET_DATA_RETRIEVE_REQUEST: + return "DATA_RETRIEVE_REQUEST"; + + case NET_PACKET_DATA_RETRIEVE_RESPONSE: + return "DATA_RETRIEVE_RESPONSE"; + + case NET_PACKET_STORE_ANNOUNCE_REQUEST: + return "STORE_ANNOUNCE_REQUEST"; + + case NET_PACKET_STORE_ANNOUNCE_RESPONSE: + return "STORE_ANNOUNCE_RESPONSE"; + + case BOOTSTRAP_INFO_PACKET_ID: + return "BOOTSTRAP_INFO"; + + case NET_PACKET_MAX: + return "MAX"; + } + + return "<unknown>"; +} + non_null() static void loglogdata(const Logger *log, const char *message, const uint8_t *buffer, uint16_t buflen, const IP_Port *ip_port, long res) @@ -663,21 +778,24 @@ static void loglogdata(const Logger *log, const char *message, const uint8_t *bu Ip_Ntoa ip_str; const int error = net_error(); char *strerror = net_new_strerror(error); - LOGGER_TRACE(log, "[%2u] %s %3u%c %s:%u (%u: %s) | %08x%08x...%02x", - buffer[0], message, min_u16(buflen, 999), 'E', + LOGGER_TRACE(log, "[%02x = %-20s] %s %3u%c %s:%u (%u: %s) | %08x%08x...%02x", + buffer[0], net_packet_type_name((Net_Packet_Type)buffer[0]), message, + min_u16(buflen, 999), 'E', net_ip_ntoa(&ip_port->ip, &ip_str), net_ntohs(ip_port->port), error, strerror, data_0(buflen, buffer), data_1(buflen, buffer), buffer[buflen - 1]); net_kill_strerror(strerror); } else if ((res > 0) && ((size_t)res <= buflen)) { Ip_Ntoa ip_str; - LOGGER_TRACE(log, "[%2u] %s %3u%c %s:%u (%u: %s) | %08x%08x...%02x", - buffer[0], message, min_u16(res, 999), (size_t)res < buflen ? '<' : '=', + LOGGER_TRACE(log, "[%02x = %-20s] %s %3u%c %s:%u (%u: %s) | %08x%08x...%02x", + buffer[0], net_packet_type_name((Net_Packet_Type)buffer[0]), message, + min_u16(res, 999), (size_t)res < buflen ? '<' : '=', net_ip_ntoa(&ip_port->ip, &ip_str), net_ntohs(ip_port->port), 0, "OK", data_0(buflen, buffer), data_1(buflen, buffer), buffer[buflen - 1]); } else { /* empty or overwrite */ Ip_Ntoa ip_str; - LOGGER_TRACE(log, "[%2u] %s %lu%c%u %s:%u (%u: %s) | %08x%08x...%02x", - buffer[0], message, res, res == 0 ? '!' : '>', buflen, + LOGGER_TRACE(log, "[%02x = %-20s] %s %lu%c%u %s:%u (%u: %s) | %08x%08x...%02x", + buffer[0], net_packet_type_name((Net_Packet_Type)buffer[0]), message, + res, res == 0 ? '!' : '>', buflen, net_ip_ntoa(&ip_port->ip, &ip_str), net_ntohs(ip_port->port), 0, "OK", data_0(buflen, buffer), data_1(buflen, buffer), buffer[buflen - 1]); } @@ -1616,7 +1734,7 @@ bool net_connect(const Logger *log, Socket sock, const IP_Port *ip_port) } else { Ip_Ntoa ip_str; LOGGER_ERROR(log, "cannot connect to %s:%d which is neither IPv4 nor IPv6", - net_ip_ntoa(&ip_port->ip, &ip_str), ip_port->port); + net_ip_ntoa(&ip_port->ip, &ip_str), net_ntohs(ip_port->port)); return false; } @@ -1638,7 +1756,7 @@ bool net_connect(const Logger *log, Socket sock, const IP_Port *ip_port) if (!should_ignore_connect_error(error)) { char *net_strerror = net_new_strerror(error); LOGGER_ERROR(log, "failed to connect to %s:%d: %d (%s)", - net_ip_ntoa(&ip_port->ip, &ip_str), ip_port->port, error, net_strerror); + net_ip_ntoa(&ip_port->ip, &ip_str), net_ntohs(ip_port->port), error, net_strerror); net_kill_strerror(net_strerror); return false; } @@ -1649,18 +1767,6 @@ bool net_connect(const Logger *log, Socket sock, const IP_Port *ip_port) int32_t net_getipport(const char *node, IP_Port **res, int tox_type) { -#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION - if ((true)) { - *res = (IP_Port *)calloc(1, sizeof(IP_Port)); - assert(*res != nullptr); - IP_Port *ip_port = *res; - ip_port->ip.ip.v4.uint32 = 0x7F000003; // 127.0.0.3 - ip_port->ip.family = *make_tox_family(AF_INET); - - return 1; - } -#endif - // Try parsing as IP address first. IP_Port parsed = {{{0}}}; @@ -1676,6 +1782,18 @@ int32_t net_getipport(const char *node, IP_Port **res, int tox_type) return 1; } +#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION + if ((true)) { + *res = (IP_Port *)calloc(1, sizeof(IP_Port)); + assert(*res != nullptr); + IP_Port *ip_port = *res; + ip_port->ip.ip.v4.uint32 = net_htonl(0x7F000003); // 127.0.0.3 + ip_port->ip.family = *make_tox_family(AF_INET); + + return 1; + } +#endif + // It's not an IP address, so now we try doing a DNS lookup. struct addrinfo *infos; const int ret = getaddrinfo(node, nullptr, nullptr, &infos); @@ -1814,6 +1932,12 @@ uint16_t net_ntohs(uint16_t hostshort) return ntohs(hostshort); } +size_t net_pack_bool(uint8_t *bytes, bool v) +{ + bytes[0] = v ? 1 : 0; + return 1; +} + size_t net_pack_u16(uint8_t *bytes, uint16_t v) { bytes[0] = (v >> 8) & 0xff; @@ -1837,6 +1961,12 @@ size_t net_pack_u64(uint8_t *bytes, uint64_t v) return p - bytes; } +size_t net_unpack_bool(const uint8_t *bytes, bool *v) +{ + *v = bytes[0] != 0; + return 1; +} + size_t net_unpack_u16(const uint8_t *bytes, uint16_t *v) { const uint8_t hi = bytes[0]; diff --git a/protocols/Tox/libtox/src/toxcore/network.h b/protocols/Tox/libtox/src/toxcore/network.h index a1fc6a74fc..ffc04ed6e4 100644 --- a/protocols/Tox/libtox/src/toxcore/network.h +++ b/protocols/Tox/libtox/src/toxcore/network.h @@ -109,10 +109,9 @@ typedef enum Net_Packet_Type { NET_PACKET_CRYPTO = 0x24, /* Encrypted data packet ID. */ NET_PACKET_LAN_DISCOVERY = 0x25, /* LAN discovery packet ID. */ - // TODO(Jfreegman): Uncomment these when we merge the rest of new groupchats - // NET_PACKET_GC_HANDSHAKE = 0x62, /* Group chat handshake packet ID */ - // NET_PACKET_GC_LOSSLESS = 0x63, /* Group chat lossless packet ID */ - // NET_PACKET_GC_LOSSY = 0x64, /* Group chat lossy packet ID */ + NET_PACKET_GC_HANDSHAKE = 0x62, /* Group chat handshake packet ID */ + NET_PACKET_GC_LOSSLESS = 0x63, /* Group chat lossless packet ID */ + NET_PACKET_GC_LOSSY = 0x64, /* Group chat lossy packet ID */ /* See: `docs/Prevent_Tracking.txt` and `onion.{c,h}` */ NET_PACKET_ONION_SEND_INITIAL = 0x8f, @@ -131,6 +130,17 @@ typedef enum Net_Packet_Type { NET_PACKET_ONION_RECV_2 = 0x9c, NET_PACKET_ONION_RECV_1 = 0x9d, + NET_PACKET_FORWARD_REQUEST = 0x9e, + NET_PACKET_FORWARDING = 0x9f, + NET_PACKET_FORWARD_REPLY = 0xa0, + + NET_PACKET_DATA_SEARCH_REQUEST = 0xa1, + NET_PACKET_DATA_SEARCH_RESPONSE = 0xa2, + NET_PACKET_DATA_RETRIEVE_REQUEST = 0xa3, + NET_PACKET_DATA_RETRIEVE_RESPONSE = 0xa4, + NET_PACKET_STORE_ANNOUNCE_REQUEST = 0xa5, + NET_PACKET_STORE_ANNOUNCE_RESPONSE = 0xa6, + BOOTSTRAP_INFO_PACKET_ID = 0xf1, /* Only used for bootstrap nodes */ NET_PACKET_MAX = 0xff, /* This type must remain within a single uint8. */ @@ -148,10 +158,9 @@ typedef enum Net_Packet_Type { NET_PACKET_CRYPTO = 0x20, /* Encrypted data packet ID. */ NET_PACKET_LAN_DISCOVERY = 0x21, /* LAN discovery packet ID. */ - // TODO(Jfreegman): Uncomment these when we merge the rest of new groupchats - // NET_PACKET_GC_HANDSHAKE = 0x5a, /* Group chat handshake packet ID */ - // NET_PACKET_GC_LOSSLESS = 0x5b, /* Group chat lossless packet ID */ - // NET_PACKET_GC_LOSSY = 0x5c, /* Group chat lossy packet ID */ + NET_PACKET_GC_HANDSHAKE = 0x5a, /* Group chat handshake packet ID */ + NET_PACKET_GC_LOSSLESS = 0x5b, /* Group chat lossless packet ID */ + NET_PACKET_GC_LOSSY = 0x5c, /* Group chat lossy packet ID */ /* See: `docs/Prevent_Tracking.txt` and `onion.{c,h}` */ NET_PACKET_ONION_SEND_INITIAL = 0x80, @@ -304,6 +313,8 @@ uint32_t net_ntohl(uint32_t hostlong); uint16_t net_ntohs(uint16_t hostshort); non_null() +size_t net_pack_bool(uint8_t *bytes, bool v); +non_null() size_t net_pack_u16(uint8_t *bytes, uint16_t v); non_null() size_t net_pack_u32(uint8_t *bytes, uint32_t v); @@ -311,6 +322,8 @@ non_null() size_t net_pack_u64(uint8_t *bytes, uint64_t v); non_null() +size_t net_unpack_bool(const uint8_t *bytes, bool *v); +non_null() size_t net_unpack_u16(const uint8_t *bytes, uint16_t *v); non_null() size_t net_unpack_u32(const uint8_t *bytes, uint32_t *v); @@ -531,8 +544,9 @@ bool net_connect(const Logger *log, Socket sock, const IP_Port *ip_port); * Skip all addresses with socktype != type (use type = -1 to get all addresses) * To correctly deallocate array memory use `net_freeipport()` * - * return number of elements in res array - * and -1 on error. + * @return number of elements in res array. + * @retval 0 if res array empty. + * @retval -1 on error. */ non_null() int32_t net_getipport(const char *node, IP_Port **res, int tox_type); diff --git a/protocols/Tox/libtox/src/toxcore/onion.c b/protocols/Tox/libtox/src/toxcore/onion.c index d7e3f02665..63ff6d8520 100644 --- a/protocols/Tox/libtox/src/toxcore/onion.c +++ b/protocols/Tox/libtox/src/toxcore/onion.c @@ -27,6 +27,11 @@ #define KEY_REFRESH_INTERVAL (2 * 60 * 60) + +// Settings for the shared key cache +#define MAX_KEYS_PER_SLOT 4 +#define KEYS_TIMEOUT 600 + /** Change symmetric keys every 2 hours to make paths expire eventually. */ non_null() static void change_symmetric_key(Onion *onion) @@ -314,9 +319,14 @@ static int handle_send_initial(void *object, const IP_Port *source, const uint8_ change_symmetric_key(onion); uint8_t plain[ONION_MAX_PACKET_SIZE]; - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - get_shared_key(onion->mono_time, &onion->shared_keys_1, shared_key, dht_get_self_secret_key(onion->dht), - packet + 1 + CRYPTO_NONCE_SIZE); + const uint8_t *public_key = packet + 1 + CRYPTO_NONCE_SIZE; + const uint8_t *shared_key = shared_key_cache_lookup(onion->shared_keys_1, public_key); + + if (shared_key == nullptr) { + /* Error looking up/deriving the shared key */ + return 1; + } + const int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE, length - (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE), plain); @@ -385,9 +395,14 @@ static int handle_send_1(void *object, const IP_Port *source, const uint8_t *pac change_symmetric_key(onion); uint8_t plain[ONION_MAX_PACKET_SIZE]; - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - get_shared_key(onion->mono_time, &onion->shared_keys_2, shared_key, dht_get_self_secret_key(onion->dht), - packet + 1 + CRYPTO_NONCE_SIZE); + const uint8_t *public_key = packet + 1 + CRYPTO_NONCE_SIZE; + const uint8_t *shared_key = shared_key_cache_lookup(onion->shared_keys_2, public_key); + + if (shared_key == nullptr) { + /* Error looking up/deriving the shared key */ + return 1; + } + int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE, length - (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + RETURN_1), plain); @@ -443,9 +458,14 @@ static int handle_send_2(void *object, const IP_Port *source, const uint8_t *pac change_symmetric_key(onion); uint8_t plain[ONION_MAX_PACKET_SIZE]; - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - get_shared_key(onion->mono_time, &onion->shared_keys_3, shared_key, dht_get_self_secret_key(onion->dht), - packet + 1 + CRYPTO_NONCE_SIZE); + const uint8_t *public_key = packet + 1 + CRYPTO_NONCE_SIZE; + const uint8_t *shared_key = shared_key_cache_lookup(onion->shared_keys_3, public_key); + + if (shared_key == nullptr) { + /* Error looking up/deriving the shared key */ + return 1; + } + int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE, length - (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + RETURN_2), plain); @@ -457,7 +477,8 @@ static int handle_send_2(void *object, const IP_Port *source, const uint8_t *pac const uint8_t packet_id = plain[SIZE_IPPORT]; - if (packet_id != NET_PACKET_ANNOUNCE_REQUEST_OLD && packet_id != NET_PACKET_ONION_DATA_REQUEST) { + if (packet_id != NET_PACKET_ANNOUNCE_REQUEST && packet_id != NET_PACKET_ANNOUNCE_REQUEST_OLD && + packet_id != NET_PACKET_ONION_DATA_REQUEST) { return 1; } @@ -507,7 +528,8 @@ static int handle_recv_3(void *object, const IP_Port *source, const uint8_t *pac const uint8_t packet_id = packet[1 + RETURN_3]; - if (packet_id != NET_PACKET_ANNOUNCE_RESPONSE_OLD && packet_id != NET_PACKET_ONION_DATA_RESPONSE) { + if (packet_id != NET_PACKET_ANNOUNCE_RESPONSE && packet_id != NET_PACKET_ANNOUNCE_RESPONSE_OLD && + packet_id != NET_PACKET_ONION_DATA_RESPONSE) { return 1; } @@ -555,7 +577,8 @@ static int handle_recv_2(void *object, const IP_Port *source, const uint8_t *pac const uint8_t packet_id = packet[1 + RETURN_2]; - if (packet_id != NET_PACKET_ANNOUNCE_RESPONSE_OLD && packet_id != NET_PACKET_ONION_DATA_RESPONSE) { + if (packet_id != NET_PACKET_ANNOUNCE_RESPONSE && packet_id != NET_PACKET_ANNOUNCE_RESPONSE_OLD && + packet_id != NET_PACKET_ONION_DATA_RESPONSE) { return 1; } @@ -603,7 +626,8 @@ static int handle_recv_1(void *object, const IP_Port *source, const uint8_t *pac const uint8_t packet_id = packet[1 + RETURN_1]; - if (packet_id != NET_PACKET_ANNOUNCE_RESPONSE_OLD && packet_id != NET_PACKET_ONION_DATA_RESPONSE) { + if (packet_id != NET_PACKET_ANNOUNCE_RESPONSE && packet_id != NET_PACKET_ANNOUNCE_RESPONSE_OLD && + packet_id != NET_PACKET_ONION_DATA_RESPONSE) { return 1; } @@ -664,6 +688,19 @@ Onion *new_onion(const Logger *log, const Mono_Time *mono_time, const Random *rn new_symmetric_key(rng, onion->secret_symmetric_key); onion->timestamp = mono_time_get(onion->mono_time); + const uint8_t *secret_key = dht_get_self_secret_key(dht); + onion->shared_keys_1 = shared_key_cache_new(mono_time, secret_key, KEYS_TIMEOUT, MAX_KEYS_PER_SLOT); + onion->shared_keys_2 = shared_key_cache_new(mono_time, secret_key, KEYS_TIMEOUT, MAX_KEYS_PER_SLOT); + onion->shared_keys_3 = shared_key_cache_new(mono_time, secret_key, KEYS_TIMEOUT, MAX_KEYS_PER_SLOT); + + if (onion->shared_keys_1 == nullptr || + onion->shared_keys_2 == nullptr || + onion->shared_keys_3 == nullptr) { + kill_onion(onion); + return nullptr; + } + + networking_registerhandler(onion->net, NET_PACKET_ONION_SEND_INITIAL, &handle_send_initial, onion); networking_registerhandler(onion->net, NET_PACKET_ONION_SEND_1, &handle_send_1, onion); networking_registerhandler(onion->net, NET_PACKET_ONION_SEND_2, &handle_send_2, onion); @@ -691,5 +728,9 @@ void kill_onion(Onion *onion) crypto_memzero(onion->secret_symmetric_key, sizeof(onion->secret_symmetric_key)); + shared_key_cache_free(onion->shared_keys_1); + shared_key_cache_free(onion->shared_keys_2); + shared_key_cache_free(onion->shared_keys_3); + free(onion); } diff --git a/protocols/Tox/libtox/src/toxcore/onion.h b/protocols/Tox/libtox/src/toxcore/onion.h index 3da2137c44..5c8f920b44 100644 --- a/protocols/Tox/libtox/src/toxcore/onion.h +++ b/protocols/Tox/libtox/src/toxcore/onion.h @@ -12,6 +12,7 @@ #include "DHT.h" #include "logger.h" #include "mono_time.h" +#include "shared_key_cache.h" typedef int onion_recv_1_cb(void *object, const IP_Port *dest, const uint8_t *data, uint16_t length); @@ -24,9 +25,9 @@ typedef struct Onion { uint8_t secret_symmetric_key[CRYPTO_SYMMETRIC_KEY_SIZE]; uint64_t timestamp; - Shared_Keys shared_keys_1; - Shared_Keys shared_keys_2; - Shared_Keys shared_keys_3; + Shared_Key_Cache *shared_keys_1; + Shared_Key_Cache *shared_keys_2; + Shared_Key_Cache *shared_keys_3; onion_recv_1_cb *recv_1_function; void *callback_object; diff --git a/protocols/Tox/libtox/src/toxcore/onion_announce.c b/protocols/Tox/libtox/src/toxcore/onion_announce.c index f12e560837..fb04d21f56 100644 --- a/protocols/Tox/libtox/src/toxcore/onion_announce.c +++ b/protocols/Tox/libtox/src/toxcore/onion_announce.c @@ -16,6 +16,7 @@ #include "LAN_discovery.h" #include "ccompat.h" #include "mono_time.h" +#include "shared_key_cache.h" #include "util.h" #define PING_ID_TIMEOUT ONION_ANNOUNCE_TIMEOUT @@ -31,6 +32,10 @@ #define ONION_MINIMAL_SIZE (ONION_PING_ID_SIZE + CRYPTO_PUBLIC_KEY_SIZE * 2 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH) +/* Settings for the shared key cache */ +#define MAX_KEYS_PER_SLOT 4 +#define KEYS_TIMEOUT 600 + static_assert(ONION_PING_ID_SIZE == CRYPTO_PUBLIC_KEY_SIZE, "announce response packets assume that ONION_PING_ID_SIZE is equal to CRYPTO_PUBLIC_KEY_SIZE"); @@ -51,7 +56,7 @@ struct Onion_Announce { Onion_Announce_Entry entries[ONION_ANNOUNCE_MAX_ENTRIES]; uint8_t hmac_key[CRYPTO_HMAC_KEY_SIZE]; - Shared_Keys shared_keys_recv; + Shared_Key_Cache *shared_keys_recv; uint16_t extra_data_max_size; pack_extra_data_cb *extra_data_callback; @@ -346,7 +351,6 @@ non_null() static int add_to_entries(Onion_Announce *onion_a, const IP_Port *ret_ip_port, const uint8_t *public_key, const uint8_t *data_public_key, const uint8_t *ret) { - int pos = in_entries(onion_a, public_key); if (pos == -1) { @@ -427,9 +431,12 @@ static int handle_announce_request_common( pack_extra_data_cb *pack_extra_data_callback) { const uint8_t *packet_public_key = packet + 1 + CRYPTO_NONCE_SIZE; - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - get_shared_key(onion_a->mono_time, &onion_a->shared_keys_recv, shared_key, dht_get_self_secret_key(onion_a->dht), - packet_public_key); + const uint8_t *shared_key = shared_key_cache_lookup(onion_a->shared_keys_recv, packet_public_key); + + if (shared_key == nullptr) { + /* Error looking up/deriving the shared key */ + return 1; + } uint8_t *plain = (uint8_t *)malloc(plain_size); @@ -654,13 +661,16 @@ Onion_Announce *new_onion_announce(const Logger *log, const Random *rng, const M onion_a->extra_data_object = nullptr; new_hmac_key(rng, onion_a->hmac_key); + onion_a->shared_keys_recv = shared_key_cache_new(mono_time, dht_get_self_secret_key(dht), KEYS_TIMEOUT, MAX_KEYS_PER_SLOT); + if (onion_a->shared_keys_recv == nullptr) { + kill_onion_announce(onion_a); + return nullptr; + } + networking_registerhandler(onion_a->net, NET_PACKET_ANNOUNCE_REQUEST, &handle_announce_request, onion_a); networking_registerhandler(onion_a->net, NET_PACKET_ANNOUNCE_REQUEST_OLD, &handle_announce_request_old, onion_a); networking_registerhandler(onion_a->net, NET_PACKET_ONION_DATA_REQUEST, &handle_data_request, onion_a); - // TODO(Jfreegman): Remove this when we merge the rest of new groupchats - onion_announce_extra_data_callback(onion_a, 0, nullptr, nullptr); - return onion_a; } @@ -675,6 +685,7 @@ void kill_onion_announce(Onion_Announce *onion_a) networking_registerhandler(onion_a->net, NET_PACKET_ONION_DATA_REQUEST, nullptr, nullptr); crypto_memzero(onion_a->hmac_key, CRYPTO_HMAC_KEY_SIZE); + shared_key_cache_free(onion_a->shared_keys_recv); free(onion_a); } diff --git a/protocols/Tox/libtox/src/toxcore/onion_announce.h b/protocols/Tox/libtox/src/toxcore/onion_announce.h index 8cf1f49539..24303abccb 100644 --- a/protocols/Tox/libtox/src/toxcore/onion_announce.h +++ b/protocols/Tox/libtox/src/toxcore/onion_announce.h @@ -20,6 +20,7 @@ #define ONION_ANNOUNCE_SENDBACK_DATA_LENGTH (sizeof(uint64_t)) +#define MAX_SENT_GC_NODES 1 #define ONION_ANNOUNCE_REQUEST_MIN_SIZE (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + ONION_PING_ID_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_PUBLIC_KEY_SIZE + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_MAC_SIZE) #define ONION_ANNOUNCE_REQUEST_MAX_SIZE (ONION_ANNOUNCE_REQUEST_MIN_SIZE + ONION_MAX_EXTRA_DATA_SIZE) @@ -125,7 +126,7 @@ typedef int pack_extra_data_cb(void *object, const Logger *logger, const Mono_Ti uint8_t num_nodes, uint8_t *plain, uint16_t plain_size, uint8_t *response, uint16_t response_size, uint16_t offset); -non_null(1) nullable(3, 4) +non_null() void onion_announce_extra_data_callback(Onion_Announce *onion_a, uint16_t extra_data_max_size, pack_extra_data_cb *extra_data_callback, void *extra_data_object); diff --git a/protocols/Tox/libtox/src/toxcore/onion_client.c b/protocols/Tox/libtox/src/toxcore/onion_client.c index 91168c661c..ff63473e10 100644 --- a/protocols/Tox/libtox/src/toxcore/onion_client.c +++ b/protocols/Tox/libtox/src/toxcore/onion_client.c @@ -15,6 +15,7 @@ #include "LAN_discovery.h" #include "ccompat.h" +#include "group_onion_announce.h" #include "mono_time.h" #include "util.h" @@ -54,7 +55,7 @@ typedef struct Last_Pinged { uint64_t timestamp; } Last_Pinged; -typedef struct Onion_Friend { +struct Onion_Friend { bool is_valid; bool is_online; @@ -87,7 +88,12 @@ typedef struct Onion_Friend { onion_dht_pk_cb *dht_pk_callback; void *dht_pk_callback_object; uint32_t dht_pk_callback_number; -} Onion_Friend; + + uint8_t gc_data[GCA_MAX_DATA_LENGTH]; + uint8_t gc_public_key[ENC_PUBLIC_KEY_SIZE]; + uint16_t gc_data_length; + bool is_groupchat; +}; static const Onion_Friend empty_onion_friend = {false}; @@ -138,8 +144,51 @@ struct Onion_Client { unsigned int onion_connected; bool udp_connected; + + onion_group_announce_cb *group_announce_response; + void *group_announce_response_user_data; }; +uint16_t onion_get_friend_count(const Onion_Client *const onion_c) +{ + return onion_c->num_friends; +} + +Onion_Friend *onion_get_friend(const Onion_Client *const onion_c, uint16_t friend_num) +{ + return &onion_c->friends_list[friend_num]; +} + +const uint8_t *onion_friend_get_gc_public_key(const Onion_Friend *const onion_friend) +{ + return onion_friend->gc_public_key; +} + +const uint8_t *onion_friend_get_gc_public_key_num(const Onion_Client *const onion_c, uint32_t num) +{ + return onion_c->friends_list[num].gc_public_key; +} + +void onion_friend_set_gc_public_key(Onion_Friend *const onion_friend, const uint8_t *public_key) +{ + memcpy(onion_friend->gc_public_key, public_key, ENC_PUBLIC_KEY_SIZE); +} + +void onion_friend_set_gc_data(Onion_Friend *const onion_friend, const uint8_t *gc_data, uint16_t gc_data_length) +{ + if (gc_data_length > 0 && gc_data != nullptr) { + memcpy(onion_friend->gc_data, gc_data, gc_data_length); + } + + onion_friend->gc_data_length = gc_data_length; + onion_friend->is_groupchat = true; +} + +bool onion_friend_is_groupchat(const Onion_Friend *const onion_friend) +{ + return onion_friend->is_groupchat; +} + DHT *onion_get_dht(const Onion_Client *onion_c) { return onion_c->dht; @@ -351,8 +400,8 @@ static bool path_timed_out(const Mono_Time *mono_time, const Onion_Client_Paths const uint64_t timeout = is_new ? ONION_PATH_FIRST_TIMEOUT : ONION_PATH_TIMEOUT; return (onion_paths->last_path_used_times[pathnum] >= ONION_PATH_MAX_NO_RESPONSE_USES - && mono_time_is_timeout(mono_time, onion_paths->last_path_used[pathnum], timeout)) - || mono_time_is_timeout(mono_time, onion_paths->path_creation_time[pathnum], ONION_PATH_MAX_LIFETIME); + && mono_time_is_timeout(mono_time, onion_paths->last_path_used[pathnum], timeout)) + || mono_time_is_timeout(mono_time, onion_paths->path_creation_time[pathnum], ONION_PATH_MAX_LIFETIME); } /** should node be considered to have timed out */ @@ -360,8 +409,8 @@ non_null() static bool onion_node_timed_out(const Onion_Node *node, const Mono_Time *mono_time) { return node->timestamp == 0 - || (node->pings_since_last_response >= ONION_NODE_MAX_PINGS - && mono_time_is_timeout(mono_time, node->last_pinged, ONION_NODE_TIMEOUT)); + || (node->pings_since_last_response >= ONION_NODE_MAX_PINGS + && mono_time_is_timeout(mono_time, node->last_pinged, ONION_NODE_TIMEOUT)); } /** @brief Create a new path or use an old suitable one (if pathnum is valid) @@ -600,19 +649,35 @@ static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, con ping_id = zero_ping_id; } - uint8_t request[ONION_ANNOUNCE_REQUEST_SIZE]; + uint8_t request[ONION_ANNOUNCE_REQUEST_MAX_SIZE]; int len; if (num == 0) { len = create_announce_request( - onion_c->rng, request, sizeof(request), dest_pubkey, nc_get_self_public_key(onion_c->c), - nc_get_self_secret_key(onion_c->c), ping_id, nc_get_self_public_key(onion_c->c), - onion_c->temp_public_key, sendback); + onion_c->rng, request, sizeof(request), dest_pubkey, nc_get_self_public_key(onion_c->c), + nc_get_self_secret_key(onion_c->c), ping_id, nc_get_self_public_key(onion_c->c), + onion_c->temp_public_key, sendback); } else { - len = create_announce_request( - onion_c->rng, request, sizeof(request), dest_pubkey, onion_c->friends_list[num - 1].temp_public_key, - onion_c->friends_list[num - 1].temp_secret_key, ping_id, - onion_c->friends_list[num - 1].real_public_key, zero_ping_id, sendback); + Onion_Friend *onion_friend = &onion_c->friends_list[num - 1]; + + if (onion_friend->gc_data_length == 0) { // contact is a friend + len = create_announce_request( + onion_c->rng, request, sizeof(request), dest_pubkey, onion_friend->temp_public_key, + onion_friend->temp_secret_key, ping_id, onion_friend->real_public_key, + zero_ping_id, sendback); + } else { // contact is a gc +#ifndef VANILLA_NACL + onion_friend->is_groupchat = true; + + len = create_gca_announce_request( + onion_c->rng, request, sizeof(request), dest_pubkey, onion_friend->temp_public_key, + onion_friend->temp_secret_key, ping_id, onion_friend->real_public_key, + zero_ping_id, sendback, onion_friend->gc_data, + onion_friend->gc_data_length); +#else + return -1; +#endif // VANILLA_NACL + } } if (len == -1) { @@ -852,6 +917,16 @@ static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_for } non_null() +static bool handle_group_announce_response(Onion_Client *onion_c, uint32_t num, const uint8_t *plain, size_t plain_size) +{ + if (onion_c->group_announce_response == nullptr) { + return true; + } + + return onion_c->group_announce_response(onion_c, num, plain, plain_size, onion_c->group_announce_response_user_data); +} + +non_null(1, 2, 3) nullable(5) static int handle_announce_response(void *object, const IP_Port *source, const uint8_t *packet, uint16_t length, void *userdata) { @@ -861,6 +936,95 @@ static int handle_announce_response(void *object, const IP_Port *source, const u return 1; } + uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]; + IP_Port ip_port; + uint32_t path_num; + const uint32_t num = check_sendback(onion_c, packet + 1, public_key, &ip_port, &path_num); + + if (num > onion_c->num_friends) { + return 1; + } + + uint8_t plain[1 + ONION_PING_ID_SIZE + ONION_ANNOUNCE_RESPONSE_MAX_SIZE - ONION_ANNOUNCE_RESPONSE_MIN_SIZE]; + const int plain_size = 1 + ONION_PING_ID_SIZE + length - ONION_ANNOUNCE_RESPONSE_MIN_SIZE; + int len; + + if (num == 0) { + len = decrypt_data(public_key, nc_get_self_secret_key(onion_c->c), + packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH, + packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE, + length - (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE), plain); + } else { + if (!onion_c->friends_list[num - 1].is_valid) { + return 1; + } + + len = decrypt_data(public_key, onion_c->friends_list[num - 1].temp_secret_key, + packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH, + packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE, + length - (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE), plain); + } + + if ((uint32_t)len != plain_size) { + return 1; + } + + const uint32_t path_used = set_path_timeouts(onion_c, num, path_num); + + if (client_add_to_list(onion_c, num, public_key, &ip_port, plain[0], plain + 1, path_used) == -1) { + return 1; + } + + uint16_t len_nodes = 0; + const uint8_t nodes_count = plain[1 + ONION_PING_ID_SIZE]; + + if (nodes_count > 0) { + if (nodes_count > MAX_SENT_NODES) { + return 1; + } + + Node_format nodes[MAX_SENT_NODES]; + const int num_nodes = unpack_nodes(nodes, nodes_count, &len_nodes, plain + 2 + ONION_PING_ID_SIZE, + plain_size - 2 - ONION_PING_ID_SIZE, false); + + if (num_nodes < 0) { + return 1; + } + + if (client_ping_nodes(onion_c, num, nodes, num_nodes, source) == -1) { + return 1; + } + } + + if (len_nodes + 1 < length - ONION_ANNOUNCE_RESPONSE_MIN_SIZE) { + const uint16_t offset = 2 + ONION_PING_ID_SIZE + len_nodes; + + if (plain_size < offset) { + return 1; + } + + if (!handle_group_announce_response(onion_c, num, plain + offset, plain_size - offset)) { + return 1; + } + } + + // TODO(irungentoo): LAN vs non LAN ips?, if we are connected only to LAN, are we offline? + onion_c->last_packet_recv = mono_time_get(onion_c->mono_time); + + return 0; +} + +/* TODO(jfreegman): DEPRECATE */ +non_null(1, 2, 3) nullable(5) +static int handle_announce_response_old(void *object, const IP_Port *source, const uint8_t *packet, uint16_t length, + void *userdata) +{ + Onion_Client *onion_c = (Onion_Client *)object; + + if (length < ONION_ANNOUNCE_RESPONSE_MIN_SIZE || length > ONION_ANNOUNCE_RESPONSE_MAX_SIZE) { + return 1; + } + const uint16_t len_nodes = length - ONION_ANNOUNCE_RESPONSE_MIN_SIZE; uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]; @@ -1038,10 +1202,14 @@ static int handle_tcp_onion(void *object, const uint8_t *data, uint16_t length, IP_Port ip_port = {{{0}}}; ip_port.ip.family = net_family_tcp_server(); - if (data[0] == NET_PACKET_ANNOUNCE_RESPONSE_OLD) { + if (data[0] == NET_PACKET_ANNOUNCE_RESPONSE) { return handle_announce_response(object, &ip_port, data, length, userdata); } + if (data[0] == NET_PACKET_ANNOUNCE_RESPONSE_OLD) { + return handle_announce_response_old(object, &ip_port, data, length, userdata); + } + if (data[0] == NET_PACKET_ONION_DATA_RESPONSE) { return handle_data_response(object, &ip_port, data, length, userdata); } @@ -1118,8 +1286,8 @@ int send_onion_data(Onion_Client *onion_c, int friend_num, const uint8_t *data, uint8_t o_packet[ONION_MAX_PACKET_SIZE]; len = create_data_request( - onion_c->rng, o_packet, sizeof(o_packet), onion_c->friends_list[friend_num].real_public_key, - node_list[good_nodes[i]].data_public_key, nonce, packet, SIZEOF_VLA(packet)); + onion_c->rng, o_packet, sizeof(o_packet), onion_c->friends_list[friend_num].real_public_key, + node_list[good_nodes[i]].data_public_key, nonce, packet, SIZEOF_VLA(packet)); if (len == -1) { continue; @@ -1167,8 +1335,8 @@ static int send_dht_dhtpk(const Onion_Client *onion_c, int friend_num, const uin uint8_t packet_data[MAX_CRYPTO_REQUEST_SIZE]; len = create_request( - onion_c->rng, dht_get_self_public_key(onion_c->dht), dht_get_self_secret_key(onion_c->dht), packet_data, - onion_c->friends_list[friend_num].dht_public_key, temp, SIZEOF_VLA(temp), CRYPTO_PACKET_DHTPK); + onion_c->rng, dht_get_self_public_key(onion_c->dht), dht_get_self_secret_key(onion_c->dht), packet_data, + onion_c->friends_list[friend_num].dht_public_key, temp, SIZEOF_VLA(temp), CRYPTO_PACKET_DHTPK); assert(len <= UINT16_MAX); const Packet packet = {packet_data, (uint16_t)len}; @@ -1237,7 +1405,8 @@ static int send_dhtpk_announce(Onion_Client *onion_c, uint16_t friend_num, uint8 int nodes_len = 0; if (num_nodes != 0) { - nodes_len = pack_nodes(onion_c->logger, data + DHTPK_DATA_MIN_LENGTH, DHTPK_DATA_MAX_LENGTH - DHTPK_DATA_MIN_LENGTH, nodes, num_nodes); + nodes_len = pack_nodes(onion_c->logger, data + DHTPK_DATA_MIN_LENGTH, DHTPK_DATA_MAX_LENGTH - DHTPK_DATA_MIN_LENGTH, + nodes, num_nodes); if (nodes_len <= 0) { return -1; @@ -1344,7 +1513,8 @@ int onion_addfriend(Onion_Client *onion_c, const uint8_t *public_key) onion_c->friends_list[index].is_valid = true; memcpy(onion_c->friends_list[index].real_public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE); - crypto_new_keypair(onion_c->rng, onion_c->friends_list[index].temp_public_key, onion_c->friends_list[index].temp_secret_key); + crypto_new_keypair(onion_c->rng, onion_c->friends_list[index].temp_public_key, + onion_c->friends_list[index].temp_secret_key); return index; } @@ -1674,6 +1844,12 @@ void oniondata_registerhandler(Onion_Client *onion_c, uint8_t byte, oniondata_ha onion_c->onion_data_handlers[byte].object = object; } +void onion_group_announce_register(Onion_Client *onion_c, onion_group_announce_cb *func, void *user_data) +{ + onion_c->group_announce_response = func; + onion_c->group_announce_response_user_data = user_data; +} + #define ANNOUNCE_INTERVAL_NOT_ANNOUNCED 3 #define ANNOUNCE_INTERVAL_ANNOUNCED ONION_NODE_PING_INTERVAL @@ -1925,7 +2101,8 @@ Onion_Client *new_onion_client(const Logger *logger, const Random *rng, const Mo onion_c->c = c; new_symmetric_key(rng, onion_c->secret_symmetric_key); crypto_new_keypair(rng, onion_c->temp_public_key, onion_c->temp_secret_key); - networking_registerhandler(onion_c->net, NET_PACKET_ANNOUNCE_RESPONSE_OLD, &handle_announce_response, onion_c); + networking_registerhandler(onion_c->net, NET_PACKET_ANNOUNCE_RESPONSE, &handle_announce_response, onion_c); + networking_registerhandler(onion_c->net, NET_PACKET_ANNOUNCE_RESPONSE_OLD, &handle_announce_response_old, onion_c); networking_registerhandler(onion_c->net, NET_PACKET_ONION_DATA_RESPONSE, &handle_data_response, onion_c); oniondata_registerhandler(onion_c, ONION_DATA_DHTPK, &handle_dhtpk_announce, onion_c); cryptopacket_registerhandler(onion_c->dht, CRYPTO_PACKET_DHTPK, &handle_dht_dhtpk, onion_c); @@ -1942,6 +2119,7 @@ void kill_onion_client(Onion_Client *onion_c) ping_array_kill(onion_c->announce_ping_array); realloc_onion_friends(onion_c, 0); + networking_registerhandler(onion_c->net, NET_PACKET_ANNOUNCE_RESPONSE, nullptr, nullptr); networking_registerhandler(onion_c->net, NET_PACKET_ANNOUNCE_RESPONSE_OLD, nullptr, nullptr); networking_registerhandler(onion_c->net, NET_PACKET_ONION_DATA_RESPONSE, nullptr, nullptr); oniondata_registerhandler(onion_c, ONION_DATA_DHTPK, nullptr, nullptr); diff --git a/protocols/Tox/libtox/src/toxcore/onion_client.h b/protocols/Tox/libtox/src/toxcore/onion_client.h index 2a30005c69..23a48ef5e6 100644 --- a/protocols/Tox/libtox/src/toxcore/onion_client.h +++ b/protocols/Tox/libtox/src/toxcore/onion_client.h @@ -43,6 +43,8 @@ #define MAX_PATH_NODES 32 +#define GCA_MAX_DATA_LENGTH GCA_PUBLIC_ANNOUNCE_MAX_SIZE + /** * If no announce response packets are received within this interval tox will * be considered offline. We give time for a node to be pinged often enough @@ -195,6 +197,13 @@ typedef int oniondata_handler_cb(void *object, const uint8_t *source_pubkey, con non_null(1) nullable(3, 4) void oniondata_registerhandler(Onion_Client *onion_c, uint8_t byte, oniondata_handler_cb *cb, void *object); +typedef bool onion_group_announce_cb(Onion_Client *onion_c, uint32_t sendback_num, const uint8_t *data, + size_t data_length, void *user_data); + +/** Function to call when the onion gets a group announce response. */ +non_null(1) nullable(2, 3) +void onion_group_announce_register(Onion_Client *onion_c, onion_group_announce_cb *func, void *user_data); + non_null() void do_onion_client(Onion_Client *onion_c); @@ -217,4 +226,15 @@ typedef enum Onion_Connection_Status { non_null() Onion_Connection_Status onion_connection_status(const Onion_Client *onion_c); +typedef struct Onion_Friend Onion_Friend; + +non_null() uint16_t onion_get_friend_count(const Onion_Client *const onion_c); +non_null() Onion_Friend *onion_get_friend(const Onion_Client *const onion_c, uint16_t friend_num); +non_null() const uint8_t *onion_friend_get_gc_public_key(const Onion_Friend *const onion_friend); +non_null() const uint8_t *onion_friend_get_gc_public_key_num(const Onion_Client *const onion_c, uint32_t num); +non_null() void onion_friend_set_gc_public_key(Onion_Friend *const onion_friend, const uint8_t *public_key); +non_null(1) nullable(2) +void onion_friend_set_gc_data(Onion_Friend *const onion_friend, const uint8_t *gc_data, uint16_t gc_data_length); +non_null() bool onion_friend_is_groupchat(const Onion_Friend *const onion_friend); + #endif diff --git a/protocols/Tox/libtox/src/toxcore/ping.c b/protocols/Tox/libtox/src/toxcore/ping.c index 91a780b123..f44777b8ee 100644 --- a/protocols/Tox/libtox/src/toxcore/ping.c +++ b/protocols/Tox/libtox/src/toxcore/ping.c @@ -53,10 +53,9 @@ void ping_send_request(Ping *ping, const IP_Port *ipp, const uint8_t *public_key return; } - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; // generate key to encrypt ping_id with recipient privkey - dht_get_shared_key_sent(ping->dht, shared_key, public_key); + const uint8_t *shared_key = dht_get_shared_key_sent(ping->dht, public_key); // Generate random ping_id. uint8_t data[PING_DATA_SIZE]; pk_copy(data, public_key); @@ -64,7 +63,6 @@ void ping_send_request(Ping *ping, const IP_Port *ipp, const uint8_t *public_key ping_id = ping_array_add(ping->ping_array, ping->mono_time, ping->rng, data, sizeof(data)); if (ping_id == 0) { - crypto_memzero(shared_key, sizeof(shared_key)); return; } @@ -82,8 +80,6 @@ void ping_send_request(Ping *ping, const IP_Port *ipp, const uint8_t *public_key ping_plain, sizeof(ping_plain), pk + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE); - crypto_memzero(shared_key, sizeof(shared_key)); - if (rc != PING_PLAIN_SIZE + CRYPTO_MAC_SIZE) { return; } @@ -139,11 +135,11 @@ static int handle_ping_request(void *object, const IP_Port *source, const uint8_ return 1; } - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; + const uint8_t *shared_key = dht_get_shared_key_recv(dht, packet + 1); + uint8_t ping_plain[PING_PLAIN_SIZE]; // Decrypt ping_id - dht_get_shared_key_recv(dht, shared_key, packet + 1); const int rc = decrypt_data_symmetric(shared_key, packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE, @@ -151,12 +147,10 @@ static int handle_ping_request(void *object, const IP_Port *source, const uint8_ ping_plain); if (rc != sizeof(ping_plain)) { - crypto_memzero(shared_key, sizeof(shared_key)); return 1; } if (ping_plain[0] != NET_PACKET_PING_REQUEST) { - crypto_memzero(shared_key, sizeof(shared_key)); return 1; } @@ -166,8 +160,6 @@ static int handle_ping_request(void *object, const IP_Port *source, const uint8_ ping_send_response(ping, source, packet + 1, ping_id, shared_key); ping_add(ping, packet + 1, source); - crypto_memzero(shared_key, sizeof(shared_key)); - return 0; } @@ -188,10 +180,8 @@ static int handle_ping_response(void *object, const IP_Port *source, const uint8 return 1; } - uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; - // generate key to encrypt ping_id with recipient privkey - dht_get_shared_key_sent(ping->dht, shared_key, packet + 1); + const uint8_t *shared_key = dht_get_shared_key_sent(ping->dht, packet + 1); uint8_t ping_plain[PING_PLAIN_SIZE]; // Decrypt ping_id @@ -201,8 +191,6 @@ static int handle_ping_response(void *object, const IP_Port *source, const uint8 PING_PLAIN_SIZE + CRYPTO_MAC_SIZE, ping_plain); - crypto_memzero(shared_key, sizeof(shared_key)); - if (rc != sizeof(ping_plain)) { return 1; } diff --git a/protocols/Tox/libtox/src/toxcore/shared_key_cache.c b/protocols/Tox/libtox/src/toxcore/shared_key_cache.c new file mode 100644 index 0000000000..7846ae4f69 --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/shared_key_cache.c @@ -0,0 +1,161 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Copyright © 2022 The TokTok team. + */ + +#include "shared_key_cache.h" + +#include <assert.h> +#include <stdint.h> +#include <stdlib.h> // calloc(...) +#include <string.h> // memcpy(...) + +#include "ccompat.h" +#include "crypto_core.h" +#include "mono_time.h" + +typedef struct Shared_Key { + uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]; + uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; + uint64_t time_last_requested; +} Shared_Key; + +struct Shared_Key_Cache { + Shared_Key *keys; + const uint8_t* self_secret_key; + uint64_t timeout; /** After this time (in seconds), a key is erased on the next housekeeping cycle */ + const Mono_Time *time; + uint8_t keys_per_slot; +}; + +non_null() +static bool shared_key_is_empty(const Shared_Key *k) { + assert(k != nullptr); + /* + * Since time can never be 0, we use that to determine if a key slot is empty. + * Additionally this allows us to use crypto_memzero and leave the slot in a valid state. + */ + return k->time_last_requested == 0; +} + +non_null() +static void shared_key_set_empty(Shared_Key *k) { + crypto_memzero(k, sizeof (Shared_Key)); + assert(shared_key_is_empty(k)); +} + +Shared_Key_Cache *shared_key_cache_new(const Mono_Time *time, const uint8_t *self_secret_key, uint64_t timeout, uint8_t keys_per_slot) +{ + if (time == nullptr || self_secret_key == nullptr || timeout == 0 || keys_per_slot == 0) { + return nullptr; + } + + // Time must not be zero, since we use that as special value for empty slots + if (mono_time_get(time) == 0) { + // Fail loudly in debug environments + assert(false); + return nullptr; + } + + Shared_Key_Cache *res = (Shared_Key_Cache *)calloc(1, sizeof (Shared_Key_Cache)); + if (res == nullptr) { + return nullptr; + } + + res->self_secret_key = self_secret_key; + res->time = time; + res->keys_per_slot = keys_per_slot; + // We take one byte from the public key for each bucket and store keys_per_slot elements there + const size_t cache_size = 256 * keys_per_slot; + res->keys = (Shared_Key *)calloc(cache_size, sizeof (Shared_Key)); + + if (res->keys == nullptr) { + free(res); + return nullptr; + } + + crypto_memlock(res->keys, cache_size * sizeof (Shared_Key)); + + return res; +} + +void shared_key_cache_free(Shared_Key_Cache *cache) +{ + if (cache == nullptr) { + return; + } + + const size_t cache_size = 256 * cache->keys_per_slot; + // Don't leave key material in memory + crypto_memzero(cache->keys, cache_size * sizeof (Shared_Key)); + crypto_memunlock(cache->keys, cache_size * sizeof (Shared_Key)); + free(cache->keys); + free(cache); +} + +/* NOTE: On each lookup housekeeping is performed to evict keys that did timeout. */ +const uint8_t *shared_key_cache_lookup(Shared_Key_Cache *cache, const uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]) +{ + // caching the time is not necessary, but calls to mono_time_get(...) are not free + const uint64_t cur_time = mono_time_get(cache->time); + // We can't use the first and last bytes because they are masked in curve25519. Selected 8 for good alignment. + const uint8_t bucket_idx = public_key[8]; + Shared_Key* bucket_start = &cache->keys[bucket_idx*cache->keys_per_slot]; + + const uint8_t* found = nullptr; + + // Perform lookup + for(size_t i = 0; i < cache->keys_per_slot; ++i) { + if (shared_key_is_empty(&bucket_start[i])) { + continue; + } + + if (pk_equal(public_key, bucket_start[i].public_key)) { + found = bucket_start[i].shared_key; + bucket_start[i].time_last_requested = cur_time; + break; + } + } + + // Perform housekeeping for this bucket + for (size_t i = 0; i < cache->keys_per_slot; ++i) { + if (shared_key_is_empty(&bucket_start[i])) { + continue; + } + + const bool timed_out = (bucket_start[i].time_last_requested + cache->timeout) < cur_time; + if (timed_out) { + shared_key_set_empty(&bucket_start[i]); + } + } + + if (found == nullptr) { + // Insert into cache + + uint64_t oldest_timestamp = UINT64_MAX; + size_t oldest_index = 0; + + /* + * Find least recently used entry, unused entries are prioritised, + * because their time_last_requested field is zeroed. + */ + for (size_t i = 0; i < cache->keys_per_slot; ++i) { + if (bucket_start[i].time_last_requested < oldest_timestamp) { + oldest_timestamp = bucket_start[i].time_last_requested; + oldest_index = i; + } + } + + // Compute the shared key for the cache + if (encrypt_precompute(public_key, cache->self_secret_key, bucket_start[oldest_index].shared_key) != 0) { + // Don't put anything in the cache on error + return nullptr; + } + + // update cache entry + memcpy(bucket_start[oldest_index].public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE); + bucket_start[oldest_index].time_last_requested = cur_time; + found = bucket_start[oldest_index].shared_key; + } + + return found; +} diff --git a/protocols/Tox/libtox/src/toxcore/shared_key_cache.h b/protocols/Tox/libtox/src/toxcore/shared_key_cache.h new file mode 100644 index 0000000000..97d8b7a4a8 --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/shared_key_cache.h @@ -0,0 +1,51 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Copyright © 2022 The TokTok team. + */ + +#ifndef C_TOXCORE_TOXCORE_SHARED_KEY_CACHE_H +#define C_TOXCORE_TOXCORE_SHARED_KEY_CACHE_H + +#include <stdint.h> // uint*_t + +#include "crypto_core.h" +#include "mono_time.h" + +/** + * This implements a cache for shared keys, since key generation is expensive. + */ + +typedef struct Shared_Key_Cache Shared_Key_Cache; + +/** + * @brief Initializes a new shared key cache. + * @param time Time object for retrieving current time. + * @param self_secret_key Our own secret key of length CRYPTO_SECRET_KEY_SIZE, + * it must not change during the lifetime of the cache. + * @param timeout Number of milliseconds, after which a key should be evicted. + * @param keys_per_slot There are 256 slots, this controls how many keys are stored per slot and the size of the cache. + * @return nullptr on error. + */ +non_null() +Shared_Key_Cache *shared_key_cache_new(const Mono_Time *time, + const uint8_t *self_secret_key, + uint64_t timeout, uint8_t keys_per_slot); + +/** + * @brief Deletes the cache and frees all resources. + * @param cache Cache to delete or nullptr. + */ +nullable(1) +void shared_key_cache_free(Shared_Key_Cache *cache); + +/** + * @brief Looks up a key from the cache or computes it if it didn't exist yet. + * @param cache Cache to perform the lookup on. + * @param public_key Public key, used for the lookup and computation. + * + * @return The shared key of length CRYPTO_SHARED_KEY_SIZE, matching the public key and our secret key. + * @return nullptr on error. + */ +non_null() +const uint8_t* shared_key_cache_lookup(Shared_Key_Cache *cache, const uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]); + +#endif // C_TOXCORE_TOXCORE_SHARED_KEY_CACHE_H diff --git a/protocols/Tox/libtox/src/toxcore/state.h b/protocols/Tox/libtox/src/toxcore/state.h index 716286d6d1..0cc188d50d 100644 --- a/protocols/Tox/libtox/src/toxcore/state.h +++ b/protocols/Tox/libtox/src/toxcore/state.h @@ -34,6 +34,7 @@ typedef enum State_Type { STATE_TYPE_NAME = 4, STATE_TYPE_STATUSMESSAGE = 5, STATE_TYPE_STATUS = 6, + STATE_TYPE_GROUPS = 7, STATE_TYPE_TCP_RELAY = 10, STATE_TYPE_PATH_NODE = 11, STATE_TYPE_CONFERENCES = 20, diff --git a/protocols/Tox/libtox/src/toxcore/tox.c b/protocols/Tox/libtox/src/toxcore/tox.c index 079f404079..3f7dcc439d 100644 --- a/protocols/Tox/libtox/src/toxcore/tox.c +++ b/protocols/Tox/libtox/src/toxcore/tox.c @@ -19,6 +19,8 @@ #include "Messenger.h" #include "ccompat.h" #include "group.h" +#include "group_chats.h" +#include "group_moderation.h" #include "logger.h" #include "mono_time.h" #include "network.h" @@ -54,6 +56,10 @@ static_assert(TOX_MAX_NAME_LENGTH == MAX_NAME_LENGTH, "TOX_MAX_NAME_LENGTH is assumed to be equal to MAX_NAME_LENGTH"); static_assert(TOX_MAX_STATUS_MESSAGE_LENGTH == MAX_STATUSMESSAGE_LENGTH, "TOX_MAX_STATUS_MESSAGE_LENGTH is assumed to be equal to MAX_STATUSMESSAGE_LENGTH"); +static_assert(TOX_GROUP_MAX_MESSAGE_LENGTH == GROUP_MAX_MESSAGE_LENGTH, + "TOX_GROUP_MAX_MESSAGE_LENGTH is assumed to be equal to GROUP_MAX_MESSAGE_LENGTH"); +static_assert(TOX_MAX_CUSTOM_PACKET_SIZE == MAX_GC_CUSTOM_LOSSLESS_PACKET_SIZE, + "TOX_MAX_CUSTOM_PACKET_SIZE is assumed to be equal to MAX_GC_CUSTOM_LOSSLESS_PACKET_SIZE"); struct Tox_Userdata { Tox *tox; @@ -317,8 +323,8 @@ static void tox_dht_get_nodes_response_handler(const DHT *dht, const Node_format Ip_Ntoa ip_str; tox_data->tox->dht_get_nodes_response_callback( - tox_data->tox, node->public_key, net_ip_ntoa(&node->ip_port.ip, &ip_str), net_ntohs(node->ip_port.port), - tox_data->user_data); + tox_data->tox, node->public_key, net_ip_ntoa(&node->ip_port.ip, &ip_str), net_ntohs(node->ip_port.port), + tox_data->user_data); } static m_friend_lossy_packet_cb tox_friend_lossy_packet_handler; @@ -353,6 +359,218 @@ static void tox_friend_lossless_packet_handler(Messenger *m, uint32_t friend_num } } +#ifndef VANILLA_NACL +non_null(1, 4) nullable(6) +static void tox_group_peer_name_handler(const Messenger *m, uint32_t group_number, uint32_t peer_id, + const uint8_t *name, size_t length, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_peer_name_callback != nullptr) { + tox_data->tox->group_peer_name_callback(tox_data->tox, group_number, peer_id, name, length, tox_data->user_data); + } +} + +non_null(1) nullable(5) +static void tox_group_peer_status_handler(const Messenger *m, uint32_t group_number, uint32_t peer_id, + unsigned int status, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_peer_status_callback != nullptr) { + tox_data->tox->group_peer_status_callback(tox_data->tox, group_number, peer_id, (Tox_User_Status)status, + tox_data->user_data); + } +} + +non_null(1, 4) nullable(6) +static void tox_group_topic_handler(const Messenger *m, uint32_t group_number, uint32_t peer_id, const uint8_t *topic, + size_t length, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_topic_callback != nullptr) { + tox_data->tox->group_topic_callback(tox_data->tox, group_number, peer_id, topic, length, tox_data->user_data); + } +} + +non_null(1) nullable(4) +static void tox_group_topic_lock_handler(const Messenger *m, uint32_t group_number, unsigned int topic_lock, + void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_topic_lock_callback != nullptr) { + tox_data->tox->group_topic_lock_callback(tox_data->tox, group_number, (Tox_Group_Topic_Lock)topic_lock, + tox_data->user_data); + } +} + +non_null(1) nullable(4) +static void tox_group_voice_state_handler(const Messenger *m, uint32_t group_number, unsigned int voice_state, + void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_voice_state_callback != nullptr) { + tox_data->tox->group_voice_state_callback(tox_data->tox, group_number, (Tox_Group_Voice_State)voice_state, + tox_data->user_data); + } +} + +non_null(1) nullable(4) +static void tox_group_peer_limit_handler(const Messenger *m, uint32_t group_number, uint32_t peer_limit, + void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_peer_limit_callback != nullptr) { + tox_data->tox->group_peer_limit_callback(tox_data->tox, group_number, peer_limit, tox_data->user_data); + } +} + +non_null(1) nullable(4) +static void tox_group_privacy_state_handler(const Messenger *m, uint32_t group_number, unsigned int privacy_state, + void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_privacy_state_callback != nullptr) { + tox_data->tox->group_privacy_state_callback(tox_data->tox, group_number, (Tox_Group_Privacy_State)privacy_state, + tox_data->user_data); + } +} + +non_null(1) nullable(3, 5) +static void tox_group_password_handler(const Messenger *m, uint32_t group_number, const uint8_t *password, + size_t length, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_password_callback != nullptr) { + tox_data->tox->group_password_callback(tox_data->tox, group_number, password, length, tox_data->user_data); + } +} + +non_null(1, 5) nullable(8) +static void tox_group_message_handler(const Messenger *m, uint32_t group_number, uint32_t peer_id, unsigned int type, + const uint8_t *message, size_t length, uint32_t message_id, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_message_callback != nullptr) { + tox_data->tox->group_message_callback(tox_data->tox, group_number, peer_id, (Tox_Message_Type)type, message, length, + message_id, tox_data->user_data); + } +} + +non_null(1, 5) nullable(7) +static void tox_group_private_message_handler(const Messenger *m, uint32_t group_number, uint32_t peer_id, + unsigned int type, const uint8_t *message, size_t length, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_private_message_callback != nullptr) { + tox_data->tox->group_private_message_callback(tox_data->tox, group_number, peer_id, (Tox_Message_Type)type, message, + length, + tox_data->user_data); + } +} + +non_null(1, 4) nullable(6) +static void tox_group_custom_packet_handler(const Messenger *m, uint32_t group_number, uint32_t peer_id, + const uint8_t *data, size_t length, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_custom_packet_callback != nullptr) { + tox_data->tox->group_custom_packet_callback(tox_data->tox, group_number, peer_id, data, length, tox_data->user_data); + } +} + +non_null(1, 4) nullable(6) +static void tox_group_custom_private_packet_handler(const Messenger *m, uint32_t group_number, uint32_t peer_id, + const uint8_t *data, size_t length, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_custom_private_packet_callback != nullptr) { + tox_data->tox->group_custom_private_packet_callback(tox_data->tox, group_number, peer_id, data, length, + tox_data->user_data); + } +} + +non_null(1, 3, 5) nullable(7) +static void tox_group_invite_handler(const Messenger *m, uint32_t friend_number, const uint8_t *invite_data, + size_t length, const uint8_t *group_name, size_t group_name_length, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_invite_callback != nullptr) { + tox_data->tox->group_invite_callback(tox_data->tox, friend_number, invite_data, length, group_name, group_name_length, + tox_data->user_data); + } +} + +non_null(1) nullable(4) +static void tox_group_peer_join_handler(const Messenger *m, uint32_t group_number, uint32_t peer_id, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_peer_join_callback != nullptr) { + tox_data->tox->group_peer_join_callback(tox_data->tox, group_number, peer_id, tox_data->user_data); + } +} + +non_null(1, 5) nullable(7, 9) +static void tox_group_peer_exit_handler(const Messenger *m, uint32_t group_number, uint32_t peer_id, + unsigned int exit_type, const uint8_t *name, size_t name_length, + const uint8_t *part_message, size_t length, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_peer_exit_callback != nullptr) { + tox_data->tox->group_peer_exit_callback(tox_data->tox, group_number, peer_id, (Tox_Group_Exit_Type) exit_type, name, + name_length, + part_message, length, tox_data->user_data); + } +} + +non_null(1) nullable(3) +static void tox_group_self_join_handler(const Messenger *m, uint32_t group_number, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_self_join_callback != nullptr) { + tox_data->tox->group_self_join_callback(tox_data->tox, group_number, tox_data->user_data); + } +} + +non_null(1) nullable(4) +static void tox_group_join_fail_handler(const Messenger *m, uint32_t group_number, unsigned int fail_type, + void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_join_fail_callback != nullptr) { + tox_data->tox->group_join_fail_callback(tox_data->tox, group_number, (Tox_Group_Join_Fail)fail_type, + tox_data->user_data); + } +} + +non_null(1) nullable(6) +static void tox_group_moderation_handler(const Messenger *m, uint32_t group_number, uint32_t source_peer_number, + uint32_t target_peer_number, unsigned int mod_type, void *user_data) +{ + struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data; + + if (tox_data->tox->group_moderation_callback != nullptr) { + tox_data->tox->group_moderation_callback(tox_data->tox, group_number, source_peer_number, target_peer_number, + (Tox_Group_Mod_Event)mod_type, + tox_data->user_data); + } +} +#endif bool tox_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch) { @@ -522,6 +740,7 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error) const Tox_System *sys = tox_options_get_operating_system(opts); const Tox_System default_system = tox_default_system(); + if (sys == nullptr) { sys = &default_system; } @@ -553,7 +772,8 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error) const char *const proxy_host = tox_options_get_proxy_host(opts); - if (proxy_host == nullptr || !addr_resolve_or_parse_ip(&tox->ns, proxy_host, &m_options.proxy_info.ip_port.ip, nullptr)) { + if (proxy_host == nullptr + || !addr_resolve_or_parse_ip(&tox->ns, proxy_host, &m_options.proxy_info.ip_port.ip, nullptr)) { SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_HOST); // TODO(irungentoo): TOX_ERR_NEW_PROXY_NOT_FOUND if domain. tox_options_free(default_options); @@ -671,6 +891,27 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error) custom_lossy_packet_registerhandler(tox->m, tox_friend_lossy_packet_handler); custom_lossless_packet_registerhandler(tox->m, tox_friend_lossless_packet_handler); +#ifndef VANILLA_NACL + m_callback_group_invite(tox->m, tox_group_invite_handler); + gc_callback_message(tox->m, tox_group_message_handler); + gc_callback_private_message(tox->m, tox_group_private_message_handler); + gc_callback_custom_packet(tox->m, tox_group_custom_packet_handler); + gc_callback_custom_private_packet(tox->m, tox_group_custom_private_packet_handler); + gc_callback_moderation(tox->m, tox_group_moderation_handler); + gc_callback_nick_change(tox->m, tox_group_peer_name_handler); + gc_callback_status_change(tox->m, tox_group_peer_status_handler); + gc_callback_topic_change(tox->m, tox_group_topic_handler); + gc_callback_peer_limit(tox->m, tox_group_peer_limit_handler); + gc_callback_privacy_state(tox->m, tox_group_privacy_state_handler); + gc_callback_topic_lock(tox->m, tox_group_topic_lock_handler); + gc_callback_password(tox->m, tox_group_password_handler); + gc_callback_peer_join(tox->m, tox_group_peer_join_handler); + gc_callback_peer_exit(tox->m, tox_group_peer_exit_handler); + gc_callback_self_join(tox->m, tox_group_self_join_handler); + gc_callback_rejected(tox->m, tox_group_join_fail_handler); + gc_callback_voice_state(tox->m, tox_group_voice_state_handler); +#endif + tox_options_free(default_options); tox_unlock(tox); @@ -714,9 +955,9 @@ size_t tox_get_savedata_size(const Tox *tox) assert(tox != nullptr); tox_lock(tox); const size_t ret = 2 * sizeof(uint32_t) - + messenger_size(tox->m) - + conferences_size(tox->m->conferences_object) - + end_size(); + + messenger_size(tox->m) + + conferences_size(tox->m->conferences_object) + + end_size(); tox_unlock(tox); return ret; } @@ -749,7 +990,8 @@ void tox_get_savedata(const Tox *tox, uint8_t *savedata) } non_null(5) nullable(1, 2, 4, 6) -static int32_t resolve_bootstrap_node(Tox *tox, const char *host, uint16_t port, const uint8_t *public_key, IP_Port **root, Tox_Err_Bootstrap *error) +static int32_t resolve_bootstrap_node(Tox *tox, const char *host, uint16_t port, const uint8_t *public_key, + IP_Port **root, Tox_Err_Bootstrap *error) { assert(tox != nullptr); assert(root != nullptr); @@ -766,7 +1008,7 @@ static int32_t resolve_bootstrap_node(Tox *tox, const char *host, uint16_t port, const int32_t count = net_getipport(host, root, TOX_SOCK_DGRAM); - if (count == -1) { + if (count < 1) { LOGGER_DEBUG(tox->m->log, "could not resolve bootstrap node '%s'", host); net_freeipport(*root); SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST); @@ -879,6 +1121,7 @@ Tox_Connection tox_self_get_connection_status(const Tox *tox) } LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + return TOX_CONNECTION_NONE; } @@ -2580,3 +2823,1760 @@ uint16_t tox_self_get_tcp_port(const Tox *tox, Tox_Err_Get_Port *error) tox_unlock(tox); return 0; } + +/* GROUPCHAT FUNCTIONS */ + +#ifndef VANILLA_NACL +void tox_callback_group_invite(Tox *tox, tox_group_invite_cb *callback) +{ + assert(tox != nullptr); + tox->group_invite_callback = callback; +} + +void tox_callback_group_message(Tox *tox, tox_group_message_cb *callback) +{ + assert(tox != nullptr); + tox->group_message_callback = callback; +} + +void tox_callback_group_private_message(Tox *tox, tox_group_private_message_cb *callback) +{ + assert(tox != nullptr); + tox->group_private_message_callback = callback; +} + +void tox_callback_group_custom_packet(Tox *tox, tox_group_custom_packet_cb *callback) +{ + assert(tox != nullptr); + tox->group_custom_packet_callback = callback; +} + +void tox_callback_group_custom_private_packet(Tox *tox, tox_group_custom_private_packet_cb *callback) +{ + assert(tox != nullptr); + tox->group_custom_private_packet_callback = callback; +} + +void tox_callback_group_moderation(Tox *tox, tox_group_moderation_cb *callback) +{ + assert(tox != nullptr); + tox->group_moderation_callback = callback; +} + +void tox_callback_group_peer_name(Tox *tox, tox_group_peer_name_cb *callback) +{ + assert(tox != nullptr); + tox->group_peer_name_callback = callback; +} + +void tox_callback_group_peer_status(Tox *tox, tox_group_peer_status_cb *callback) +{ + assert(tox != nullptr); + tox->group_peer_status_callback = callback; +} + +void tox_callback_group_topic(Tox *tox, tox_group_topic_cb *callback) +{ + assert(tox != nullptr); + tox->group_topic_callback = callback; +} + +void tox_callback_group_privacy_state(Tox *tox, tox_group_privacy_state_cb *callback) +{ + assert(tox != nullptr); + tox->group_privacy_state_callback = callback; +} + +void tox_callback_group_topic_lock(Tox *tox, tox_group_topic_lock_cb *callback) +{ + assert(tox != nullptr); + tox->group_topic_lock_callback = callback; +} + +void tox_callback_group_voice_state(Tox *tox, tox_group_voice_state_cb *callback) +{ + assert(tox != nullptr); + tox->group_voice_state_callback = callback; +} + +void tox_callback_group_peer_limit(Tox *tox, tox_group_peer_limit_cb *callback) +{ + assert(tox != nullptr); + tox->group_peer_limit_callback = callback; +} + +void tox_callback_group_password(Tox *tox, tox_group_password_cb *callback) +{ + assert(tox != nullptr); + tox->group_password_callback = callback; +} + +void tox_callback_group_peer_join(Tox *tox, tox_group_peer_join_cb *callback) +{ + assert(tox != nullptr); + tox->group_peer_join_callback = callback; +} + +void tox_callback_group_peer_exit(Tox *tox, tox_group_peer_exit_cb *callback) +{ + assert(tox != nullptr); + tox->group_peer_exit_callback = callback; +} + +void tox_callback_group_self_join(Tox *tox, tox_group_self_join_cb *callback) +{ + assert(tox != nullptr); + tox->group_self_join_callback = callback; +} + +void tox_callback_group_join_fail(Tox *tox, tox_group_join_fail_cb *callback) +{ + assert(tox != nullptr); + tox->group_join_fail_callback = callback; +} + +uint32_t tox_group_new(Tox *tox, Tox_Group_Privacy_State privacy_state, const uint8_t *group_name, + size_t group_name_length, const uint8_t *name, size_t name_length, Tox_Err_Group_New *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const int ret = gc_group_add(tox->m->group_handler, (Group_Privacy_State) privacy_state, + group_name, group_name_length, name, name_length); + tox_unlock(tox); + + if (ret >= 0) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_NEW_OK); + return ret; + } + + switch (ret) { + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_NEW_TOO_LONG); + return UINT32_MAX; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_NEW_EMPTY); + return UINT32_MAX; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_NEW_INIT); + return UINT32_MAX; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_NEW_STATE); + return UINT32_MAX; + } + + case -5: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_NEW_ANNOUNCE); + return UINT32_MAX; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return UINT32_MAX; +} + +uint32_t tox_group_join(Tox *tox, const uint8_t *chat_id, const uint8_t *name, size_t name_length, + const uint8_t *password, size_t password_length, Tox_Err_Group_Join *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const int ret = gc_group_join(tox->m->group_handler, chat_id, name, name_length, password, password_length); + tox_unlock(tox); + + if (ret >= 0) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_JOIN_OK); + return ret; + } + + switch (ret) { + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_JOIN_INIT); + return UINT32_MAX; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_JOIN_BAD_CHAT_ID); + return UINT32_MAX; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_JOIN_TOO_LONG); + return UINT32_MAX; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_JOIN_EMPTY); + return UINT32_MAX; + } + + case -5: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_JOIN_PASSWORD); + return UINT32_MAX; + } + + case -6: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_JOIN_CORE); + return UINT32_MAX; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return UINT32_MAX; +} + +bool tox_group_is_connected(const Tox *tox, uint32_t group_number, Tox_Err_Group_Is_Connected *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_IS_CONNECTED_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_IS_CONNECTED_OK); + + const bool ret = chat->connection_state == CS_CONNECTED || chat->connection_state == CS_CONNECTING; + tox_unlock(tox); + + return ret; +} + +bool tox_group_disconnect(const Tox *tox, uint32_t group_number, Tox_Err_Group_Disconnect *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_DISCONNECT_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + if (chat->connection_state == CS_DISCONNECTED) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_DISCONNECT_ALREADY_DISCONNECTED); + tox_unlock(tox); + return false; + } + + + const bool ret = gc_disconnect_from_group(tox->m->group_handler, chat); + + tox_unlock(tox); + + if (!ret) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_DISCONNECT_GROUP_NOT_FOUND); + return false; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_DISCONNECT_OK); + + return true; +} + +bool tox_group_reconnect(Tox *tox, uint32_t group_number, Tox_Err_Group_Reconnect *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_RECONNECT_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + const int ret = gc_rejoin_group(tox->m->group_handler, chat); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_RECONNECT_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_RECONNECT_GROUP_NOT_FOUND); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_RECONNECT_CORE); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_leave(Tox *tox, uint32_t group_number, const uint8_t *part_message, size_t length, + Tox_Err_Group_Leave *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_LEAVE_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + const int ret = gc_group_exit(tox->m->group_handler, chat, part_message, length); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_LEAVE_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_LEAVE_TOO_LONG); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_LEAVE_FAIL_SEND); + return true; /* the group was still successfully deleted */ + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_self_set_name(const Tox *tox, uint32_t group_number, const uint8_t *name, size_t length, + Tox_Err_Group_Self_Name_Set *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const int ret = gc_set_self_nick(tox->m, group_number, name, length); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_NAME_SET_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_NAME_SET_GROUP_NOT_FOUND); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_NAME_SET_TOO_LONG); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_NAME_SET_INVALID); + return false; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_NAME_SET_FAIL_SEND); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +size_t tox_group_self_get_name_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_Self_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return -1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_OK); + + const size_t ret = gc_get_self_nick_size(chat); + tox_unlock(tox); + + return ret; +} + +bool tox_group_self_get_name(const Tox *tox, uint32_t group_number, uint8_t *name, Tox_Err_Group_Self_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_OK); + + gc_get_self_nick(chat, name); + tox_unlock(tox); + + return true; +} + +bool tox_group_self_set_status(const Tox *tox, uint32_t group_number, Tox_User_Status status, + Tox_Err_Group_Self_Status_Set *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const int ret = gc_set_self_status(tox->m, group_number, (Group_Peer_Status) status); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_STATUS_SET_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_STATUS_SET_GROUP_NOT_FOUND); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_STATUS_SET_FAIL_SEND); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +Tox_User_Status tox_group_self_get_status(const Tox *tox, uint32_t group_number, Tox_Err_Group_Self_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return (Tox_User_Status) - 1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_OK); + + const uint8_t status = gc_get_self_status(chat); + tox_unlock(tox); + + return (Tox_User_Status)status; +} + +Tox_Group_Role tox_group_self_get_role(const Tox *tox, uint32_t group_number, Tox_Err_Group_Self_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return (Tox_Group_Role) - 1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_OK); + + const Group_Role role = gc_get_self_role(chat); + tox_unlock(tox); + + return (Tox_Group_Role)role; +} + +uint32_t tox_group_self_get_peer_id(const Tox *tox, uint32_t group_number, Tox_Err_Group_Self_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return -1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_OK); + + const uint32_t ret = gc_get_self_peer_id(chat); + tox_unlock(tox); + + return ret; +} + +bool tox_group_self_get_public_key(const Tox *tox, uint32_t group_number, uint8_t *public_key, + Tox_Err_Group_Self_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SELF_QUERY_OK); + + gc_get_self_public_key(chat, public_key); + tox_unlock(tox); + + return true; +} + +size_t tox_group_peer_get_name_size(const Tox *tox, uint32_t group_number, uint32_t peer_id, + Tox_Err_Group_Peer_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return -1; + } + + const int ret = gc_get_peer_nick_size(chat, peer_id); + tox_unlock(tox); + + if (ret == -1) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_PEER_NOT_FOUND); + return -1; + } else { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_OK); + return ret; + } +} + +bool tox_group_peer_get_name(const Tox *tox, uint32_t group_number, uint32_t peer_id, uint8_t *name, + Tox_Err_Group_Peer_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + const bool ret = gc_get_peer_nick(chat, peer_id, name); + tox_unlock(tox); + + if (!ret) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_PEER_NOT_FOUND); + return false; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_OK); + return true; +} + +Tox_User_Status tox_group_peer_get_status(const Tox *tox, uint32_t group_number, uint32_t peer_id, + Tox_Err_Group_Peer_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return (Tox_User_Status) - 1; + } + + const uint8_t ret = gc_get_status(chat, peer_id); + tox_unlock(tox); + + if (ret == UINT8_MAX) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_PEER_NOT_FOUND); + return (Tox_User_Status) - 1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_OK); + return (Tox_User_Status)ret; +} + +Tox_Group_Role tox_group_peer_get_role(const Tox *tox, uint32_t group_number, uint32_t peer_id, + Tox_Err_Group_Peer_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return (Tox_Group_Role) - 1; + } + + const uint8_t ret = gc_get_role(chat, peer_id); + tox_unlock(tox); + + if (ret == (uint8_t) -1) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_PEER_NOT_FOUND); + return (Tox_Group_Role) - 1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_OK); + return (Tox_Group_Role)ret; +} + +bool tox_group_peer_get_public_key(const Tox *tox, uint32_t group_number, uint32_t peer_id, uint8_t *public_key, + Tox_Err_Group_Peer_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + const int ret = gc_get_peer_public_key_by_peer_id(chat, peer_id, public_key); + tox_unlock(tox); + + if (ret == -1) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_PEER_NOT_FOUND); + return false; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_OK); + return true; +} + +Tox_Connection tox_group_peer_get_connection_status(const Tox *tox, uint32_t group_number, uint32_t peer_id, + Tox_Err_Group_Peer_Query *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_GROUP_NOT_FOUND); + tox_unlock(tox); + return TOX_CONNECTION_NONE; + } + + const unsigned int ret = gc_get_peer_connection_status(chat, peer_id); + tox_unlock(tox); + + if (ret == 0) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_PEER_NOT_FOUND); + return TOX_CONNECTION_NONE; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_OK); + return (Tox_Connection)ret; +} + +bool tox_group_set_topic(const Tox *tox, uint32_t group_number, const uint8_t *topic, size_t length, + Tox_Err_Group_Topic_Set *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_TOPIC_SET_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + if (chat->connection_state == CS_DISCONNECTED) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_TOPIC_SET_DISCONNECTED); + tox_unlock(tox); + return false; + } + + const int ret = gc_set_topic(chat, topic, length); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_TOPIC_SET_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_TOPIC_SET_TOO_LONG); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_TOPIC_SET_PERMISSIONS); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_TOPIC_SET_FAIL_CREATE); + return false; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_TOPIC_SET_FAIL_SEND); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +size_t tox_group_get_topic_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND); + tox_unlock(tox); + return -1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK); + + const size_t ret = gc_get_topic_size(chat); + tox_unlock(tox); + + return ret; +} + +bool tox_group_get_topic(const Tox *tox, uint32_t group_number, uint8_t *topic, Tox_Err_Group_State_Queries *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + gc_get_topic(chat, topic); + tox_unlock(tox); + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK); + return true; +} + +size_t tox_group_get_name_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND); + tox_unlock(tox); + return -1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK); + + const size_t ret = gc_get_group_name_size(chat); + tox_unlock(tox); + + return ret; +} + +bool tox_group_get_name(const Tox *tox, uint32_t group_number, uint8_t *group_name, Tox_Err_Group_State_Queries *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + gc_get_group_name(chat, group_name); + tox_unlock(tox); + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK); + + return true; +} + +bool tox_group_get_chat_id(const Tox *tox, uint32_t group_number, uint8_t *chat_id, Tox_Err_Group_State_Queries *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK); + gc_get_chat_id(chat, chat_id); + tox_unlock(tox); + + return true; +} + +uint32_t tox_group_get_number_groups(const Tox *tox) +{ + assert(tox != nullptr); + + tox_lock(tox); + const uint32_t ret = gc_count_groups(tox->m->group_handler); + tox_unlock(tox); + + return ret; +} + +Tox_Group_Privacy_State tox_group_get_privacy_state(const Tox *tox, uint32_t group_number, + Tox_Err_Group_State_Queries *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND); + tox_unlock(tox); + return (Tox_Group_Privacy_State) - 1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK); + + const uint8_t state = gc_get_privacy_state(chat); + tox_unlock(tox); + + return (Tox_Group_Privacy_State)state; +} + +Tox_Group_Topic_Lock tox_group_get_topic_lock(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND); + tox_unlock(tox); + return (Tox_Group_Topic_Lock) - 1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK); + + const Group_Topic_Lock topic_lock = gc_get_topic_lock_state(chat); + tox_unlock(tox); + + return (Tox_Group_Topic_Lock)topic_lock; +} + +Tox_Group_Voice_State tox_group_get_voice_state(const Tox *tox, uint32_t group_number, + Tox_Err_Group_State_Queries *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND); + tox_unlock(tox); + return (Tox_Group_Voice_State) - 1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK); + + const Group_Voice_State voice_state = gc_get_voice_state(chat); + tox_unlock(tox); + + return (Tox_Group_Voice_State)voice_state; +} + +uint16_t tox_group_get_peer_limit(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND); + tox_unlock(tox); + return -1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK); + + const uint16_t ret = gc_get_max_peers(chat); + tox_unlock(tox); + + return ret; +} + +size_t tox_group_get_password_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND); + tox_unlock(tox); + return -1; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK); + + const size_t ret = gc_get_password_size(chat); + tox_unlock(tox); + + return ret; +} + +bool tox_group_get_password(const Tox *tox, uint32_t group_number, uint8_t *password, + Tox_Err_Group_State_Queries *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK); + + gc_get_password(chat, password); + tox_unlock(tox); + + return true; +} + +bool tox_group_send_message(const Tox *tox, uint32_t group_number, Tox_Message_Type type, const uint8_t *message, + size_t length, uint32_t *message_id, Tox_Err_Group_Send_Message *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_MESSAGE_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + if (chat->connection_state == CS_DISCONNECTED) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_MESSAGE_DISCONNECTED); + tox_unlock(tox); + return false; + } + + const int ret = gc_send_message(chat, message, length, type, message_id); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_MESSAGE_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_MESSAGE_TOO_LONG); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_MESSAGE_EMPTY); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_MESSAGE_BAD_TYPE); + return false; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_MESSAGE_PERMISSIONS); + return false; + } + + case -5: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_MESSAGE_FAIL_SEND); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_send_private_message(const Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, + const uint8_t *message, size_t length, Tox_Err_Group_Send_Private_Message *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + if (chat->connection_state == CS_DISCONNECTED) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_DISCONNECTED); + tox_unlock(tox); + return false; + } + + const int ret = gc_send_private_message(chat, peer_id, type, message, length); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_TOO_LONG); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_EMPTY); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PEER_NOT_FOUND); + return false; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_BAD_TYPE); + return false; + } + + case -5: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PERMISSIONS); + return false; + } + + case -6: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_FAIL_SEND); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_send_custom_packet(const Tox *tox, uint32_t group_number, bool lossless, const uint8_t *data, + size_t length, Tox_Err_Group_Send_Custom_Packet *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PACKET_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + if (chat->connection_state == CS_DISCONNECTED) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PACKET_DISCONNECTED); + tox_unlock(tox); + return false; + } + + const int ret = gc_send_custom_packet(chat, lossless, data, length); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PACKET_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PACKET_TOO_LONG); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PACKET_EMPTY); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PACKET_PERMISSIONS); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_send_custom_private_packet(const Tox *tox, uint32_t group_number, uint32_t peer_id, bool lossless, + const uint8_t *data, size_t length, + Tox_Err_Group_Send_Custom_Private_Packet *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + if (chat->connection_state == CS_DISCONNECTED) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_DISCONNECTED); + tox_unlock(tox); + return false; + } + + const int ret = gc_send_custom_private_packet(chat, lossless, peer_id, data, length); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_TOO_LONG); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_EMPTY); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_PEER_NOT_FOUND); + return false; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_PERMISSIONS); + return false; + } + + case -5: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_FAIL_SEND); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_invite_friend(const Tox *tox, uint32_t group_number, uint32_t friend_number, + Tox_Err_Group_Invite_Friend *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_FRIEND_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + if (chat->connection_state == CS_DISCONNECTED) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_FRIEND_DISCONNECTED); + tox_unlock(tox); + return false; + } + + if (!friend_is_valid(tox->m, friend_number)) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_FRIEND_FRIEND_NOT_FOUND); + tox_unlock(tox); + return false; + } + + const int ret = gc_invite_friend(tox->m->group_handler, chat, friend_number, send_group_invite_packet); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_FRIEND_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_FRIEND_FRIEND_NOT_FOUND); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_FRIEND_INVITE_FAIL); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_FRIEND_FAIL_SEND); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +uint32_t tox_group_invite_accept(Tox *tox, uint32_t friend_number, const uint8_t *invite_data, size_t length, + const uint8_t *name, size_t name_length, const uint8_t *password, + size_t password_length, Tox_Err_Group_Invite_Accept *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const int ret = gc_accept_invite(tox->m->group_handler, friend_number, invite_data, length, name, name_length, password, + password_length); + tox_unlock(tox); + + if (ret >= 0) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_ACCEPT_OK); + return ret; + } + + switch (ret) { + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_ACCEPT_BAD_INVITE); + return UINT32_MAX; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_ACCEPT_INIT_FAILED); + return UINT32_MAX; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_ACCEPT_TOO_LONG); + return UINT32_MAX; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_ACCEPT_EMPTY); + return UINT32_MAX; + } + + case -5: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_ACCEPT_PASSWORD); + return UINT32_MAX; + } + + case -6: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_ACCEPT_CORE); + return UINT32_MAX; + } + + case -7: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_INVITE_ACCEPT_FAIL_SEND); + return UINT32_MAX; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return UINT32_MAX; +} + +bool tox_group_founder_set_password(const Tox *tox, uint32_t group_number, const uint8_t *password, size_t length, + Tox_Err_Group_Founder_Set_Password *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + if (chat->connection_state == CS_DISCONNECTED) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_DISCONNECTED); + tox_unlock(tox); + return false; + } + + const int ret = gc_founder_set_password(chat, password, length); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_PERMISSIONS); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_TOO_LONG); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_FAIL_SEND); + return false; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_MALLOC); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_founder_set_privacy_state(const Tox *tox, uint32_t group_number, Tox_Group_Privacy_State privacy_state, + Tox_Err_Group_Founder_Set_Privacy_State *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const int ret = gc_founder_set_privacy_state(tox->m, group_number, (Group_Privacy_State) privacy_state); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_GROUP_NOT_FOUND); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_PERMISSIONS); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_DISCONNECTED); + return false; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_FAIL_SET); + return false; + } + + case -5: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_FAIL_SEND); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_founder_set_topic_lock(const Tox *tox, uint32_t group_number, Tox_Group_Topic_Lock topic_lock, + Tox_Err_Group_Founder_Set_Topic_Lock *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const int ret = gc_founder_set_topic_lock(tox->m, group_number, (Group_Topic_Lock) topic_lock); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_GROUP_NOT_FOUND); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_INVALID); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_PERMISSIONS); + return false; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_DISCONNECTED); + return false; + } + + case -5: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_FAIL_SET); + return false; + } + + case -6: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_FAIL_SEND); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_founder_set_voice_state(const Tox *tox, uint32_t group_number, Tox_Group_Voice_State voice_state, + Tox_Err_Group_Founder_Set_Voice_State *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const int ret = gc_founder_set_voice_state(tox->m, group_number, (Group_Voice_State)voice_state); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_GROUP_NOT_FOUND); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_PERMISSIONS); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_DISCONNECTED); + return false; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_FAIL_SET); + return false; + } + + case -5: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_FAIL_SEND); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_founder_set_peer_limit(const Tox *tox, uint32_t group_number, uint16_t max_peers, + Tox_Err_Group_Founder_Set_Peer_Limit *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + if (chat->connection_state == CS_DISCONNECTED) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_DISCONNECTED); + tox_unlock(tox); + return false; + } + + const int ret = gc_founder_set_max_peers(chat, max_peers); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_PERMISSIONS); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_FAIL_SET); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_FAIL_SEND); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_set_ignore(const Tox *tox, uint32_t group_number, uint32_t peer_id, bool ignore, + Tox_Err_Group_Set_Ignore *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number); + + if (chat == nullptr) { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SET_IGNORE_GROUP_NOT_FOUND); + tox_unlock(tox); + return false; + } + + const int ret = gc_set_ignore(chat, peer_id, ignore); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SET_IGNORE_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SET_IGNORE_PEER_NOT_FOUND); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SET_IGNORE_SELF); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_mod_set_role(const Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Group_Role role, + Tox_Err_Group_Mod_Set_Role *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const int ret = gc_set_peer_role(tox->m, group_number, peer_id, (Group_Role) role); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_SET_ROLE_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_SET_ROLE_GROUP_NOT_FOUND); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_SET_ROLE_PEER_NOT_FOUND); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_SET_ROLE_PERMISSIONS); + return false; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_SET_ROLE_ASSIGNMENT); + return false; + } + + case -5: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_SET_ROLE_FAIL_ACTION); + return false; + } + + case -6: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_SET_ROLE_SELF); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +bool tox_group_mod_kick_peer(const Tox *tox, uint32_t group_number, uint32_t peer_id, + Tox_Err_Group_Mod_Kick_Peer *error) +{ + assert(tox != nullptr); + + tox_lock(tox); + const int ret = gc_kick_peer(tox->m, group_number, peer_id); + tox_unlock(tox); + + switch (ret) { + case 0: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_KICK_PEER_OK); + return true; + } + + case -1: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_KICK_PEER_GROUP_NOT_FOUND); + return false; + } + + case -2: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_KICK_PEER_PEER_NOT_FOUND); + return false; + } + + case -3: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_KICK_PEER_PERMISSIONS); + return false; + } + + case -4: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_KICK_PEER_FAIL_ACTION); + return false; + } + + case -5: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_KICK_PEER_FAIL_SEND); + return false; + } + + case -6: { + SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_MOD_KICK_PEER_SELF); + return false; + } + } + + /* can't happen */ + LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret); + + return false; +} + +#endif /* VANILLA_NACL */ + diff --git a/protocols/Tox/libtox/src/toxcore/tox.h b/protocols/Tox/libtox/src/toxcore/tox.h index e8d55c6689..fd1901f69c 100644 --- a/protocols/Tox/libtox/src/toxcore/tox.h +++ b/protocols/Tox/libtox/src/toxcore/tox.h @@ -3267,6 +3267,2192 @@ uint16_t tox_self_get_tcp_port(const Tox *tox, Tox_Err_Get_Port *error); /** @} */ +/******************************************************************************* + * + * :: Group chats + * + ******************************************************************************/ + + + + +/******************************************************************************* + * + * :: Group chat numeric constants + * + ******************************************************************************/ + + + +/** @{ + * Maximum length of a group topic. + */ +#define TOX_GROUP_MAX_TOPIC_LENGTH 512 + +uint32_t tox_group_max_topic_length(void); + +/** + * Maximum length of a peer part message. + */ +#define TOX_GROUP_MAX_PART_LENGTH 128 + +uint32_t tox_group_max_part_length(void); + +/** + * Maximum length of a group text message. + */ +#define TOX_GROUP_MAX_MESSAGE_LENGTH 1372 + +uint32_t tox_group_max_message_length(void); + +/** + * Maximum length of a group custom lossy packet. + */ +#define TOX_GROUP_MAX_CUSTOM_LOSSY_PACKET_LENGTH 500 + +uint32_t tox_group_max_custom_lossy_packet_length(void); + +/** + * Maximum length of a group custom lossless packet. + */ +#define TOX_GROUP_MAX_CUSTOM_LOSSLESS_PACKET_LENGTH 1373 + +uint32_t tox_group_max_custom_lossless_packet_length(void); + +/** + * Maximum length of a group name. + */ +#define TOX_GROUP_MAX_GROUP_NAME_LENGTH 48 + +uint32_t tox_group_max_group_name_length(void); + +/** + * Maximum length of a group password. + */ +#define TOX_GROUP_MAX_PASSWORD_SIZE 32 + +uint32_t tox_group_max_password_size(void); + +/** + * Number of bytes in a group Chat ID. + */ +#define TOX_GROUP_CHAT_ID_SIZE 32 + +uint32_t tox_group_chat_id_size(void); + +/** + * Size of a peer public key. + */ +#define TOX_GROUP_PEER_PUBLIC_KEY_SIZE 32 + +uint32_t tox_group_peer_public_key_size(void); + + +/******************************************************************************* + * + * :: Group chat state enumerators + * + ******************************************************************************/ + + + +/** + * Represents the group privacy state. + */ +typedef enum Tox_Group_Privacy_State { + + /** + * The group is considered to be public. Anyone may join the group using the Chat ID. + * + * If the group is in this state, even if the Chat ID is never explicitly shared + * with someone outside of the group, information including the Chat ID, IP addresses, + * and peer ID's (but not Tox ID's) is visible to anyone with access to a node + * storing a DHT entry for the given group. + */ + TOX_GROUP_PRIVACY_STATE_PUBLIC, + + /** + * The group is considered to be private. The only way to join the group is by having + * someone in your contact list send you an invite. + * + * If the group is in this state, no group information (mentioned above) is present in the DHT; + * the DHT is not used for any purpose at all. If a public group is set to private, + * all DHT information related to the group will expire shortly. + */ + TOX_GROUP_PRIVACY_STATE_PRIVATE, + +} Tox_Group_Privacy_State; + + +/** + * Represents the state of the group topic lock. + */ +typedef enum Tox_Group_Topic_Lock { + + /** + * The topic lock is enabled. Only peers with the founder and moderator roles may set the topic. + */ + TOX_GROUP_TOPIC_LOCK_ENABLED, + + /** + * The topic lock is disabled. All peers except those with the observer role may set the topic. + */ + TOX_GROUP_TOPIC_LOCK_DISABLED, + +} Tox_Group_Topic_Lock; + +/** + * Represents the group voice state, which determines which Group Roles have permission to speak + * in the group chat. The voice state does not have any effect private messages or topic setting. + */ +typedef enum Tox_Group_Voice_State { + /** + * All group roles above Observer have permission to speak. + */ + TOX_GROUP_VOICE_STATE_ALL, + + /** + * Moderators and Founders have permission to speak. + */ + TOX_GROUP_VOICE_STATE_MODERATOR, + + /** + * Only the founder may speak. + */ + TOX_GROUP_VOICE_STATE_FOUNDER, +} Tox_Group_Voice_State; + +/** + * Represents group roles. + * + * Roles are hierarchical in that each role has a set of privileges plus all the privileges + * of the roles below it. + */ +typedef enum Tox_Group_Role { + + /** + * May kick all other peers as well as set their role to anything (except founder). + * Founders may also set the group password, toggle the privacy state, and set the peer limit. + */ + TOX_GROUP_ROLE_FOUNDER, + + /** + * May kick and set the user and observer roles for peers below this role. + * May also set the group topic. + */ + TOX_GROUP_ROLE_MODERATOR, + + /** + * May communicate with other peers normally. + */ + TOX_GROUP_ROLE_USER, + + /** + * May observe the group and ignore peers; may not communicate with other peers or with the group. + */ + TOX_GROUP_ROLE_OBSERVER, + +} Tox_Group_Role; + + + +/******************************************************************************* + * + * :: Group chat instance management + * + ******************************************************************************/ + + + +typedef enum Tox_Err_Group_New { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_NEW_OK, + + /** + * name exceeds TOX_MAX_NAME_LENGTH or group_name exceeded TOX_GROUP_MAX_GROUP_NAME_LENGTH. + */ + TOX_ERR_GROUP_NEW_TOO_LONG, + + /** + * name or group_name is NULL or length is zero. + */ + TOX_ERR_GROUP_NEW_EMPTY, + + /** + * The group instance failed to initialize. + */ + TOX_ERR_GROUP_NEW_INIT, + + /** + * The group state failed to initialize. This usually indicates that something went wrong + * related to cryptographic signing. + */ + TOX_ERR_GROUP_NEW_STATE, + + /** + * The group failed to announce to the DHT. This indicates a network related error. + */ + TOX_ERR_GROUP_NEW_ANNOUNCE, + +} Tox_Err_Group_New; + + +/** + * Creates a new group chat. + * + * This function creates a new group chat object and adds it to the chats array. + * + * The caller of this function has Founder role privileges. + * + * The client should initiate its peer list with self info after calling this function, as + * the peer_join callback will not be triggered. + * + * @param privacy_state The privacy state of the group. If this is set to TOX_GROUP_PRIVACY_STATE_PUBLIC, + * the group will attempt to announce itself to the DHT and anyone with the Chat ID may join. + * Otherwise a friend invite will be required to join the group. + * @param group_name The name of the group. The name must be non-NULL. + * @param group_name_length The length of the group name. This must be greater than zero and no larger than + * TOX_GROUP_MAX_GROUP_NAME_LENGTH. + * @param name The name of the peer creating the group. + * @param name_length The length of the peer's name. This must be greater than zero and no larger + * than TOX_MAX_NAME_LENGTH. + * + * @return group_number on success, UINT32_MAX on failure. + */ +uint32_t tox_group_new(Tox *tox, Tox_Group_Privacy_State privacy_state, const uint8_t *group_name, + size_t group_name_length, const uint8_t *name, size_t name_length, Tox_Err_Group_New *error); + +typedef enum Tox_Err_Group_Join { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_JOIN_OK, + + /** + * The group instance failed to initialize. + */ + TOX_ERR_GROUP_JOIN_INIT, + + /** + * The chat_id pointer is set to NULL or a group with chat_id already exists. This usually + * happens if the client attempts to create multiple sessions for the same group. + */ + TOX_ERR_GROUP_JOIN_BAD_CHAT_ID, + + /** + * name is NULL or name_length is zero. + */ + TOX_ERR_GROUP_JOIN_EMPTY, + + /** + * name exceeds TOX_MAX_NAME_LENGTH. + */ + TOX_ERR_GROUP_JOIN_TOO_LONG, + + /** + * Failed to set password. This usually occurs if the password exceeds TOX_GROUP_MAX_PASSWORD_SIZE. + */ + TOX_ERR_GROUP_JOIN_PASSWORD, + + /** + * There was a core error when initiating the group. + */ + TOX_ERR_GROUP_JOIN_CORE, + +} Tox_Err_Group_Join; + + +/** + * Joins a group chat with specified Chat ID. + * + * This function creates a new group chat object, adds it to the chats array, and sends + * a DHT announcement to find peers in the group associated with chat_id. Once a peer has been + * found a join attempt will be initiated. + * + * @param chat_id The Chat ID of the group you wish to join. This must be TOX_GROUP_CHAT_ID_SIZE bytes. + * @param password The password required to join the group. Set to NULL if no password is required. + * @param password_length The length of the password. If length is equal to zero, + * the password parameter is ignored. length must be no larger than TOX_GROUP_MAX_PASSWORD_SIZE. + * @param name The name of the peer joining the group. + * @param name_length The length of the peer's name. This must be greater than zero and no larger + * than TOX_MAX_NAME_LENGTH. + * + * @return group_number on success, UINT32_MAX on failure. + */ +uint32_t tox_group_join(Tox *tox, const uint8_t *chat_id, const uint8_t *name, size_t name_length, + const uint8_t *password, size_t password_length, Tox_Err_Group_Join *error); + +typedef enum Tox_Err_Group_Is_Connected { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_IS_CONNECTED_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_IS_CONNECTED_GROUP_NOT_FOUND, + +} Tox_Err_Group_Is_Connected; + + +/** + * Returns true if the group chat is currently connected or attempting to connect to other peers + * in the group. + * + * @param group_number The group number of the designated group. + */ +bool tox_group_is_connected(const Tox *tox, uint32_t group_number, Tox_Err_Group_Is_Connected *error); + +typedef enum Tox_Err_Group_Disconnect { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_DISCONNECT_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_DISCONNECT_GROUP_NOT_FOUND, + + /** + * The group is already disconnected. + */ + TOX_ERR_GROUP_DISCONNECT_ALREADY_DISCONNECTED, +} Tox_Err_Group_Disconnect; + + +/** + * Disconnects from a group chat while retaining the group state and credentials. + * + * Returns true if we successfully disconnect from the group. + * + * @param group_number The group number of the designated group. + */ +bool tox_group_disconnect(const Tox *tox, uint32_t group_number, Tox_Err_Group_Disconnect *error); + +typedef enum Tox_Err_Group_Reconnect { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_RECONNECT_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_RECONNECT_GROUP_NOT_FOUND, + + /** + * There was a core error when initiating the group. + */ + TOX_ERR_GROUP_RECONNECT_CORE, + +} Tox_Err_Group_Reconnect; + + +/** + * Reconnects to a group. + * + * This function disconnects from all peers in the group, then attempts to reconnect with the group. + * The caller's state is not changed (i.e. name, status, role, chat public key etc.). + * + * @param group_number The group number of the group we wish to reconnect to. + * + * @return true on success. + */ +bool tox_group_reconnect(Tox *tox, uint32_t group_number, Tox_Err_Group_Reconnect *error); + +typedef enum Tox_Err_Group_Leave { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_LEAVE_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_LEAVE_GROUP_NOT_FOUND, + + /** + * Message length exceeded TOX_GROUP_MAX_PART_LENGTH. + */ + TOX_ERR_GROUP_LEAVE_TOO_LONG, + + /** + * The parting packet failed to send. + */ + TOX_ERR_GROUP_LEAVE_FAIL_SEND, +} Tox_Err_Group_Leave; + + +/** + * Leaves a group. + * + * This function sends a parting packet containing a custom (non-obligatory) message to all + * peers in a group, and deletes the group from the chat array. All group state information is permanently + * lost, including keys and role credentials. + * + * @param group_number The group number of the group we wish to leave. + * @param part_message The parting message to be sent to all the peers. Set to NULL if we do not wish to + * send a parting message. + * @param length The length of the parting message. Set to 0 if we do not wish to send a parting message. + * + * @return true if the group chat instance is successfully deleted. + */ +bool tox_group_leave(Tox *tox, uint32_t group_number, const uint8_t *part_message, size_t length, + Tox_Err_Group_Leave *error); + + +/******************************************************************************* + * + * :: Group user-visible client information (nickname/status/role/public key) + * + ******************************************************************************/ + + + +/** + * General error codes for self state get and size functions. + */ +typedef enum Tox_Err_Group_Self_Query { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_SELF_QUERY_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_SELF_QUERY_GROUP_NOT_FOUND, + +} Tox_Err_Group_Self_Query; + + +/** + * Error codes for self name setting. + */ +typedef enum Tox_Err_Group_Self_Name_Set { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_SELF_NAME_SET_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_SELF_NAME_SET_GROUP_NOT_FOUND, + + /** + * Name length exceeded TOX_MAX_NAME_LENGTH. + */ + TOX_ERR_GROUP_SELF_NAME_SET_TOO_LONG, + + /** + * The length given to the set function is zero or name is a NULL pointer. + */ + TOX_ERR_GROUP_SELF_NAME_SET_INVALID, + + /** + * The packet failed to send. + */ + TOX_ERR_GROUP_SELF_NAME_SET_FAIL_SEND, + +} Tox_Err_Group_Self_Name_Set; + + +/** + * Set the client's nickname for the group instance designated by the given group number. + * + * Nickname length cannot exceed TOX_MAX_NAME_LENGTH. If length is equal to zero or name is a NULL + * pointer, the function call will fail. + * + * @param name A byte array containing the new nickname. + * @param length The size of the name byte array. + * + * @return true on success. + */ +bool tox_group_self_set_name(const Tox *tox, uint32_t group_number, const uint8_t *name, size_t length, + Tox_Err_Group_Self_Name_Set *error); + +/** + * Return the length of the client's current nickname for the group instance designated + * by group_number as passed to tox_group_self_set_name. + * + * If no nickname was set before calling this function, the name is empty, + * and this function returns 0. + * + * @see threading for concurrency implications. + */ +size_t tox_group_self_get_name_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_Self_Query *error); + +/** + * Write the nickname set by tox_group_self_set_name to a byte array. + * + * If no nickname was set before calling this function, the name is empty, + * and this function has no effect. + * + * Call tox_group_self_get_name_size to find out how much memory to allocate for the result. + * + * @param name A valid memory location large enough to hold the nickname. + * If this parameter is NULL, the function has no effect. + * + * @return true on success. + */ +bool tox_group_self_get_name(const Tox *tox, uint32_t group_number, uint8_t *name, Tox_Err_Group_Self_Query *error); + +/** + * Error codes for self status setting. + */ +typedef enum Tox_Err_Group_Self_Status_Set { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_SELF_STATUS_SET_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_SELF_STATUS_SET_GROUP_NOT_FOUND, + + /** + * The packet failed to send. + */ + TOX_ERR_GROUP_SELF_STATUS_SET_FAIL_SEND, + +} Tox_Err_Group_Self_Status_Set; + + +/** + * Set the client's status for the group instance. Status must be a Tox_User_Status. + * + * @return true on success. + */ +bool tox_group_self_set_status(const Tox *tox, uint32_t group_number, Tox_User_Status status, + Tox_Err_Group_Self_Status_Set *error); + +/** + * returns the client's status for the group instance on success. + * return value is unspecified on failure. + */ +Tox_User_Status tox_group_self_get_status(const Tox *tox, uint32_t group_number, Tox_Err_Group_Self_Query *error); + +/** + * returns the client's role for the group instance on success. + * return value is unspecified on failure. + */ +Tox_Group_Role tox_group_self_get_role(const Tox *tox, uint32_t group_number, Tox_Err_Group_Self_Query *error); + +/** + * returns the client's peer id for the group instance on success. + * return value is unspecified on failure. + */ +uint32_t tox_group_self_get_peer_id(const Tox *tox, uint32_t group_number, Tox_Err_Group_Self_Query *error); + +/** + * Write the client's group public key designated by the given group number to a byte array. + * + * This key will be permanently tied to the client's identity for this particular group until + * the client explicitly leaves the group. This key is the only way for other peers to reliably + * identify the client across client restarts. + * + * `public_key` should have room for at least TOX_GROUP_PEER_PUBLIC_KEY_SIZE bytes. + * + * @param public_key A valid memory region large enough to store the public key. + * If this parameter is NULL, this function call has no effect. + * + * @return true on success. + */ +bool tox_group_self_get_public_key(const Tox *tox, uint32_t group_number, uint8_t *public_key, + Tox_Err_Group_Self_Query *error); + + +/******************************************************************************* + * + * :: Peer-specific group state queries. + * + ******************************************************************************/ + + + +/** + * Error codes for peer info queries. + */ +typedef enum Tox_Err_Group_Peer_Query { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_PEER_QUERY_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_PEER_QUERY_GROUP_NOT_FOUND, + + /** + * The ID passed did not designate a valid peer. + */ + TOX_ERR_GROUP_PEER_QUERY_PEER_NOT_FOUND, + +} Tox_Err_Group_Peer_Query; + + +/** + * Return the length of the peer's name. If the group number or ID is invalid, the + * return value is unspecified. + * + * @param group_number The group number of the group we wish to query. + * @param peer_id The ID of the peer whose name length we want to retrieve. + * + * The return value is equal to the `length` argument received by the last + * `group_peer_name` callback. + */ +size_t tox_group_peer_get_name_size(const Tox *tox, uint32_t group_number, uint32_t peer_id, + Tox_Err_Group_Peer_Query *error); + +/** + * Write the name of the peer designated by the given ID to a byte + * array. + * + * Call tox_group_peer_get_name_size to determine the allocation size for the `name` parameter. + * + * The data written to `name` is equal to the data received by the last + * `group_peer_name` callback. + * + * @param group_number The group number of the group we wish to query. + * @param peer_id The ID of the peer whose name we wish to retrieve. + * @param name A valid memory region large enough to store the friend's name. + * + * @return true on success. + */ +bool tox_group_peer_get_name(const Tox *tox, uint32_t group_number, uint32_t peer_id, uint8_t *name, + Tox_Err_Group_Peer_Query *error); + +/** + * Return the peer's user status (away/busy/...). If the ID or group number is + * invalid, the return value is unspecified. + * + * @param group_number The group number of the group we wish to query. + * @param peer_id The ID of the peer whose status we wish to query. + * + * The status returned is equal to the last status received through the + * `group_peer_status` callback. + */ +Tox_User_Status tox_group_peer_get_status(const Tox *tox, uint32_t group_number, uint32_t peer_id, + Tox_Err_Group_Peer_Query *error); + +/** + * Return the peer's role (user/moderator/founder...). If the ID or group number is + * invalid, the return value is unspecified. + * + * @param group_number The group number of the group we wish to query. + * @param peer_id The ID of the peer whose role we wish to query. + * + * The role returned is equal to the last role received through the + * `group_moderation` callback. + */ +Tox_Group_Role tox_group_peer_get_role(const Tox *tox, uint32_t group_number, uint32_t peer_id, + Tox_Err_Group_Peer_Query *error); + +/** + * Return the type of connection we have established with a peer. + * + * This function will return an error if called on ourselves. + * + * @param group_number The group number of the group we wish to query. + * @param peer_id The ID of the peer whose connection status we wish to query. + */ +Tox_Connection tox_group_peer_get_connection_status(const Tox *tox, uint32_t group_number, uint32_t peer_id, + Tox_Err_Group_Peer_Query *error); + +/** + * Write the group public key with the designated peer_id for the designated group number to public_key. + * + * This key will be permanently tied to a particular peer until they explicitly leave the group and is + * the only way to reliably identify the same peer across client restarts. + * + * `public_key` should have room for at least TOX_GROUP_PEER_PUBLIC_KEY_SIZE bytes. If `public_key` is null + * this function has no effect. + * + * @param group_number The group number of the group we wish to query. + * @param peer_id The ID of the peer whose public key we wish to retrieve. + * @param public_key A valid memory region large enough to store the public key. + * If this parameter is NULL, this function call has no effect. + * + * @return true on success. + */ +bool tox_group_peer_get_public_key(const Tox *tox, uint32_t group_number, uint32_t peer_id, uint8_t *public_key, + Tox_Err_Group_Peer_Query *error); + +/** + * @param group_number The group number of the group the name change is intended for. + * @param peer_id The ID of the peer who has changed their name. + * @param name The name data. + * @param length The length of the name. + */ +typedef void tox_group_peer_name_cb(Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *name, + size_t length, void *user_data); + + +/** + * Set the callback for the `group_peer_name` event. Pass NULL to unset. + * + * This event is triggered when a peer changes their nickname. + */ +void tox_callback_group_peer_name(Tox *tox, tox_group_peer_name_cb *callback); + +/** + * @param group_number The group number of the group the status change is intended for. + * @param peer_id The ID of the peer who has changed their status. + * @param status The new status of the peer. + */ +typedef void tox_group_peer_status_cb(Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_User_Status status, + void *user_data); + + +/** + * Set the callback for the `group_peer_status` event. Pass NULL to unset. + * + * This event is triggered when a peer changes their status. + */ +void tox_callback_group_peer_status(Tox *tox, tox_group_peer_status_cb *callback); + + +/******************************************************************************* + * + * :: Group chat state queries and events. + * + ******************************************************************************/ + + + +/** + * General error codes for group state get and size functions. + */ +typedef enum Tox_Err_Group_State_Queries { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_STATE_QUERIES_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND, + +} Tox_Err_Group_State_Queries; + + +/** + * Error codes for group topic setting. + */ +typedef enum Tox_Err_Group_Topic_Set { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_TOPIC_SET_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_TOPIC_SET_GROUP_NOT_FOUND, + + /** + * Topic length exceeded TOX_GROUP_MAX_TOPIC_LENGTH. + */ + TOX_ERR_GROUP_TOPIC_SET_TOO_LONG, + + /** + * The caller does not have the required permissions to set the topic. + */ + TOX_ERR_GROUP_TOPIC_SET_PERMISSIONS, + + /** + * The packet could not be created. This error is usually related to cryptographic signing. + */ + TOX_ERR_GROUP_TOPIC_SET_FAIL_CREATE, + + /** + * The packet failed to send. + */ + TOX_ERR_GROUP_TOPIC_SET_FAIL_SEND, + + /** + * The group is disconnected. + */ + TOX_ERR_GROUP_TOPIC_SET_DISCONNECTED, + +} Tox_Err_Group_Topic_Set; + + +/** + * Set the group topic and broadcast it to the rest of the group. + * + * topic length cannot be longer than TOX_GROUP_MAX_TOPIC_LENGTH. If length is equal to zero or + * topic is set to NULL, the topic will be unset. + * + * @return true on success. + */ +bool tox_group_set_topic(const Tox *tox, uint32_t group_number, const uint8_t *topic, size_t length, + Tox_Err_Group_Topic_Set *error); + +/** + * Return the length of the group topic. If the group number is invalid, the + * return value is unspecified. + * + * The return value is equal to the `length` argument received by the last + * `group_topic` callback. + */ +size_t tox_group_get_topic_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error); + +/** + * Write the topic designated by the given group number to a byte array. + * + * Call tox_group_get_topic_size to determine the allocation size for the `topic` parameter. + * + * The data written to `topic` is equal to the data received by the last + * `group_topic` callback. + * + * @param topic A valid memory region large enough to store the topic. + * If this parameter is NULL, this function has no effect. + * + * @return true on success. + */ +bool tox_group_get_topic(const Tox *tox, uint32_t group_number, uint8_t *topic, Tox_Err_Group_State_Queries *error); + +/** + * @param group_number The group number of the group the topic change is intended for. + * @param peer_id The ID of the peer who changed the topic. If the peer who set the topic + * is not present in our peer list this value will be set to 0. + * @param topic The topic data. + * @param length The topic length. + */ +typedef void tox_group_topic_cb(Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *topic, size_t length, + void *user_data); + + +/** + * Set the callback for the `group_topic` event. Pass NULL to unset. + * + * This event is triggered when a peer changes the group topic. + */ +void tox_callback_group_topic(Tox *tox, tox_group_topic_cb *callback); + +/** + * Return the length of the group name. If the group number is invalid, the + * return value is unspecified. + */ +size_t tox_group_get_name_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error); + +/** + * Write the name of the group designated by the given group number to a byte array. + * + * Call tox_group_get_name_size to determine the allocation size for the `name` parameter. + * + * @param group_name A valid memory region large enough to store the group name. + * If this parameter is NULL, this function call has no effect. + * + * @return true on success. + */ +bool tox_group_get_name(const Tox *tox, uint32_t group_number, uint8_t *group_name, Tox_Err_Group_State_Queries *error); + +/** + * Write the Chat ID designated by the given group number to a byte array. + * + * `chat_id` should have room for at least TOX_GROUP_CHAT_ID_SIZE bytes. + * + * @param chat_id A valid memory region large enough to store the Chat ID. + * If this parameter is NULL, this function call has no effect. + * + * @return true on success. + */ +bool tox_group_get_chat_id(const Tox *tox, uint32_t group_number, uint8_t *chat_id, Tox_Err_Group_State_Queries *error); + +/** + * Return the number of groups in the Tox chats array. + */ +uint32_t tox_group_get_number_groups(const Tox *tox); + +/** + * Return the privacy state of the group designated by the given group number. If group number + * is invalid, the return value is unspecified. + * + * The value returned is equal to the data received by the last + * `group_privacy_state` callback. + * + * @see the `Group chat founder controls` section for the respective set function. + */ +Tox_Group_Privacy_State tox_group_get_privacy_state(const Tox *tox, uint32_t group_number, + Tox_Err_Group_State_Queries *error); + +/** + * @param group_number The group number of the group the privacy state is intended for. + * @param privacy_state The new privacy state. + */ +typedef void tox_group_privacy_state_cb(Tox *tox, uint32_t group_number, Tox_Group_Privacy_State privacy_state, + void *user_data); + + +/** + * Set the callback for the `group_privacy_state` event. Pass NULL to unset. + * + * This event is triggered when the group founder changes the privacy state. + */ +void tox_callback_group_privacy_state(Tox *tox, tox_group_privacy_state_cb *callback); + +/** + * Return the voice state of the group designated by the given group number. If group number + * is invalid, the return value is unspecified. + * + * The value returned is equal to the data received by the last `group_voice_state` callback. + * + * @see the `Group chat founder controls` section for the respective set function. + */ +Tox_Group_Voice_State tox_group_get_voice_state(const Tox *tox, uint32_t group_number, + Tox_Err_Group_State_Queries *error); + +/** + * @param group_number The group number of the group the voice state change is intended for. + * @param voice_state The new voice state. + */ +typedef void tox_group_voice_state_cb(Tox *tox, uint32_t group_number, Tox_Group_Voice_State voice_state, + void *user_data); + + +/** + * Set the callback for the `group_privacy_state` event. Pass NULL to unset. + * + * This event is triggered when the group founder changes the voice state. + */ +void tox_callback_group_voice_state(Tox *tox, tox_group_voice_state_cb *callback); + +/** + * Return the topic lock status of the group designated by the given group number. If group number + * is invalid, the return value is unspecified. + * + * The value returned is equal to the data received by the last + * `group_topic_lock` callback. + * + * @see the `Group chat founder contols` section for the respective set function. + */ +Tox_Group_Topic_Lock tox_group_get_topic_lock(const Tox *tox, uint32_t group_number, + Tox_Err_Group_State_Queries *error); + +/** + * @param group_number The group number of the group for which the topic lock has changed. + * @param topic_lock The new topic lock state. + */ +typedef void tox_group_topic_lock_cb(Tox *tox, uint32_t group_number, Tox_Group_Topic_Lock topic_lock, void *user_data); + + + +/** + * Set the callback for the `group_topic_lock` event. Pass NULL to unset. + * + * This event is triggered when the group founder changes the topic lock status. + */ +void tox_callback_group_topic_lock(Tox *tox, tox_group_topic_lock_cb *callback); + +/** + * Return the maximum number of peers allowed for the group designated by the given group number. + * If the group number is invalid, the return value is unspecified. + * + * The value returned is equal to the data received by the last + * `group_peer_limit` callback. + * + * @see the `Group chat founder controls` section for the respective set function. + */ +uint16_t tox_group_get_peer_limit(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error); + +/** + * @param group_number The group number of the group for which the peer limit has changed. + * @param peer_limit The new peer limit for the group. + */ +typedef void tox_group_peer_limit_cb(Tox *tox, uint32_t group_number, uint32_t peer_limit, void *user_data); + + +/** + * Set the callback for the `group_peer_limit` event. Pass NULL to unset. + * + * This event is triggered when the group founder changes the maximum peer limit. + */ +void tox_callback_group_peer_limit(Tox *tox, tox_group_peer_limit_cb *callback); + +/** + * Return the length of the group password. If the group number is invalid, the + * return value is unspecified. + */ +size_t tox_group_get_password_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error); + +/** + * Write the password for the group designated by the given group number to a byte array. + * + * Call tox_group_get_password_size to determine the allocation size for the `password` parameter. + * + * The data received is equal to the data received by the last + * `group_password` callback. + * + * @see the `Group chat founder controls` section for the respective set function. + * + * @param password A valid memory region large enough to store the group password. + * If this parameter is NULL, this function call has no effect. + * + * @return true on success. + */ +bool tox_group_get_password(const Tox *tox, uint32_t group_number, uint8_t *password, + Tox_Err_Group_State_Queries *error); + +/** + * @param group_number The group number of the group for which the password has changed. + * @param password The new group password. + * @param length The length of the password. + */ +typedef void tox_group_password_cb(Tox *tox, uint32_t group_number, const uint8_t *password, size_t length, + void *user_data); + + +/** + * Set the callback for the `group_password` event. Pass NULL to unset. + * + * This event is triggered when the group founder changes the group password. + */ +void tox_callback_group_password(Tox *tox, tox_group_password_cb *callback); + + +/******************************************************************************* + * + * :: Group chat message sending + * + ******************************************************************************/ + + + +typedef enum Tox_Err_Group_Send_Message { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_SEND_MESSAGE_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_SEND_MESSAGE_GROUP_NOT_FOUND, + + /** + * Message length exceeded TOX_GROUP_MAX_MESSAGE_LENGTH. + */ + TOX_ERR_GROUP_SEND_MESSAGE_TOO_LONG, + + /** + * The message pointer is null or length is zero. + */ + TOX_ERR_GROUP_SEND_MESSAGE_EMPTY, + + /** + * The message type is invalid. + */ + TOX_ERR_GROUP_SEND_MESSAGE_BAD_TYPE, + + /** + * The caller does not have the required permissions to send group messages. + */ + TOX_ERR_GROUP_SEND_MESSAGE_PERMISSIONS, + + /** + * Packet failed to send. + */ + TOX_ERR_GROUP_SEND_MESSAGE_FAIL_SEND, + + /** + * The group is disconnected. + */ + TOX_ERR_GROUP_SEND_MESSAGE_DISCONNECTED, + +} Tox_Err_Group_Send_Message; + + +/** + * Send a text chat message to the group. + * + * This function creates a group message packet and pushes it into the send + * queue. + * + * The message length may not exceed TOX_GROUP_MAX_MESSAGE_LENGTH. Larger messages + * must be split by the client and sent as separate messages. Other clients can + * then reassemble the fragments. Messages may not be empty. + * + * @param group_number The group number of the group the message is intended for. + * @param type Message type (normal, action, ...). + * @param message A non-NULL pointer to the first element of a byte array + * containing the message text. + * @param length Length of the message to be sent. + * @param message_id A pointer to a uint32_t. The message_id of this message will be returned + * unless the parameter is NULL, in which case the returned parameter value will be undefined. + * If this function returns false the returned parameter `message_id` value will also be undefined. + * + * @return true on success. + */ +bool tox_group_send_message(const Tox *tox, uint32_t group_number, Tox_Message_Type type, const uint8_t *message, + size_t length, uint32_t *message_id, Tox_Err_Group_Send_Message *error); + +typedef enum Tox_Err_Group_Send_Private_Message { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_GROUP_NOT_FOUND, + + /** + * The peer ID passed did not designate a valid peer. + */ + TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PEER_NOT_FOUND, + + /** + * Message length exceeded TOX_GROUP_MAX_MESSAGE_LENGTH. + */ + TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_TOO_LONG, + + /** + * The message pointer is null or length is zero. + */ + TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_EMPTY, + + /** + * The caller does not have the required permissions to send group messages. + */ + TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PERMISSIONS, + + /** + * Packet failed to send. + */ + TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_FAIL_SEND, + + /** + * The group is disconnected. + */ + TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_DISCONNECTED, + + /** + * The message type is invalid. + */ + TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_BAD_TYPE, + +} Tox_Err_Group_Send_Private_Message; + + +/** + * Send a text chat message to the specified peer in the specified group. + * + * This function creates a group private message packet and pushes it into the send + * queue. + * + * The message length may not exceed TOX_GROUP_MAX_MESSAGE_LENGTH. Larger messages + * must be split by the client and sent as separate messages. Other clients can + * then reassemble the fragments. Messages may not be empty. + * + * @param group_number The group number of the group the message is intended for. + * @param peer_id The ID of the peer the message is intended for. + * @param message A non-NULL pointer to the first element of a byte array + * containing the message text. + * @param length Length of the message to be sent. + * + * @return true on success. + */ +bool tox_group_send_private_message(const Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, + const uint8_t *message, size_t length, Tox_Err_Group_Send_Private_Message *error); + +typedef enum Tox_Err_Group_Send_Custom_Packet { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PACKET_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PACKET_GROUP_NOT_FOUND, + + /** + * Message length exceeded TOX_GROUP_MAX_CUSTOM_LOSSY_PACKET_LENGTH if the + * packet was lossy, or TOX_GROUP_MAX_CUSTOM_LOSSLESS_PACKET_LENGTH if the + * packet was lossless. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PACKET_TOO_LONG, + + /** + * The message pointer is null or length is zero. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PACKET_EMPTY, + + /** + * The caller does not have the required permissions to send group messages. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PACKET_PERMISSIONS, + + /** + * The group is disconnected. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PACKET_DISCONNECTED, + +} Tox_Err_Group_Send_Custom_Packet; + + +/** + * Send a custom packet to the group. + * + * If lossless is true the packet will be lossless. Lossless packet behaviour is comparable + * to TCP (reliability, arrive in order) but with packets instead of a stream. + * + * If lossless is false, the packet will be lossy. Lossy packets behave like UDP packets, + * meaning they might never reach the other side or might arrive more than once (if someone + * is messing with the connection) or might arrive in the wrong order. + * + * Unless latency is an issue or message reliability is not important, it is recommended that you use + * lossless packets. + * + * The message length may not exceed TOX_MAX_CUSTOM_PACKET_SIZE. Larger packets + * must be split by the client and sent as separate packets. Other clients can + * then reassemble the fragments. Packets may not be empty. + * + * @param group_number The group number of the group the packet is intended for. + * @param lossless True if the packet should be lossless. + * @param data A byte array containing the packet data. + * @param length The length of the packet data byte array. + * + * @return true on success. + */ +bool tox_group_send_custom_packet(const Tox *tox, uint32_t group_number, bool lossless, const uint8_t *data, + size_t length, + Tox_Err_Group_Send_Custom_Packet *error); + + +typedef enum Tox_Err_Group_Send_Custom_Private_Packet { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_GROUP_NOT_FOUND, + + /** + * Message length exceeded TOX_GROUP_MAX_CUSTOM_LOSSY_PACKET_LENGTH if the + * packet was lossy, or TOX_GROUP_MAX_CUSTOM_LOSSLESS_PACKET_LENGTH if the + * packet was lossless. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_TOO_LONG, + + /** + * The message pointer is null or length is zero. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_EMPTY, + + /** + * The peer ID passed did no designate a valid peer. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_PEER_NOT_FOUND, + + /** + * The caller does not have the required permissions to send group messages. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_PERMISSIONS, + + /** + * The packet failed to send. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_FAIL_SEND, + + /** + * The group is disconnected. + */ + TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_DISCONNECTED, + +} Tox_Err_Group_Send_Custom_Private_Packet; + +/** + * Send a custom private packet to a designated peer in the group. + * + * If lossless is true the packet will be lossless. Lossless packet behaviour is comparable + * to TCP (reliability, arrive in order) but with packets instead of a stream. + * + * If lossless is false, the packet will be lossy. Lossy packets behave like UDP packets, + * meaning they might never reach the other side or might arrive more than once (if someone + * is messing with the connection) or might arrive in the wrong order. + * + * Unless latency is an issue or message reliability is not important, it is recommended that you use + * lossless packets. + * + * The packet length may not exceed TOX_MAX_CUSTOM_PACKET_SIZE. Larger packets + * must be split by the client and sent as separate packets. Other clients can + * then reassemble the fragments. Packets may not be empty. + * + * @param group_number The group number of the group the packet is intended for. + * @param peer_id The ID of the peer the packet is intended for. + * @param lossless True if the packet should be lossless. + * @param data A byte array containing the packet data. + * @param length The length of the packet data byte array. + * + * @return true on success. + */ +bool tox_group_send_custom_private_packet(const Tox *tox, uint32_t group_number, uint32_t peer_id, bool lossless, + const uint8_t *data, size_t length, + Tox_Err_Group_Send_Custom_Private_Packet *error); + + +/******************************************************************************* + * + * :: Group chat message receiving + * + ******************************************************************************/ + + + +/** + * @param group_number The group number of the group the message is intended for. + * @param peer_id The ID of the peer who sent the message. + * @param type The type of message (normal, action, ...). + * @param message The message data. + * @param message_id A pseudo message id that clients can use to uniquely identify this group message. + * @param length The length of the message. + */ +typedef void tox_group_message_cb(Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, + const uint8_t *message, size_t length, uint32_t message_id, void *user_data); + + +/** + * Set the callback for the `group_message` event. Pass NULL to unset. + * + * This event is triggered when the client receives a group message. + */ +void tox_callback_group_message(Tox *tox, tox_group_message_cb *callback); + +/** + * @param group_number The group number of the group the private message is intended for. + * @param peer_id The ID of the peer who sent the private message. + * @param message The message data. + * @param length The length of the message. + */ +typedef void tox_group_private_message_cb(Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, + const uint8_t *message, size_t length, void *user_data); + + +/** + * Set the callback for the `group_private_message` event. Pass NULL to unset. + * + * This event is triggered when the client receives a private message. + */ +void tox_callback_group_private_message(Tox *tox, tox_group_private_message_cb *callback); + +/** + * @param group_number The group number of the group the packet is intended for. + * @param peer_id The ID of the peer who sent the packet. + * @param data The packet data. + * @param length The length of the data. + */ +typedef void tox_group_custom_packet_cb(Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *data, + size_t length, void *user_data); + + +/** + * Set the callback for the `group_custom_packet` event. Pass NULL to unset. + * + * This event is triggered when the client receives a custom packet. + */ +void tox_callback_group_custom_packet(Tox *tox, tox_group_custom_packet_cb *callback); + +/** + * @param group_number The group number of the group the packet is intended for. + * @param peer_id The ID of the peer who sent the packet. + * @param data The packet data. + * @param length The length of the data. + */ +typedef void tox_group_custom_private_packet_cb(Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *data, + size_t length, void *user_data); + + +/** + * Set the callback for the `group_custom_private_packet` event. Pass NULL to unset. + * + * This event is triggered when the client receives a custom private packet. + */ +void tox_callback_group_custom_private_packet(Tox *tox, tox_group_custom_private_packet_cb *callback); + + +/******************************************************************************* + * + * :: Group chat inviting and join/part events + * + ******************************************************************************/ + + + +typedef enum Tox_Err_Group_Invite_Friend { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_INVITE_FRIEND_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_INVITE_FRIEND_GROUP_NOT_FOUND, + + /** + * The friend number passed did not designate a valid friend. + */ + TOX_ERR_GROUP_INVITE_FRIEND_FRIEND_NOT_FOUND, + + /** + * Creation of the invite packet failed. This indicates a network related error. + */ + TOX_ERR_GROUP_INVITE_FRIEND_INVITE_FAIL, + + /** + * Packet failed to send. + */ + TOX_ERR_GROUP_INVITE_FRIEND_FAIL_SEND, + + /** + * The group is disconnected. + */ + TOX_ERR_GROUP_INVITE_FRIEND_DISCONNECTED, + +} Tox_Err_Group_Invite_Friend; + + +/** + * Invite a friend to a group. + * + * This function creates an invite request packet and pushes it to the send queue. + * + * @param group_number The group number of the group the message is intended for. + * @param friend_number The friend number of the friend the invite is intended for. + * + * @return true on success. + */ +bool tox_group_invite_friend(const Tox *tox, uint32_t group_number, uint32_t friend_number, + Tox_Err_Group_Invite_Friend *error); + +typedef enum Tox_Err_Group_Invite_Accept { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_INVITE_ACCEPT_OK, + + /** + * The invite data is not in the expected format. + */ + TOX_ERR_GROUP_INVITE_ACCEPT_BAD_INVITE, + + /** + * The group instance failed to initialize. + */ + TOX_ERR_GROUP_INVITE_ACCEPT_INIT_FAILED, + + /** + * name exceeds TOX_MAX_NAME_LENGTH + */ + TOX_ERR_GROUP_INVITE_ACCEPT_TOO_LONG, + + /** + * name is NULL or name_length is zero. + */ + TOX_ERR_GROUP_INVITE_ACCEPT_EMPTY, + + /** + * Failed to set password. This usually occurs if the password exceeds TOX_GROUP_MAX_PASSWORD_SIZE. + */ + TOX_ERR_GROUP_INVITE_ACCEPT_PASSWORD, + + /** + * There was a core error when initiating the group. + */ + TOX_ERR_GROUP_INVITE_ACCEPT_CORE, + + /** + * Packet failed to send. + */ + TOX_ERR_GROUP_INVITE_ACCEPT_FAIL_SEND, + +} Tox_Err_Group_Invite_Accept; + + +/** + * Accept an invite to a group chat that the client previously received from a friend. The invite + * is only valid while the inviter is present in the group. + * + * @param invite_data The invite data received from the `group_invite` event. + * @param length The length of the invite data. + * @param name The name of the peer joining the group. + * @param name_length The length of the peer's name. This must be greater than zero and no larger + * than TOX_MAX_NAME_LENGTH. + * @param password The password required to join the group. Set to NULL if no password is required. + * @param password_length The length of the password. If password_length is equal to zero, the password + * parameter will be ignored. password_length must be no larger than TOX_GROUP_MAX_PASSWORD_SIZE. + * + * @return the group_number on success, UINT32_MAX on failure. + */ +uint32_t tox_group_invite_accept(Tox *tox, uint32_t friend_number, const uint8_t *invite_data, size_t length, + const uint8_t *name, size_t name_length, const uint8_t *password, size_t password_length, + Tox_Err_Group_Invite_Accept *error); + +/** + * @param friend_number The friend number of the contact who sent the invite. + * @param invite_data The invite data. + * @param length The length of invite_data. + */ +typedef void tox_group_invite_cb(Tox *tox, uint32_t friend_number, const uint8_t *invite_data, size_t length, + const uint8_t *group_name, size_t group_name_length, void *user_data); + + +/** + * Set the callback for the `group_invite` event. Pass NULL to unset. + * + * This event is triggered when the client receives a group invite from a friend. The client must store + * invite_data which is used to join the group via tox_group_invite_accept. + */ +void tox_callback_group_invite(Tox *tox, tox_group_invite_cb *callback); + +/** + * @param group_number The group number of the group in which a new peer has joined. + * @param peer_id The permanent ID of the new peer. This id should not be relied on for + * client behaviour and should be treated as a random value. + */ +typedef void tox_group_peer_join_cb(Tox *tox, uint32_t group_number, uint32_t peer_id, void *user_data); + + +/** + * Set the callback for the `group_peer_join` event. Pass NULL to unset. + * + * This event is triggered when a peer other than self joins the group. + */ +void tox_callback_group_peer_join(Tox *tox, tox_group_peer_join_cb *callback); + +/** + * Represents peer exit events. These should be used with the `group_peer_exit` event. + */ +typedef enum Tox_Group_Exit_Type { + + /** + * The peer has quit the group. + */ + TOX_GROUP_EXIT_TYPE_QUIT, + + /** + * Your connection with this peer has timed out. + */ + TOX_GROUP_EXIT_TYPE_TIMEOUT, + + /** + * Your connection with this peer has been severed. + */ + TOX_GROUP_EXIT_TYPE_DISCONNECTED, + + /** + * Your connection with all peers has been severed. This will occur when you are kicked from + * a group, rejoin a group, or manually disconnect from a group. + */ + TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED, + + /** + * The peer has been kicked. + */ + TOX_GROUP_EXIT_TYPE_KICK, + + /** + * The peer provided invalid group sync information. + */ + TOX_GROUP_EXIT_TYPE_SYNC_ERROR, + +} Tox_Group_Exit_Type; + + +/** + * @param group_number The group number of the group in which a peer has left. + * @param peer_id The ID of the peer who left the group. This ID no longer designates a valid peer + * and cannot be used for API calls. + * @param exit_type The type of exit event. One of Tox_Group_Exit_Type. + * @param name The nickname of the peer who left the group. + * @param name_length The length of the peer name. + * @param part_message The parting message data. + * @param part_message_length The length of the parting message. + */ +typedef void tox_group_peer_exit_cb(Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Group_Exit_Type exit_type, + const uint8_t *name, size_t name_length, const uint8_t *part_message, size_t part_message_length, void *user_data); + + +/** + * Set the callback for the `group_peer_exit` event. Pass NULL to unset. + * + * This event is triggered when a peer other than self exits the group. + */ +void tox_callback_group_peer_exit(Tox *tox, tox_group_peer_exit_cb *callback); + +/** + * @param group_number The group number of the group that the client has joined. + */ +typedef void tox_group_self_join_cb(Tox *tox, uint32_t group_number, void *user_data); + + +/** + * Set the callback for the `group_self_join` event. Pass NULL to unset. + * + * This event is triggered when the client has successfully joined a group. Use this to initialize + * any group information the client may need. + */ +void tox_callback_group_self_join(Tox *tox, tox_group_self_join_cb *callback); + +/** + * Represents types of failed group join attempts. These are used in the tox_callback_group_rejected + * callback when a peer fails to join a group. + */ +typedef enum Tox_Group_Join_Fail { + + /** + * The group peer limit has been reached. + */ + TOX_GROUP_JOIN_FAIL_PEER_LIMIT, + + /** + * You have supplied an invalid password. + */ + TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD, + + /** + * The join attempt failed due to an unspecified error. This often occurs when the group is + * not found in the DHT. + */ + TOX_GROUP_JOIN_FAIL_UNKNOWN, + +} Tox_Group_Join_Fail; + + +/** + * @param group_number The group number of the group for which the join has failed. + * @param fail_type The type of group rejection. + */ +typedef void tox_group_join_fail_cb(Tox *tox, uint32_t group_number, Tox_Group_Join_Fail fail_type, void *user_data); + + +/** + * Set the callback for the `group_join_fail` event. Pass NULL to unset. + * + * This event is triggered when the client fails to join a group. + */ +void tox_callback_group_join_fail(Tox *tox, tox_group_join_fail_cb *callback); + + +/******************************************************************************* + * + * :: Group chat founder controls (these only work for the group founder) + * + ******************************************************************************/ + + + +typedef enum Tox_Err_Group_Founder_Set_Password { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_GROUP_NOT_FOUND, + + /** + * The caller does not have the required permissions to set the password. + */ + TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_PERMISSIONS, + + /** + * Password length exceeded TOX_GROUP_MAX_PASSWORD_SIZE. + */ + TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_TOO_LONG, + + /** + * The packet failed to send. + */ + TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_FAIL_SEND, + + /** + * The function failed to allocate enough memory for the operation. + */ + TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_MALLOC, + + /** + * The group is disconnected. + */ + TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_DISCONNECTED, + +} Tox_Err_Group_Founder_Set_Password; + + +/** + * Set or unset the group password. + * + * This function sets the groups password, creates a new group shared state including the change, + * and distributes it to the rest of the group. + * + * @param group_number The group number of the group for which we wish to set the password. + * @param password The password we want to set. Set password to NULL to unset the password. + * @param length The length of the password. length must be no longer than TOX_GROUP_MAX_PASSWORD_SIZE. + * + * @return true on success. + */ +bool tox_group_founder_set_password(const Tox *tox, uint32_t group_number, const uint8_t *password, size_t length, + Tox_Err_Group_Founder_Set_Password *error); + +typedef enum Tox_Err_Group_Founder_Set_Topic_Lock { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_GROUP_NOT_FOUND, + + /** + * Tox_Group_Topic_Lock is an invalid type. + */ + TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_INVALID, + + /** + * The caller does not have the required permissions to set the topic lock. + */ + TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_PERMISSIONS, + + /** + * The topic lock could not be set. This may occur due to an error related to + * cryptographic signing of the new shared state. + */ + TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_FAIL_SET, + + /** + * The packet failed to send. + */ + TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_FAIL_SEND, + + /** + * The group is disconnected. + */ + TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_DISCONNECTED, + +} Tox_Err_Group_Founder_Set_Topic_Lock; + + +/** + * Set the group topic lock state. + * + * This function sets the group's topic lock state to enabled or disabled, creates a new shared + * state including the change, and distributes it to the rest of the group. + * + * When the topic lock is enabled, only the group founder and moderators may set the topic. + * When disabled, all peers except those with the observer role may set the topic. + * + * @param group_number The group number of the group for which we wish to change the topic lock state. + * @param topic_lock The state we wish to set the topic lock to. + * + * @return true on success. + */ +bool tox_group_founder_set_topic_lock(const Tox *tox, uint32_t group_number, Tox_Group_Topic_Lock topic_lock, + Tox_Err_Group_Founder_Set_Topic_Lock *error); + +typedef enum Tox_Err_Group_Founder_Set_Voice_State { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_GROUP_NOT_FOUND, + + /** + * The caller does not have the required permissions to set the privacy state. + */ + TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_PERMISSIONS, + + /** + * The voice state could not be set. This may occur due to an error related to + * cryptographic signing of the new shared state. + */ + TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_FAIL_SET, + + /** + * The packet failed to send. + */ + TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_FAIL_SEND, + + /** + * The group is disconnected. + */ + TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_DISCONNECTED, + +} Tox_Err_Group_Founder_Set_Voice_State; + +/** + * Set the group voice state. + * + * This function sets the group's voice state, creates a new group shared state + * including the change, and distributes it to the rest of the group. + * + * If an attempt is made to set the voice state to the same state that the group is already + * in, the function call will be successful and no action will be taken. + * + * @param group_number The group number of the group for which we wish to change the voice state. + * @param voice_state The voice state we wish to set the group to. + * + * @return true on success. + */ +bool tox_group_founder_set_voice_state(const Tox *tox, uint32_t group_number, Tox_Group_Voice_State voice_state, + Tox_Err_Group_Founder_Set_Voice_State *error); + +typedef enum Tox_Err_Group_Founder_Set_Privacy_State { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_GROUP_NOT_FOUND, + + /** + * The caller does not have the required permissions to set the privacy state. + */ + TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_PERMISSIONS, + + /** + * The privacy state could not be set. This may occur due to an error related to + * cryptographic signing of the new shared state. + */ + TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_FAIL_SET, + + /** + * The packet failed to send. + */ + TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_FAIL_SEND, + + /** + * The group is disconnected. + */ + TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_DISCONNECTED, + +} Tox_Err_Group_Founder_Set_Privacy_State; + +/** + * Set the group privacy state. + * + * This function sets the group's privacy state, creates a new group shared state + * including the change, and distributes it to the rest of the group. + * + * If an attempt is made to set the privacy state to the same state that the group is already + * in, the function call will be successful and no action will be taken. + * + * @param group_number The group number of the group for which we wish to change the privacy state. + * @param privacy_state The privacy state we wish to set the group to. + * + * @return true on success. + */ +bool tox_group_founder_set_privacy_state(const Tox *tox, uint32_t group_number, Tox_Group_Privacy_State privacy_state, + Tox_Err_Group_Founder_Set_Privacy_State *error); + +typedef enum Tox_Err_Group_Founder_Set_Peer_Limit { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_GROUP_NOT_FOUND, + + /** + * The caller does not have the required permissions to set the peer limit. + */ + TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_PERMISSIONS, + + /** + * The peer limit could not be set. This may occur due to an error related to + * cryptographic signing of the new shared state. + */ + TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_FAIL_SET, + + /** + * The packet failed to send. + */ + TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_FAIL_SEND, + + /** + * The group is disconnected. + */ + TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_DISCONNECTED, + +} Tox_Err_Group_Founder_Set_Peer_Limit; + + +/** + * Set the group peer limit. + * + * This function sets a limit for the number of peers who may be in the group, creates a new + * group shared state including the change, and distributes it to the rest of the group. + * + * @param group_number The group number of the group for which we wish to set the peer limit. + * @param max_peers The maximum number of peers to allow in the group. + * + * @return true on success. + */ +bool tox_group_founder_set_peer_limit(const Tox *tox, uint32_t group_number, uint16_t max_peers, + Tox_Err_Group_Founder_Set_Peer_Limit *error); + + +/******************************************************************************* + * + * :: Group chat moderation + * + ******************************************************************************/ + + + +typedef enum Tox_Err_Group_Set_Ignore { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_SET_IGNORE_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_SET_IGNORE_GROUP_NOT_FOUND, + + /** + * The ID passed did not designate a valid peer. + */ + TOX_ERR_GROUP_SET_IGNORE_PEER_NOT_FOUND, + + /** + * The caller attempted to ignore himself. + */ + TOX_ERR_GROUP_SET_IGNORE_SELF, + +} Tox_Err_Group_Set_Ignore; + + +/** + * Ignore or unignore a peer. + * + * @param group_number The group number of the group in which you wish to ignore a peer. + * @param peer_id The ID of the peer who shall be ignored or unignored. + * @param ignore True to ignore the peer, false to unignore the peer. + * + * @return true on success. + */ +bool tox_group_set_ignore(const Tox *tox, uint32_t group_number, uint32_t peer_id, bool ignore, + Tox_Err_Group_Set_Ignore *error); + +typedef enum Tox_Err_Group_Mod_Set_Role { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_MOD_SET_ROLE_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_MOD_SET_ROLE_GROUP_NOT_FOUND, + + /** + * The ID passed did not designate a valid peer. Note: you cannot set your own role. + */ + TOX_ERR_GROUP_MOD_SET_ROLE_PEER_NOT_FOUND, + + /** + * The caller does not have the required permissions for this action. + */ + TOX_ERR_GROUP_MOD_SET_ROLE_PERMISSIONS, + + /** + * The role assignment is invalid. This will occur if you try to set a peer's role to + * the role they already have. + */ + TOX_ERR_GROUP_MOD_SET_ROLE_ASSIGNMENT, + + /** + * The role was not successfully set. This may occur if the packet failed to send, or + * if the role limit has been reached. + */ + TOX_ERR_GROUP_MOD_SET_ROLE_FAIL_ACTION, + + /** + * The caller attempted to set their own role. + */ + TOX_ERR_GROUP_MOD_SET_ROLE_SELF, + +} Tox_Err_Group_Mod_Set_Role; + + +/** + * Set a peer's role. + * + * This function will first remove the peer's previous role and then assign them a new role. + * It will also send a packet to the rest of the group, requesting that they perform + * the role reassignment. Note: peers cannot be set to the founder role. + * + * @param group_number The group number of the group the in which you wish set the peer's role. + * @param peer_id The ID of the peer whose role you wish to set. + * @param role The role you wish to set the peer to. + * + * @return true on success. + */ +bool tox_group_mod_set_role(const Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Group_Role role, + Tox_Err_Group_Mod_Set_Role *error); + +typedef enum Tox_Err_Group_Mod_Kick_Peer { + + /** + * The function returned successfully. + */ + TOX_ERR_GROUP_MOD_KICK_PEER_OK, + + /** + * The group number passed did not designate a valid group. + */ + TOX_ERR_GROUP_MOD_KICK_PEER_GROUP_NOT_FOUND, + + /** + * The ID passed did not designate a valid peer. + */ + TOX_ERR_GROUP_MOD_KICK_PEER_PEER_NOT_FOUND, + + /** + * The caller does not have the required permissions for this action. + */ + TOX_ERR_GROUP_MOD_KICK_PEER_PERMISSIONS, + + /** + * The peer could not be kicked from the group. + */ + TOX_ERR_GROUP_MOD_KICK_PEER_FAIL_ACTION, + + /** + * The packet failed to send. + */ + TOX_ERR_GROUP_MOD_KICK_PEER_FAIL_SEND, + + /** + * The caller attempted to set their own role. + */ + TOX_ERR_GROUP_MOD_KICK_PEER_SELF, + +} Tox_Err_Group_Mod_Kick_Peer; + + +/** + * Kick a peer. + * + * This function will remove a peer from the caller's peer list and send a packet to all + * group members requesting them to do the same. Note: This function will not trigger + * the `group_peer_exit` event for the caller. + * + * @param group_number The group number of the group the action is intended for. + * @param peer_id The ID of the peer who will be kicked. + * + * @return true on success. + */ +bool tox_group_mod_kick_peer(const Tox *tox, uint32_t group_number, uint32_t peer_id, + Tox_Err_Group_Mod_Kick_Peer *error); + +/** + * Represents moderation events. These should be used with the `group_moderation` event. + */ +typedef enum Tox_Group_Mod_Event { + + /** + * A peer has been kicked from the group. + */ + TOX_GROUP_MOD_EVENT_KICK, + + /** + * A peer as been given the observer role. + */ + TOX_GROUP_MOD_EVENT_OBSERVER, + + /** + * A peer has been given the user role. + */ + TOX_GROUP_MOD_EVENT_USER, + + /** + * A peer has been given the moderator role. + */ + TOX_GROUP_MOD_EVENT_MODERATOR, + +} Tox_Group_Mod_Event; + + +/** + * @param group_number The group number of the group the event is intended for. + * @param source_peer_id The ID of the peer who initiated the event. + * @param target_peer_id The ID of the peer who is the target of the event. + * @param mod_type The type of event. + */ +typedef void tox_group_moderation_cb(Tox *tox, uint32_t group_number, uint32_t source_peer_id, uint32_t target_peer_id, + Tox_Group_Mod_Event mod_type, void *user_data); + + +/** + * Set the callback for the `group_moderation` event. Pass NULL to unset. + * + * This event is triggered when a moderator or founder executes a moderation event, with + * the exception of the peer who initiates the event. It is also triggered when the + * observer and moderator lists are silently modified (this may occur during group syncing). + * + * If either peer id does not designate a valid peer in the group chat, the client should + * manually update all peer roles. + */ +void tox_callback_group_moderation(Tox *tox, tox_group_moderation_cb *callback); + +/** @} */ + /** @} */ #ifdef __cplusplus diff --git a/protocols/Tox/libtox/src/toxcore/tox_api.c b/protocols/Tox/libtox/src/toxcore/tox_api.c index 00051e497b..61c248c30d 100644 --- a/protocols/Tox/libtox/src/toxcore/tox_api.c +++ b/protocols/Tox/libtox/src/toxcore/tox_api.c @@ -88,6 +88,42 @@ uint32_t tox_max_hostname_length(void) { return TOX_MAX_HOSTNAME_LENGTH; } +uint32_t tox_group_max_topic_length(void) +{ + return TOX_GROUP_MAX_TOPIC_LENGTH; +} +uint32_t tox_group_max_part_length(void) +{ + return TOX_GROUP_MAX_PART_LENGTH; +} +uint32_t tox_group_max_message_length(void) +{ + return TOX_GROUP_MAX_MESSAGE_LENGTH; +} +uint32_t tox_group_max_custom_lossy_packet_length(void) +{ + return TOX_GROUP_MAX_CUSTOM_LOSSY_PACKET_LENGTH; +} +uint32_t tox_group_max_custom_lossless_packet_length(void) +{ + return TOX_GROUP_MAX_CUSTOM_LOSSLESS_PACKET_LENGTH; +} +uint32_t tox_group_max_group_name_length(void) +{ + return TOX_GROUP_MAX_GROUP_NAME_LENGTH; +} +uint32_t tox_group_max_password_size(void) +{ + return TOX_GROUP_MAX_PASSWORD_SIZE; +} +uint32_t tox_group_chat_id_size(void) +{ + return TOX_GROUP_CHAT_ID_SIZE; +} +uint32_t tox_group_peer_public_key_size(void) +{ + return TOX_GROUP_PEER_PUBLIC_KEY_SIZE; +} uint32_t tox_dht_node_ip_string_size(void) { return TOX_DHT_NODE_IP_STRING_SIZE; diff --git a/protocols/Tox/libtox/src/toxcore/tox_dispatch.c b/protocols/Tox/libtox/src/toxcore/tox_dispatch.c index 4b4546e4a4..5427851470 100644 --- a/protocols/Tox/libtox/src/toxcore/tox_dispatch.c +++ b/protocols/Tox/libtox/src/toxcore/tox_dispatch.c @@ -47,9 +47,11 @@ Tox_Dispatch *tox_dispatch_new(Tox_Err_Dispatch_New *error) *dispatch = (Tox_Dispatch) { nullptr }; + if (error != nullptr) { *error = TOX_ERR_DISPATCH_NEW_OK; } + return dispatch; } diff --git a/protocols/Tox/libtox/src/toxcore/tox_struct.h b/protocols/Tox/libtox/src/toxcore/tox_struct.h index 22d1c54a27..8b95d83bbc 100644 --- a/protocols/Tox/libtox/src/toxcore/tox_struct.h +++ b/protocols/Tox/libtox/src/toxcore/tox_struct.h @@ -44,6 +44,24 @@ struct Tox { tox_dht_get_nodes_response_cb *dht_get_nodes_response_callback; tox_friend_lossy_packet_cb *friend_lossy_packet_callback_per_pktid[UINT8_MAX + 1]; tox_friend_lossless_packet_cb *friend_lossless_packet_callback_per_pktid[UINT8_MAX + 1]; + tox_group_peer_name_cb *group_peer_name_callback; + tox_group_peer_status_cb *group_peer_status_callback; + tox_group_topic_cb *group_topic_callback; + tox_group_privacy_state_cb *group_privacy_state_callback; + tox_group_topic_lock_cb *group_topic_lock_callback; + tox_group_voice_state_cb *group_voice_state_callback; + tox_group_peer_limit_cb *group_peer_limit_callback; + tox_group_password_cb *group_password_callback; + tox_group_message_cb *group_message_callback; + tox_group_private_message_cb *group_private_message_callback; + tox_group_custom_packet_cb *group_custom_packet_callback; + tox_group_custom_private_packet_cb *group_custom_private_packet_callback; + tox_group_invite_cb *group_invite_callback; + tox_group_peer_join_cb *group_peer_join_callback; + tox_group_peer_exit_cb *group_peer_exit_callback; + tox_group_self_join_cb *group_self_join_callback; + tox_group_join_fail_cb *group_join_fail_callback; + tox_group_moderation_cb *group_moderation_callback; void *toxav_object; // workaround to store a ToxAV object (setter and getter functions are available) }; diff --git a/protocols/Tox/libtox/src/toxcore/util.c b/protocols/Tox/libtox/src/toxcore/util.c index c70c3a76f5..402977a680 100644 --- a/protocols/Tox/libtox/src/toxcore/util.c +++ b/protocols/Tox/libtox/src/toxcore/util.c @@ -139,12 +139,12 @@ uint32_t jenkins_one_at_a_time_hash(const uint8_t *key, size_t len) for (uint32_t i = 0; i < len; ++i) { hash += key[i]; - hash += hash << 10; + hash += (uint32_t)((uint64_t)hash << 10); hash ^= hash >> 6; } - hash += hash << 3; + hash += (uint32_t)((uint64_t)hash << 3); hash ^= hash >> 11; - hash += hash << 15; + hash += (uint32_t)((uint64_t)hash << 15); return hash; } |