StarMirror/toxcore
1
0
Fork 0
mirror of https://github.com/irungentoo/toxcore.git synced 2024-03-22 13:30:51 +08:00
Code Issues Projects Releases Wiki Activity

Reduced size of get_node packets.

Browse Source 
Sendback data is now 8 bytes.

This does not break the network as the sendback data can be any
size between 1 and 150 bytes.
This commit is contained in:
irungentoo 2014-05-28 17:59:48 -04:00
parent e9d8eddf26
commit d87c772a7e
No known key found for this signature in database
GPG Key ID: 10349DC9BED89E98
2 changed files with 48 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
toxcore/DHT.c
View File

@ -967,51 +967,45 @@ static int getnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *cli
if (id_equal(public_key, dht->self_public_key)) if (id_equal(public_key, dht->self_public_key))
return -1; return -1;
uint8_t plain_message[NODES_ENCRYPTED_MESSAGE_LENGTH] = {0}; uint8_t plain_message[sizeof(Node_format) * 2] = {0};
uint8_t encrypted_message[NODES_ENCRYPTED_MESSAGE_LENGTH];
uint8_t nonce[crypto_box_NONCEBYTES];
new_nonce(nonce);
memcpy(encrypted_message, nonce, crypto_box_NONCEBYTES);
uint64_t temp_time = unix_time();
memcpy(plain_message, &temp_time, sizeof(temp_time));
Node_format receiver; Node_format receiver;
memcpy(receiver.client_id, public_key, CLIENT_ID_SIZE); memcpy(receiver.client_id, public_key, CLIENT_ID_SIZE);
receiver.ip_port = ip_port; receiver.ip_port = ip_port;
memcpy(plain_message + sizeof(temp_time), &receiver, sizeof(receiver)); memcpy(plain_message, &receiver, sizeof(receiver));
if (sendback_node != NULL) uint64_t ping_id = 0;
memcpy(plain_message + sizeof(temp_time) + sizeof(receiver), sendback_node, sizeof(Node_format));
else
memset(plain_message + sizeof(temp_time) + sizeof(receiver), 0, sizeof(Node_format));
int len_m = encrypt_data_symmetric(dht->secret_symmetric_key, if (sendback_node != NULL) {
nonce, memcpy(plain_message + sizeof(receiver), sendback_node, sizeof(Node_format));
plain_message, ping_id = ping_array_add(&dht->dht_harden_ping_array, plain_message, sizeof(plain_message));
sizeof(temp_time) + sizeof(receiver) + sizeof(Node_format), } else {
encrypted_message + crypto_box_NONCEBYTES); ping_id = ping_array_add(&dht->dht_ping_array, plain_message, sizeof(receiver));
}
if (len_m != NODES_ENCRYPTED_MESSAGE_LENGTH - crypto_box_NONCEBYTES) if (ping_id == 0)
return -1; return -1;
uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES]; uint8_t plain[CLIENT_ID_SIZE + sizeof(ping_id)];
uint8_t plain[CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH]; uint8_t encrypt[sizeof(plain) + crypto_box_MACBYTES];
uint8_t encrypt[CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES]; uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(encrypt)];
memcpy(plain, client_id, CLIENT_ID_SIZE); memcpy(plain, client_id, CLIENT_ID_SIZE);
memcpy(plain + CLIENT_ID_SIZE, encrypted_message, NODES_ENCRYPTED_MESSAGE_LENGTH); memcpy(plain + CLIENT_ID_SIZE, &ping_id, sizeof(ping_id));
uint8_t shared_key[crypto_box_BEFORENMBYTES]; uint8_t shared_key[crypto_box_BEFORENMBYTES];
DHT_get_shared_key_sent(dht, shared_key, public_key); DHT_get_shared_key_sent(dht, shared_key, public_key);
uint8_t nonce[crypto_box_NONCEBYTES];
new_nonce(nonce);
int len = encrypt_data_symmetric( shared_key, int len = encrypt_data_symmetric( shared_key,
nonce, nonce,
plain, plain,
CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH, sizeof(plain),
encrypt ); encrypt );
if (len != CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES) if (len != sizeof(encrypt))
return -1; return -1;
data[0] = NET_PACKET_GET_NODES; data[0] = NET_PACKET_GET_NODES;
@ -1110,32 +1104,26 @@ static int handle_getnodes(void *object, IP_Port source, uint8_t *packet, uint32
return 0; return 0;
} }
/* return 0 if no /* return 0 if no
return 1 if yes return 1 if yes */
encrypted_data must be of size NODES_ENCRYPTED_MESSAGE_LENGTH*/ static uint8_t sent_getnode_to_node(DHT *dht, uint8_t *client_id, IP_Port node_ip_port, uint64_t ping_id,
static uint8_t sent_getnode_to_node(DHT *dht, uint8_t *client_id, IP_Port node_ip_port, uint8_t *encrypted_data,
Node_format *sendback_node) Node_format *sendback_node)
{ {
uint8_t plain_message[NODES_ENCRYPTED_MESSAGE_LENGTH]; uint8_t data[sizeof(Node_format) * 2];
if (decrypt_data_symmetric(dht->secret_symmetric_key, encrypted_data, encrypted_data + crypto_box_NONCEBYTES, if (ping_array_check(data, sizeof(data), &dht->dht_ping_array, ping_id) == sizeof(Node_format)) {
NODES_ENCRYPTED_MESSAGE_LENGTH - crypto_box_NONCEBYTES, memset(sendback_node, 0, sizeof(Node_format));
plain_message) != sizeof(uint64_t) + sizeof(Node_format) * 2) } else if (ping_array_check(data, sizeof(data), &dht->dht_harden_ping_array, ping_id) == sizeof(data)) {
return 0; memcpy(sendback_node, data + sizeof(Node_format), sizeof(Node_format));
} else {
uint64_t comp_time;
memcpy(&comp_time, plain_message, sizeof(uint64_t));
uint64_t temp_time = unix_time();
if (comp_time + PING_TIMEOUT < temp_time || temp_time < comp_time)
return 0; return 0;
}
Node_format test; Node_format test;
memcpy(&test, plain_message + sizeof(uint64_t), sizeof(Node_format)); memcpy(&test, data, sizeof(Node_format));
if (!ipport_equal(&test.ip_port, &node_ip_port) || memcmp(test.client_id, client_id, CLIENT_ID_SIZE) != 0) if (!ipport_equal(&test.ip_port, &node_ip_port) || memcmp(test.client_id, client_id, CLIENT_ID_SIZE) != 0)
return 0; return 0;
memcpy(sendback_node, plain_message + sizeof(uint64_t) + sizeof(Node_format), sizeof(Node_format));
return 1; return 1;
} }
@ -1147,8 +1135,7 @@ static int handle_sendnodes_core(void *object, IP_Port source, uint8_t *packet,
Node_format *plain_nodes, uint16_t size_plain_nodes, uint32_t *num_nodes_out) Node_format *plain_nodes, uint16_t size_plain_nodes, uint32_t *num_nodes_out)
{ {
DHT *dht = object; DHT *dht = object;
uint32_t cid_size = 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + 1 + NODES_ENCRYPTED_MESSAGE_LENGTH + uint32_t cid_size = 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + 1 + sizeof(uint64_t) + crypto_box_MACBYTES;
crypto_box_MACBYTES;
if (length <= cid_size) /* too short */ if (length <= cid_size) /* too short */
return 1; return 1;
@ -1161,14 +1148,14 @@ static int handle_sendnodes_core(void *object, IP_Port source, uint8_t *packet,
if (data_size > sizeof(Node_format) * MAX_SENT_NODES) /* invalid length */ if (data_size > sizeof(Node_format) * MAX_SENT_NODES) /* invalid length */
return 1; return 1;
uint8_t plain[1 + data_size + NODES_ENCRYPTED_MESSAGE_LENGTH]; uint8_t plain[1 + data_size + sizeof(uint64_t)];
uint8_t shared_key[crypto_box_BEFORENMBYTES]; uint8_t shared_key[crypto_box_BEFORENMBYTES];
DHT_get_shared_key_sent(dht, shared_key, packet + 1); DHT_get_shared_key_sent(dht, shared_key, packet + 1);
int len = decrypt_data_symmetric( int len = decrypt_data_symmetric(
shared_key, shared_key,
packet + 1 + CLIENT_ID_SIZE, packet + 1 + CLIENT_ID_SIZE,
packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
1 + data_size + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES, 1 + data_size + sizeof(uint64_t) + crypto_box_MACBYTES,
plain); plain);
if ((unsigned int)len != sizeof(plain)) if ((unsigned int)len != sizeof(plain))
@ -1179,7 +1166,10 @@ static int handle_sendnodes_core(void *object, IP_Port source, uint8_t *packet,
Node_format sendback_node; Node_format sendback_node;
if (!sent_getnode_to_node(dht, packet + 1, source, plain + 1 + data_size, &sendback_node)) uint64_t ping_id;
memcpy(&ping_id, plain + 1 + data_size, sizeof(ping_id));
if (!sent_getnode_to_node(dht, packet + 1, source, ping_id, &sendback_node))
return 1; return 1;
uint16_t length_nodes = 0; uint16_t length_nodes = 0;
@ -2368,6 +2358,9 @@ DHT *new_DHT(Networking_Core *net)
new_symmetric_key(dht->secret_symmetric_key); new_symmetric_key(dht->secret_symmetric_key);
crypto_box_keypair(dht->self_public_key, dht->self_secret_key); crypto_box_keypair(dht->self_public_key, dht->self_secret_key);
ping_array_init(&dht->dht_ping_array, DHT_PING_ARRAY_SIZE, PING_TIMEOUT);
ping_array_init(&dht->dht_harden_ping_array, DHT_PING_ARRAY_SIZE, PING_TIMEOUT);
#ifdef ENABLE_ASSOC_DHT #ifdef ENABLE_ASSOC_DHT
dht->assoc = new_Assoc_default(dht->self_public_key); dht->assoc = new_Assoc_default(dht->self_public_key);
#endif #endif
@ -2413,6 +2406,8 @@ void kill_DHT(DHT *dht)
networking_registerhandler(dht->net, NET_PACKET_SEND_NODES_IPV6, NULL, NULL); networking_registerhandler(dht->net, NET_PACKET_SEND_NODES_IPV6, NULL, NULL);
cryptopacket_registerhandler(dht, CRYPTO_PACKET_NAT_PING, NULL, NULL); cryptopacket_registerhandler(dht, CRYPTO_PACKET_NAT_PING, NULL, NULL);
cryptopacket_registerhandler(dht, CRYPTO_PACKET_HARDENING, NULL, NULL); cryptopacket_registerhandler(dht, CRYPTO_PACKET_HARDENING, NULL, NULL);
ping_array_free_all(&dht->dht_ping_array);
ping_array_free_all(&dht->dht_harden_ping_array);
kill_ping(dht->ping); kill_ping(dht->ping);
free(dht->friends_list); free(dht->friends_list);
free(dht); free(dht);

6
toxcore/DHT.h
View File

@ -26,6 +26,7 @@
#include "crypto_core.h" #include "crypto_core.h"
#include "network.h" #include "network.h"
#include "ping_array.h"
/* Size of the client_id in bytes. */ /* Size of the client_id in bytes. */
#define CLIENT_ID_SIZE crypto_box_PUBLICKEYBYTES #define CLIENT_ID_SIZE crypto_box_PUBLICKEYBYTES
@ -42,6 +43,9 @@
/* Ping timeout in seconds */ /* Ping timeout in seconds */
#define PING_TIMEOUT 3 #define PING_TIMEOUT 3
/* size of DHT ping arrays. */
#define DHT_PING_ARRAY_SIZE 512
/* Ping interval in seconds for each node in our lists. */ /* Ping interval in seconds for each node in our lists. */
#define PING_INTERVAL 60 #define PING_INTERVAL 60
@ -200,6 +204,8 @@ typedef struct {
Shared_Keys shared_keys_sent; Shared_Keys shared_keys_sent;
struct PING *ping; struct PING *ping;
Ping_Array dht_ping_array;
Ping_Array dht_harden_ping_array;
#ifdef ENABLE_ASSOC_DHT #ifdef ENABLE_ASSOC_DHT
struct Assoc *assoc; struct Assoc *assoc;
#endif #endif