diff --git a/auto_tests/assoc_test.c b/auto_tests/assoc_test.c index 9de95136..165724e9 100644 --- a/auto_tests/assoc_test.c +++ b/auto_tests/assoc_test.c @@ -18,7 +18,7 @@ START_TEST(test_basics) { /* TODO: real test */ - uint8_t id[CLIENT_ID_SIZE]; + uint8_t id[crypto_box_PUBLICKEYBYTES]; Assoc *assoc = new_Assoc_default(id); ck_assert_msg(assoc != NULL, "failed to create default assoc"); @@ -63,19 +63,19 @@ START_TEST(test_fillup) { /* TODO: real test */ int i, j; - uint8_t id[CLIENT_ID_SIZE]; + uint8_t id[crypto_box_PUBLICKEYBYTES]; //uint32_t a = current_time(); uint32_t a = 2710106197; srand(a); - for (i = 0; i < CLIENT_ID_SIZE; ++i) { + for (i = 0; i < crypto_box_PUBLICKEYBYTES; ++i) { id[i] = rand(); } Assoc *assoc = new_Assoc(6, 15, id); ck_assert_msg(assoc != NULL, "failed to create default assoc"); struct entry { - uint8_t id[CLIENT_ID_SIZE]; + uint8_t id[crypto_box_PUBLICKEYBYTES]; IPPTs ippts_send; IP_Port ipp_recv; }; @@ -85,7 +85,7 @@ START_TEST(test_fillup) for (j = 0; j < 128; ++j) { - for (i = 0; i < CLIENT_ID_SIZE; ++i) { + for (i = 0; i < crypto_box_PUBLICKEYBYTES; ++i) { entries[j].id[i] = rand(); } @@ -100,7 +100,7 @@ START_TEST(test_fillup) entries[j].ipp_recv = ipp; if (j % 16 == 0) { - memcpy(entries[j].id, id, CLIENT_ID_SIZE - 30); + memcpy(entries[j].id, id, crypto_box_PUBLICKEYBYTES - 30); memcpy(&closest[j / 16], &entries[j], sizeof(struct entry)); } diff --git a/auto_tests/dht_test.c b/auto_tests/dht_test.c index 479eb330..32985bca 100644 --- a/auto_tests/dht_test.c +++ b/auto_tests/dht_test.c @@ -85,7 +85,7 @@ void test_addto_lists_update(DHT *dht, { int used, test, test1, test2, found; IP_Port test_ipp; - uint8_t test_id[CLIENT_ID_SIZE]; + uint8_t test_id[crypto_box_PUBLICKEYBYTES]; uint8_t ipv6 = ip_port->ip.family == AF_INET6 ? 1 : 0; // check id update for existing ip_port @@ -153,7 +153,7 @@ void test_addto_lists_bad(DHT *dht, { // check "bad" clients replacement int used, test1, test2, test3; - uint8_t public_key[CLIENT_ID_SIZE], test_id1[CLIENT_ID_SIZE], test_id2[CLIENT_ID_SIZE], test_id3[CLIENT_ID_SIZE]; + uint8_t public_key[crypto_box_PUBLICKEYBYTES], test_id1[crypto_box_PUBLICKEYBYTES], test_id2[crypto_box_PUBLICKEYBYTES], test_id3[crypto_box_PUBLICKEYBYTES]; uint8_t ipv6 = ip_port->ip.family == AF_INET6 ? 1 : 0; randombytes(public_key, sizeof(public_key)); @@ -196,7 +196,7 @@ void test_addto_lists_possible_bad(DHT *dht, { // check "possibly bad" clients replacement int used, test1, test2, test3; - uint8_t public_key[CLIENT_ID_SIZE], test_id1[CLIENT_ID_SIZE], test_id2[CLIENT_ID_SIZE], test_id3[CLIENT_ID_SIZE]; + uint8_t public_key[crypto_box_PUBLICKEYBYTES], test_id1[crypto_box_PUBLICKEYBYTES], test_id2[crypto_box_PUBLICKEYBYTES], test_id3[crypto_box_PUBLICKEYBYTES]; uint8_t ipv6 = ip_port->ip.family == AF_INET6 ? 1 : 0; randombytes(public_key, sizeof(public_key)); @@ -258,7 +258,7 @@ void test_addto_lists_good(DHT *dht, IP_Port *ip_port, const uint8_t *comp_client_id) { - uint8_t public_key[CLIENT_ID_SIZE]; + uint8_t public_key[crypto_box_PUBLICKEYBYTES]; uint8_t ipv6 = ip_port->ip.family == AF_INET6 ? 1 : 0; mark_all_good(list, length, ipv6); @@ -291,7 +291,7 @@ void test_addto_lists(IP ip) ck_assert_msg(dht != 0, "Failed to create DHT"); IP_Port ip_port = { .ip = ip, .port = TOX_PORT_DEFAULT }; - uint8_t public_key[CLIENT_ID_SIZE]; + uint8_t public_key[crypto_box_PUBLICKEYBYTES]; int i, used; // check lists filling diff --git a/testing/DHT_test.c b/testing/DHT_test.c index 2f99902f..d07e3959 100644 --- a/testing/DHT_test.c +++ b/testing/DHT_test.c @@ -52,13 +52,13 @@ #define PORT 33445 -uint8_t zeroes_cid[CLIENT_ID_SIZE]; +uint8_t zeroes_cid[crypto_box_PUBLICKEYBYTES]; void print_client_id(uint8_t *public_key) { uint32_t j; - for (j = 0; j < CLIENT_ID_SIZE; j++) { + for (j = 0; j < crypto_box_PUBLICKEYBYTES; j++) { printf("%02hhX", public_key[j]); } } @@ -108,7 +108,7 @@ void print_clientlist(DHT *dht) for (i = 0; i < LCLIENT_LIST; i++) { Client_data *client = &dht->close_clientlist[i]; - if (memcmp(client->public_key, zeroes_cid, CLIENT_ID_SIZE) == 0) + if (memcmp(client->public_key, zeroes_cid, crypto_box_PUBLICKEYBYTES) == 0) continue; printf("ClientID: "); @@ -139,7 +139,7 @@ void print_friendlist(DHT *dht) for (i = 0; i < MAX_FRIEND_CLIENTS; i++) { Client_data *client = &dht->friends_list[k].client_list[i]; - if (memcmp(client->public_key, zeroes_cid, CLIENT_ID_SIZE) == 0) + if (memcmp(client->public_key, zeroes_cid, crypto_box_PUBLICKEYBYTES) == 0) continue; printf("ClientID: "); diff --git a/toxcore/DHT.c b/toxcore/DHT.c index 467fff22..ae823302 100644 --- a/toxcore/DHT.c +++ b/toxcore/DHT.c @@ -919,7 +919,7 @@ static int getnodes(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const uint8_t plain_message[sizeof(Node_format) * 2] = {0}; Node_format receiver; - memcpy(receiver.public_key, public_key, CLIENT_ID_SIZE); + memcpy(receiver.public_key, public_key, crypto_box_PUBLICKEYBYTES); receiver.ip_port = ip_port; memcpy(plain_message, &receiver, sizeof(receiver)); @@ -935,12 +935,12 @@ static int getnodes(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const if (ping_id == 0) return -1; - uint8_t plain[CLIENT_ID_SIZE + sizeof(ping_id)]; + uint8_t plain[crypto_box_PUBLICKEYBYTES + sizeof(ping_id)]; uint8_t encrypt[sizeof(plain) + crypto_box_MACBYTES]; - uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(encrypt)]; + uint8_t data[1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + sizeof(encrypt)]; - memcpy(plain, client_id, CLIENT_ID_SIZE); - memcpy(plain + CLIENT_ID_SIZE, &ping_id, sizeof(ping_id)); + memcpy(plain, client_id, crypto_box_PUBLICKEYBYTES); + memcpy(plain + crypto_box_PUBLICKEYBYTES, &ping_id, sizeof(ping_id)); uint8_t shared_key[crypto_box_BEFORENMBYTES]; DHT_get_shared_key_sent(dht, shared_key, public_key); @@ -958,9 +958,9 @@ static int getnodes(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const return -1; data[0] = NET_PACKET_GET_NODES; - memcpy(data + 1, dht->self_public_key, CLIENT_ID_SIZE); - memcpy(data + 1 + CLIENT_ID_SIZE, nonce, crypto_box_NONCEBYTES); - memcpy(data + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, encrypt, len); + memcpy(data + 1, dht->self_public_key, crypto_box_PUBLICKEYBYTES); + memcpy(data + 1 + crypto_box_PUBLICKEYBYTES, nonce, crypto_box_NONCEBYTES); + memcpy(data + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, encrypt, len); return sendpacket(dht->net, ip_port, data, sizeof(data)); } @@ -977,7 +977,7 @@ static int sendnodes_ipv6(const DHT *dht, IP_Port ip_port, const uint8_t *public return -1; size_t Node_format_size = sizeof(Node_format); - uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + uint8_t data[1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + Node_format_size * MAX_SENT_NODES + length + crypto_box_MACBYTES]; Node_format nodes_list[MAX_SENT_NODES]; @@ -1008,16 +1008,17 @@ static int sendnodes_ipv6(const DHT *dht, IP_Port ip_port, const uint8_t *public return -1; data[0] = NET_PACKET_SEND_NODES_IPV6; - memcpy(data + 1, dht->self_public_key, CLIENT_ID_SIZE); - memcpy(data + 1 + CLIENT_ID_SIZE, nonce, crypto_box_NONCEBYTES); - memcpy(data + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, encrypt, len); + memcpy(data + 1, dht->self_public_key, crypto_box_PUBLICKEYBYTES); + memcpy(data + 1 + crypto_box_PUBLICKEYBYTES, nonce, crypto_box_NONCEBYTES); + memcpy(data + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, encrypt, len); - return sendpacket(dht->net, ip_port, data, 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + len); + return sendpacket(dht->net, ip_port, data, 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + len); } static int handle_getnodes(void *object, IP_Port source, const uint8_t *packet, uint16_t length) { - if (length != (1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + CLIENT_ID_SIZE + sizeof(uint64_t) + crypto_box_MACBYTES)) + if (length != (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + sizeof( + uint64_t) + crypto_box_MACBYTES)) return 1; DHT *dht = object; @@ -1026,20 +1027,20 @@ static int handle_getnodes(void *object, IP_Port source, const uint8_t *packet, if (id_equal(packet + 1, dht->self_public_key)) return 1; - uint8_t plain[CLIENT_ID_SIZE + sizeof(uint64_t)]; + uint8_t plain[crypto_box_PUBLICKEYBYTES + sizeof(uint64_t)]; uint8_t shared_key[crypto_box_BEFORENMBYTES]; DHT_get_shared_key_recv(dht, shared_key, packet + 1); int len = decrypt_data_symmetric( shared_key, - packet + 1 + CLIENT_ID_SIZE, - packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, - CLIENT_ID_SIZE + sizeof(uint64_t) + crypto_box_MACBYTES, + packet + 1 + crypto_box_PUBLICKEYBYTES, + packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, + crypto_box_PUBLICKEYBYTES + sizeof(uint64_t) + crypto_box_MACBYTES, plain ); - if (len != CLIENT_ID_SIZE + sizeof(uint64_t)) + if (len != crypto_box_PUBLICKEYBYTES + sizeof(uint64_t)) return 1; - sendnodes_ipv6(dht, source, packet + 1, plain, plain + CLIENT_ID_SIZE, sizeof(uint64_t), shared_key); + sendnodes_ipv6(dht, source, packet + 1, plain, plain + crypto_box_PUBLICKEYBYTES, sizeof(uint64_t), shared_key); add_to_ping(dht->ping, packet + 1, source); @@ -1077,7 +1078,7 @@ static int handle_sendnodes_core(void *object, IP_Port source, const uint8_t *pa Node_format *plain_nodes, uint16_t size_plain_nodes, uint32_t *num_nodes_out) { DHT *dht = object; - uint32_t cid_size = 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + 1 + sizeof(uint64_t) + crypto_box_MACBYTES; + uint32_t cid_size = 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + 1 + sizeof(uint64_t) + crypto_box_MACBYTES; if (length <= cid_size) /* too short */ return 1; @@ -1095,8 +1096,8 @@ static int handle_sendnodes_core(void *object, IP_Port source, const uint8_t *pa DHT_get_shared_key_sent(dht, shared_key, packet + 1); int len = decrypt_data_symmetric( shared_key, - packet + 1 + CLIENT_ID_SIZE, - packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, + packet + 1 + crypto_box_PUBLICKEYBYTES, + packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, 1 + data_size + sizeof(uint64_t) + crypto_box_MACBYTES, plain); @@ -1197,7 +1198,7 @@ int DHT_addfriend(DHT *dht, const uint8_t *public_key, void (*ip_callback)(void dht->friends_list = temp; DHT_Friend *friend = &dht->friends_list[dht->num_friends]; memset(friend, 0, sizeof(DHT_Friend)); - memcpy(friend->public_key, public_key, CLIENT_ID_SIZE); + memcpy(friend->public_key, public_key, crypto_box_PUBLICKEYBYTES); friend->nat.NATping_id = random_64b(); ++dht->num_friends; @@ -1893,10 +1894,10 @@ static int send_hardening_req(DHT *dht, Node_format *sendto, uint8_t type, uint8 /* Send a get node hardening request */ static int send_hardening_getnode_req(DHT *dht, Node_format *dest, Node_format *node_totest, uint8_t *search_id) { - uint8_t data[sizeof(Node_format) + CLIENT_ID_SIZE]; + uint8_t data[sizeof(Node_format) + crypto_box_PUBLICKEYBYTES]; memcpy(data, node_totest, sizeof(Node_format)); - memcpy(data + sizeof(Node_format), search_id, CLIENT_ID_SIZE); - return send_hardening_req(dht, dest, CHECK_TYPE_GETNODE_REQ, data, sizeof(Node_format) + CLIENT_ID_SIZE); + memcpy(data + sizeof(Node_format), search_id, crypto_box_PUBLICKEYBYTES); + return send_hardening_req(dht, dest, CHECK_TYPE_GETNODE_REQ, data, sizeof(Node_format) + crypto_box_PUBLICKEYBYTES); } /* Send a get node hardening response */ @@ -1907,10 +1908,10 @@ static int send_hardening_getnode_res(const DHT *dht, const Node_format *sendto, return -1; uint8_t packet[MAX_CRYPTO_REQUEST_SIZE]; - uint8_t data[1 + CLIENT_ID_SIZE + nodes_data_length]; + uint8_t data[1 + crypto_box_PUBLICKEYBYTES + nodes_data_length]; data[0] = CHECK_TYPE_GETNODE_RES; - memcpy(data + 1, queried_client_id, CLIENT_ID_SIZE); - memcpy(data + 1 + CLIENT_ID_SIZE, nodes_data, nodes_data_length); + memcpy(data + 1, queried_client_id, crypto_box_PUBLICKEYBYTES); + memcpy(data + 1 + crypto_box_PUBLICKEYBYTES, nodes_data, nodes_data_length); int len = create_request(dht->self_public_key, dht->self_secret_key, packet, sendto->public_key, data, sizeof(data), CRYPTO_PACKET_HARDENING); @@ -1926,7 +1927,7 @@ static IPPTsPng *get_closelist_IPPTsPng(DHT *dht, const uint8_t *public_key, sa_ uint32_t i; for (i = 0; i < LCLIENT_LIST; ++i) { - if (memcmp(dht->close_clientlist[i].public_key, public_key, CLIENT_ID_SIZE) != 0) + if (memcmp(dht->close_clientlist[i].public_key, public_key, crypto_box_PUBLICKEYBYTES) != 0) continue; if (sa_family == AF_INET) @@ -1996,15 +1997,15 @@ static int handle_hardening(void *object, IP_Port source, const uint8_t *source_ } case CHECK_TYPE_GETNODE_RES: { - if (length <= CLIENT_ID_SIZE + 1) + if (length <= crypto_box_PUBLICKEYBYTES + 1) return 1; - if (length > 1 + CLIENT_ID_SIZE + sizeof(Node_format) * MAX_SENT_NODES) + if (length > 1 + crypto_box_PUBLICKEYBYTES + sizeof(Node_format) * MAX_SENT_NODES) return 1; - uint16_t length_nodes = length - 1 - CLIENT_ID_SIZE; + uint16_t length_nodes = length - 1 - crypto_box_PUBLICKEYBYTES; Node_format nodes[MAX_SENT_NODES]; - int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, 0, packet + 1 + CLIENT_ID_SIZE, length_nodes, 0); + int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, 0, packet + 1 + crypto_box_PUBLICKEYBYTES, length_nodes, 0); /* TODO: MAX_SENT_NODES nodes should be returned at all times (right now we have a small network size so it could cause problems for testing and etc..) */ @@ -2023,7 +2024,7 @@ static int handle_hardening(void *object, IP_Port source, const uint8_t *source_ if (is_timeout(temp->hardening.send_nodes_timestamp, HARDENING_INTERVAL)) return 1; - if (memcmp(temp->hardening.send_nodes_pingedid, source_pubkey, CLIENT_ID_SIZE) != 0) + if (memcmp(temp->hardening.send_nodes_pingedid, source_pubkey, crypto_box_PUBLICKEYBYTES) != 0) return 1; /* If Nodes look good and the request checks out */ @@ -2040,10 +2041,10 @@ static int handle_hardening(void *object, IP_Port source, const uint8_t *source_ */ Node_format random_node(DHT *dht, sa_family_t sa_family) { - uint8_t id[CLIENT_ID_SIZE]; + uint8_t id[crypto_box_PUBLICKEYBYTES]; uint32_t i; - for (i = 0; i < CLIENT_ID_SIZE / 4; ++i) { /* populate the id with pseudorandom bytes.*/ + for (i = 0; i < crypto_box_PUBLICKEYBYTES / 4; ++i) { /* populate the id with pseudorandom bytes.*/ uint32_t t = rand(); memcpy(id + i * sizeof(t), &t, sizeof(t)); } @@ -2086,7 +2087,7 @@ uint16_t closelist_nodes(DHT *dht, Node_format *nodes, uint16_t max_num) } if (assoc != NULL) { - memcpy(nodes[count].public_key, list[i - 1].public_key, CLIENT_ID_SIZE); + memcpy(nodes[count].public_key, list[i - 1].public_key, crypto_box_PUBLICKEYBYTES); nodes[count].ip_port = assoc->ip_port; ++count; @@ -2230,7 +2231,7 @@ DHT *new_DHT(Networking_Core *net) uint32_t i; for (i = 0; i < DHT_FAKE_FRIEND_NUMBER; ++i) { - uint8_t random_key_bytes[CLIENT_ID_SIZE]; + uint8_t random_key_bytes[crypto_box_PUBLICKEYBYTES]; randombytes(random_key_bytes, sizeof(random_key_bytes)); DHT_addfriend(dht, random_key_bytes, 0, 0, 0, 0); } diff --git a/toxcore/DHT.h b/toxcore/DHT.h index a36ea252..50ab92dc 100644 --- a/toxcore/DHT.h +++ b/toxcore/DHT.h @@ -28,9 +28,6 @@ #include "network.h" #include "ping_array.h" -/* Size of the client_id in bytes. */ -#define CLIENT_ID_SIZE crypto_box_PUBLICKEYBYTES - /* Maximum number of clients stored per friend. */ #define MAX_FRIEND_CLIENTS 8 @@ -79,17 +76,17 @@ typedef struct { uint8_t routes_requests_ok; /* Time which we last checked this.*/ uint64_t routes_requests_timestamp; - uint8_t routes_requests_pingedid[CLIENT_ID_SIZE]; + uint8_t routes_requests_pingedid[crypto_box_PUBLICKEYBYTES]; /* Node sends correct send_node (true (1) or false/didn't check (0)) */ uint8_t send_nodes_ok; /* Time which we last checked this.*/ uint64_t send_nodes_timestamp; - uint8_t send_nodes_pingedid[CLIENT_ID_SIZE]; + uint8_t send_nodes_pingedid[crypto_box_PUBLICKEYBYTES]; /* Node can be used to test other nodes (true (1) or false/didn't check (0)) */ uint8_t testing_requests; /* Time which we last checked this.*/ uint64_t testing_timestamp; - uint8_t testing_pingedid[CLIENT_ID_SIZE]; + uint8_t testing_pingedid[crypto_box_PUBLICKEYBYTES]; } Hardening; typedef struct { diff --git a/toxcore/assoc.c b/toxcore/assoc.c index 553f4339..44c4cc30 100644 --- a/toxcore/assoc.c +++ b/toxcore/assoc.c @@ -87,7 +87,7 @@ typedef struct candidates_bucket { struct Assoc { hash_t self_hash; /* hash of self_client_id */ - uint8_t self_client_id[CLIENT_ID_SIZE]; /* don't store entries for this */ + uint8_t self_client_id[crypto_box_PUBLICKEYBYTES]; /* don't store entries for this */ /* association centralization: clients not in use */ size_t candidates_bucket_bits; @@ -101,7 +101,7 @@ struct Assoc { /* HELPER FUNCTIONS */ /*****************************************************************************/ -/* the complete distance would be CLIENT_ID_SIZE long... +/* the complete distance would be crypto_box_PUBLICKEYBYTES long... * returns DISTANCE_INDEX_DISTANCE_BITS valid bits */ static uint64_t id_distance(const Assoc *assoc, void *callback_data, const uint8_t *id_ref, const uint8_t *id_test) { @@ -200,7 +200,7 @@ static hash_t id_hash(const Assoc *assoc, const uint8_t *id) { uint32_t i, res = 0x19a64e82; - for (i = 0; i < CLIENT_ID_SIZE; i++) + for (i = 0; i < crypto_box_PUBLICKEYBYTES; i++) res = ((res << 1) ^ id[i]) + (res >> 31); /* can't have zero as hash, a) marks an unused spot, @@ -976,11 +976,11 @@ void kill_Assoc(Assoc *assoc) #ifdef LOGGING -static char buffer[CLIENT_ID_SIZE * 2 + 1]; +static char buffer[crypto_box_PUBLICKEYBYTES * 2 + 1]; static char *idpart2str(uint8_t *id, size_t len) { - if (len > CLIENT_ID_SIZE) - len = CLIENT_ID_SIZE; + if (len > crypto_box_PUBLICKEYBYTES) + len = crypto_box_PUBLICKEYBYTES; size_t i; diff --git a/toxcore/ping.c b/toxcore/ping.c index 543ceec5..877aaca2 100644 --- a/toxcore/ping.c +++ b/toxcore/ping.c @@ -55,8 +55,8 @@ struct PING { #define PING_PLAIN_SIZE (1 + sizeof(uint64_t)) -#define DHT_PING_SIZE (1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + PING_PLAIN_SIZE + crypto_box_MACBYTES) -#define PING_DATA_SIZE (CLIENT_ID_SIZE + sizeof(IP_Port)) +#define DHT_PING_SIZE (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + PING_PLAIN_SIZE + crypto_box_MACBYTES) +#define PING_DATA_SIZE (crypto_box_PUBLICKEYBYTES + sizeof(IP_Port)) int send_ping_request(PING *ping, IP_Port ipp, const uint8_t *public_key) { @@ -74,7 +74,7 @@ int send_ping_request(PING *ping, IP_Port ipp, const uint8_t *public_key) // Generate random ping_id. uint8_t data[PING_DATA_SIZE]; id_copy(data, public_key); - memcpy(data + CLIENT_ID_SIZE, &ipp, sizeof(IP_Port)); + memcpy(data + crypto_box_PUBLICKEYBYTES, &ipp, sizeof(IP_Port)); ping_id = ping_array_add(&ping->ping_array, data, sizeof(data)); if (ping_id == 0) @@ -86,13 +86,13 @@ int send_ping_request(PING *ping, IP_Port ipp, const uint8_t *public_key) pk[0] = NET_PACKET_PING_REQUEST; id_copy(pk + 1, ping->dht->self_public_key); // Our pubkey - new_nonce(pk + 1 + CLIENT_ID_SIZE); // Generate new nonce + new_nonce(pk + 1 + crypto_box_PUBLICKEYBYTES); // Generate new nonce rc = encrypt_data_symmetric(shared_key, - pk + 1 + CLIENT_ID_SIZE, + pk + 1 + crypto_box_PUBLICKEYBYTES, ping_plain, sizeof(ping_plain), - pk + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES); + pk + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES); if (rc != PING_PLAIN_SIZE + crypto_box_MACBYTES) return 1; @@ -115,13 +115,13 @@ static int send_ping_response(PING *ping, IP_Port ipp, const uint8_t *public_key pk[0] = NET_PACKET_PING_RESPONSE; id_copy(pk + 1, ping->dht->self_public_key); // Our pubkey - new_nonce(pk + 1 + CLIENT_ID_SIZE); // Generate new nonce + new_nonce(pk + 1 + crypto_box_PUBLICKEYBYTES); // Generate new nonce // Encrypt ping_id using recipient privkey rc = encrypt_data_symmetric(shared_encryption_key, - pk + 1 + CLIENT_ID_SIZE, + pk + 1 + crypto_box_PUBLICKEYBYTES, ping_plain, sizeof(ping_plain), - pk + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES ); + pk + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES ); if (rc != PING_PLAIN_SIZE + crypto_box_MACBYTES) return 1; @@ -148,8 +148,8 @@ static int handle_ping_request(void *_dht, IP_Port source, const uint8_t *packet // Decrypt ping_id DHT_get_shared_key_recv(dht, shared_key, packet + 1); rc = decrypt_data_symmetric(shared_key, - packet + 1 + CLIENT_ID_SIZE, - packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, + packet + 1 + crypto_box_PUBLICKEYBYTES, + packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, PING_PLAIN_SIZE + crypto_box_MACBYTES, ping_plain ); @@ -189,8 +189,8 @@ static int handle_ping_response(void *_dht, IP_Port source, const uint8_t *packe uint8_t ping_plain[PING_PLAIN_SIZE]; // Decrypt ping_id rc = decrypt_data_symmetric(shared_key, - packet + 1 + CLIENT_ID_SIZE, - packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, + packet + 1 + crypto_box_PUBLICKEYBYTES, + packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, PING_PLAIN_SIZE + crypto_box_MACBYTES, ping_plain); @@ -211,7 +211,7 @@ static int handle_ping_response(void *_dht, IP_Port source, const uint8_t *packe return 1; IP_Port ipp; - memcpy(&ipp, data + CLIENT_ID_SIZE, sizeof(IP_Port)); + memcpy(&ipp, data + crypto_box_PUBLICKEYBYTES, sizeof(IP_Port)); if (!ipport_equal(&ipp, &source)) return 1; @@ -269,12 +269,12 @@ int add_to_ping(PING *ping, const uint8_t *public_key, IP_Port ip_port) for (i = 0; i < MAX_TO_PING; ++i) { if (!ip_isset(&ping->to_ping[i].ip_port.ip)) { - memcpy(ping->to_ping[i].public_key, public_key, CLIENT_ID_SIZE); + memcpy(ping->to_ping[i].public_key, public_key, crypto_box_PUBLICKEYBYTES); ipport_copy(&ping->to_ping[i].ip_port, &ip_port); return 0; } - if (memcmp(ping->to_ping[i].public_key, public_key, CLIENT_ID_SIZE) == 0) { + if (memcmp(ping->to_ping[i].public_key, public_key, crypto_box_PUBLICKEYBYTES) == 0) { return -1; } } @@ -283,7 +283,7 @@ int add_to_ping(PING *ping, const uint8_t *public_key, IP_Port ip_port) for (i = 0; i < MAX_TO_PING; ++i) { if (id_closest(ping->dht->self_public_key, ping->to_ping[(i + r) % MAX_TO_PING].public_key, public_key) == 2) { - memcpy(ping->to_ping[(i + r) % MAX_TO_PING].public_key, public_key, CLIENT_ID_SIZE); + memcpy(ping->to_ping[(i + r) % MAX_TO_PING].public_key, public_key, crypto_box_PUBLICKEYBYTES); ipport_copy(&ping->to_ping[(i + r) % MAX_TO_PING].ip_port, &ip_port); return 0; } diff --git a/toxcore/util.c b/toxcore/util.c index 5caf5855..c320cdc4 100644 --- a/toxcore/util.c +++ b/toxcore/util.c @@ -28,8 +28,8 @@ #include -/* for CLIENT_ID_SIZE */ -#include "DHT.h" +/* for crypto_box_PUBLICKEYBYTES */ +#include "crypto_core.h" #include "util.h" @@ -60,13 +60,13 @@ int is_timeout(uint64_t timestamp, uint64_t timeout) /* id functions */ bool id_equal(const uint8_t *dest, const uint8_t *src) { - return memcmp(dest, src, CLIENT_ID_SIZE) == 0; + return memcmp(dest, src, crypto_box_PUBLICKEYBYTES) == 0; } uint32_t id_copy(uint8_t *dest, const uint8_t *src) { - memcpy(dest, src, CLIENT_ID_SIZE); - return CLIENT_ID_SIZE; + memcpy(dest, src, crypto_box_PUBLICKEYBYTES); + return crypto_box_PUBLICKEYBYTES; } void host_to_net(uint8_t *num, uint16_t numbytes)