1 files changed, 92 insertions, 82 deletions

diff --git a/toxcore/onion.c b/toxcore/onion.c
index ccb729f3..479c6209 100644
--- a/toxcore/onion.c
+++ b/toxcore/onion.c
@@ -26,8 +26,6 @@
 #include "onion.h"
 #include "util.h"
 
-#define MAX_ONION_SIZE MAX_DATA_SIZE
-
 #define RETURN_1 ONION_RETURN_1
 #define RETURN_2 ONION_RETURN_2
 #define RETURN_3 ONION_RETURN_3
@@ -89,41 +87,43 @@ int create_onion_path(DHT *dht, Onion_Path *new_path, Node_format *nodes)
 /* Create and send a onion packet.
  *
  * Use Onion_Path path to send data of length to dest.
+ * Maximum length of data is ONION_MAX_DATA_SIZE.
  *
  * return -1 on failure.
  * return 0 on success.
  */
 int send_onion_packet(Networking_Core *net, Onion_Path *path, IP_Port dest, uint8_t *data, uint32_t length)
 {
-    if (1 + length + SEND_1 > MAX_ONION_SIZE || length == 0)
+    if (1 + length + SEND_1 > ONION_MAX_PACKET_SIZE || length == 0)
         return -1;
 
     to_net_family(&dest.ip);
-    uint8_t step1[sizeof(IP_Port) + length];
+    uint8_t step1[SIZE_IPPORT + length];
+
 
-    memcpy(step1, &dest, sizeof(IP_Port));
-    memcpy(step1 + sizeof(IP_Port), data, length);
+    ipport_pack(step1, &dest);
+    memcpy(step1 + SIZE_IPPORT, data, length);
 
     uint8_t nonce[crypto_box_NONCEBYTES];
     random_nonce(nonce);
 
-    uint8_t step2[sizeof(IP_Port) + SEND_BASE + length];
-    memcpy(step2, &path->ip_port3, sizeof(IP_Port));
-    memcpy(step2 + sizeof(IP_Port), path->public_key3, crypto_box_PUBLICKEYBYTES);
+    uint8_t step2[SIZE_IPPORT + SEND_BASE + length];
+    ipport_pack(step2, &path->ip_port3);
+    memcpy(step2 + SIZE_IPPORT, path->public_key3, crypto_box_PUBLICKEYBYTES);
 
-    int len = encrypt_data_fast(path->shared_key3, nonce, step1, sizeof(step1),
-                                step2 + sizeof(IP_Port) + crypto_box_PUBLICKEYBYTES);
+    int len = encrypt_data_symmetric(path->shared_key3, nonce, step1, sizeof(step1),
+                                     step2 + SIZE_IPPORT + crypto_box_PUBLICKEYBYTES);
 
-    if ((uint32_t)len != sizeof(IP_Port) + length + crypto_box_MACBYTES)
+    if ((uint32_t)len != SIZE_IPPORT + length + crypto_box_MACBYTES)
         return -1;
 
-    uint8_t step3[sizeof(IP_Port) + SEND_BASE * 2 + length];
-    memcpy(step3, &path->ip_port2, sizeof(IP_Port));
-    memcpy(step3 + sizeof(IP_Port), path->public_key2, crypto_box_PUBLICKEYBYTES);
-    len = encrypt_data_fast(path->shared_key2, nonce, step2, sizeof(step2),
-                            step3 + sizeof(IP_Port) + crypto_box_PUBLICKEYBYTES);
+    uint8_t step3[SIZE_IPPORT + SEND_BASE * 2 + length];
+    ipport_pack(step3, &path->ip_port2);
+    memcpy(step3 + SIZE_IPPORT, path->public_key2, crypto_box_PUBLICKEYBYTES);
+    len = encrypt_data_symmetric(path->shared_key2, nonce, step2, sizeof(step2),
+                                 step3 + SIZE_IPPORT + crypto_box_PUBLICKEYBYTES);
 
-    if ((uint32_t)len != sizeof(IP_Port) + SEND_BASE + length + crypto_box_MACBYTES)
+    if ((uint32_t)len != SIZE_IPPORT + SEND_BASE + length + crypto_box_MACBYTES)
         return -1;
 
     uint8_t packet[1 + length + SEND_1];
@@ -131,10 +131,10 @@ int send_onion_packet(Networking_Core *net, Onion_Path *path, IP_Port dest, uint
     memcpy(packet + 1, nonce, crypto_box_NONCEBYTES);
     memcpy(packet + 1 + crypto_box_NONCEBYTES, path->public_key1, crypto_box_PUBLICKEYBYTES);
 
-    len = encrypt_data_fast(path->shared_key1, nonce, step3, sizeof(step3),
-                            packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES);
+    len = encrypt_data_symmetric(path->shared_key1, nonce, step3, sizeof(step3),
+                                 packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES);
 
-    if ((uint32_t)len != sizeof(IP_Port) + SEND_BASE * 2 + length + crypto_box_MACBYTES)
+    if ((uint32_t)len != SIZE_IPPORT + SEND_BASE * 2 + length + crypto_box_MACBYTES)
         return -1;
 
     if ((uint32_t)sendpacket(net, path->ip_port1, packet, sizeof(packet)) != sizeof(packet))
@@ -142,13 +142,18 @@ int send_onion_packet(Networking_Core *net, Onion_Path *path, IP_Port dest, uint
 
     return 0;
 }
+
 /* Create and send a onion response sent initially to dest with.
+ * Maximum length of data is ONION_RESPONSE_MAX_DATA_SIZE.
  *
  * return -1 on failure.
  * return 0 on success.
  */
 int send_onion_response(Networking_Core *net, IP_Port dest, uint8_t *data, uint32_t length, uint8_t *ret)
 {
+    if (length > ONION_RESPONSE_MAX_DATA_SIZE || length == 0)
+        return -1;
+
     uint8_t packet[1 + RETURN_3 + length];
     packet[0] = NET_PACKET_ONION_RECV_3;
     memcpy(packet + 1, ret, RETURN_3);
@@ -164,7 +169,7 @@ static int handle_send_initial(void *object, IP_Port source, uint8_t *packet, ui
 {
     Onion *onion = object;
 
-    if (length > MAX_ONION_SIZE)
+    if (length > ONION_MAX_PACKET_SIZE)
         return 1;
 
     if (length <= 1 + SEND_1)
@@ -172,11 +177,11 @@ static int handle_send_initial(void *object, IP_Port source, uint8_t *packet, ui
 
     change_symmetric_key(onion);
 
-    uint8_t plain[MAX_ONION_SIZE];
+    uint8_t plain[ONION_MAX_PACKET_SIZE];
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
     get_shared_key(&onion->shared_keys_1, shared_key, onion->dht->self_secret_key, packet + 1 + crypto_box_NONCEBYTES);
-    int len = decrypt_data_fast(shared_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
-                                length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES), plain);
+    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
+                                     length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES), plain);
 
     if ((uint32_t)len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES))
         return 1;
@@ -187,23 +192,26 @@ static int handle_send_initial(void *object, IP_Port source, uint8_t *packet, ui
 int onion_send_1(Onion *onion, uint8_t *plain, uint32_t len, IP_Port source, uint8_t *nonce)
 {
     IP_Port send_to;
-    memcpy(&send_to, plain, sizeof(IP_Port));
+    ipport_unpack(&send_to, plain);
     to_host_family(&send_to.ip);
 
-    uint8_t data[MAX_ONION_SIZE];
+    uint8_t ip_port[SIZE_IPPORT];
+    ipport_pack(ip_port, &source);
+
+    uint8_t data[ONION_MAX_PACKET_SIZE];
     data[0] = NET_PACKET_ONION_SEND_1;
     memcpy(data + 1, nonce, crypto_box_NONCEBYTES);
-    memcpy(data + 1 + crypto_box_NONCEBYTES, plain + sizeof(IP_Port), len - sizeof(IP_Port));
-    uint32_t data_len = 1 + crypto_box_NONCEBYTES + (len - sizeof(IP_Port));
+    memcpy(data + 1 + crypto_box_NONCEBYTES, plain + SIZE_IPPORT, len - SIZE_IPPORT);
+    uint32_t data_len = 1 + crypto_box_NONCEBYTES + (len - SIZE_IPPORT);
     uint8_t *ret_part = data + data_len;
     new_nonce(ret_part);
-    len = encrypt_data_symmetric(onion->secret_symmetric_key, ret_part, (uint8_t *)&source, sizeof(IP_Port),
-                                 ret_part + crypto_secretbox_NONCEBYTES);
+    len = encrypt_data_symmetric(onion->secret_symmetric_key, ret_part, ip_port, SIZE_IPPORT,
+                                 ret_part + crypto_box_NONCEBYTES);
 
-    if (len != sizeof(IP_Port) + crypto_secretbox_MACBYTES)
+    if (len != SIZE_IPPORT + crypto_box_MACBYTES)
         return 1;
 
-    data_len += crypto_secretbox_NONCEBYTES + len;
+    data_len += crypto_box_NONCEBYTES + len;
 
     if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len)
         return 1;
@@ -215,7 +223,7 @@ static int handle_send_1(void *object, IP_Port source, uint8_t *packet, uint32_t
 {
     Onion *onion = object;
 
-    if (length > MAX_ONION_SIZE)
+    if (length > ONION_MAX_PACKET_SIZE)
         return 1;
 
     if (length <= 1 + SEND_2)
@@ -223,36 +231,36 @@ static int handle_send_1(void *object, IP_Port source, uint8_t *packet, uint32_t
 
     change_symmetric_key(onion);
 
-    uint8_t plain[MAX_ONION_SIZE];
+    uint8_t plain[ONION_MAX_PACKET_SIZE];
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
     get_shared_key(&onion->shared_keys_2, shared_key, onion->dht->self_secret_key, packet + 1 + crypto_box_NONCEBYTES);
-    int len = decrypt_data_fast(shared_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
-                                length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_1), plain);
+    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
+                                     length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_1), plain);
 
     if ((uint32_t)len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_1 + crypto_box_MACBYTES))
         return 1;
 
     IP_Port send_to;
-    memcpy(&send_to, plain, sizeof(IP_Port));
+    ipport_unpack(&send_to, plain);
     to_host_family(&send_to.ip);
 
-    uint8_t data[MAX_ONION_SIZE];
+    uint8_t data[ONION_MAX_PACKET_SIZE];
     data[0] = NET_PACKET_ONION_SEND_2;
     memcpy(data + 1, packet + 1, crypto_box_NONCEBYTES);
-    memcpy(data + 1 + crypto_box_NONCEBYTES, plain + sizeof(IP_Port), len - sizeof(IP_Port));
-    uint32_t data_len = 1 + crypto_box_NONCEBYTES + (len - sizeof(IP_Port));
+    memcpy(data + 1 + crypto_box_NONCEBYTES, plain + SIZE_IPPORT, len - SIZE_IPPORT);
+    uint32_t data_len = 1 + crypto_box_NONCEBYTES + (len - SIZE_IPPORT);
     uint8_t *ret_part = data + data_len;
     new_nonce(ret_part);
-    uint8_t ret_data[RETURN_1 + sizeof(IP_Port)];
-    memcpy(ret_data, &source, sizeof(IP_Port));
-    memcpy(ret_data + sizeof(IP_Port), packet + (length - RETURN_1), RETURN_1);
+    uint8_t ret_data[RETURN_1 + SIZE_IPPORT];
+    ipport_pack(ret_data, &source);
+    memcpy(ret_data + SIZE_IPPORT, packet + (length - RETURN_1), RETURN_1);
     len = encrypt_data_symmetric(onion->secret_symmetric_key, ret_part, ret_data, sizeof(ret_data),
-                                 ret_part + crypto_secretbox_NONCEBYTES);
+                                 ret_part + crypto_box_NONCEBYTES);
 
-    if (len != RETURN_2 - crypto_secretbox_NONCEBYTES)
+    if (len != RETURN_2 - crypto_box_NONCEBYTES)
         return 1;
 
-    data_len += crypto_secretbox_NONCEBYTES + len;
+    data_len += crypto_box_NONCEBYTES + len;
 
     if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len)
         return 1;
@@ -264,7 +272,7 @@ static int handle_send_2(void *object, IP_Port source, uint8_t *packet, uint32_t
 {
     Onion *onion = object;
 
-    if (length > MAX_ONION_SIZE)
+    if (length > ONION_MAX_PACKET_SIZE)
         return 1;
 
     if (length <= 1 + SEND_3)
@@ -272,31 +280,31 @@ static int handle_send_2(void *object, IP_Port source, uint8_t *packet, uint32_t
 
     change_symmetric_key(onion);
 
-    uint8_t plain[MAX_ONION_SIZE];
+    uint8_t plain[ONION_MAX_PACKET_SIZE];
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
     get_shared_key(&onion->shared_keys_3, shared_key, onion->dht->self_secret_key, packet + 1 + crypto_box_NONCEBYTES);
-    int len = decrypt_data_fast(shared_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
-                                length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_2), plain);
+    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
+                                     length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_2), plain);
 
     if ((uint32_t)len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_2 + crypto_box_MACBYTES))
         return 1;
 
     IP_Port send_to;
-    memcpy(&send_to, plain, sizeof(IP_Port));
+    ipport_unpack(&send_to, plain);
     to_host_family(&send_to.ip);
 
-    uint8_t data[MAX_ONION_SIZE];
-    memcpy(data, plain + sizeof(IP_Port), len - sizeof(IP_Port));
-    uint32_t data_len = (len - sizeof(IP_Port));
-    uint8_t *ret_part = data + (len - sizeof(IP_Port));
+    uint8_t data[ONION_MAX_PACKET_SIZE];
+    memcpy(data, plain + SIZE_IPPORT, len - SIZE_IPPORT);
+    uint32_t data_len = (len - SIZE_IPPORT);
+    uint8_t *ret_part = data + (len - SIZE_IPPORT);
     new_nonce(ret_part);
-    uint8_t ret_data[RETURN_2 + sizeof(IP_Port)];
-    memcpy(ret_data, &source, sizeof(IP_Port));
-    memcpy(ret_data + sizeof(IP_Port), packet + (length - RETURN_2), RETURN_2);
+    uint8_t ret_data[RETURN_2 + SIZE_IPPORT];
+    ipport_pack(ret_data, &source);
+    memcpy(ret_data + SIZE_IPPORT, packet + (length - RETURN_2), RETURN_2);
     len = encrypt_data_symmetric(onion->secret_symmetric_key, ret_part, ret_data, sizeof(ret_data),
-                                 ret_part + crypto_secretbox_NONCEBYTES);
+                                 ret_part + crypto_box_NONCEBYTES);
 
-    if (len != RETURN_3 - crypto_secretbox_NONCEBYTES)
+    if (len != RETURN_3 - crypto_box_NONCEBYTES)
         return 1;
 
     data_len += RETURN_3;
@@ -312,7 +320,7 @@ static int handle_recv_3(void *object, IP_Port source, uint8_t *packet, uint32_t
 {
     Onion *onion = object;
 
-    if (length > MAX_ONION_SIZE)
+    if (length > ONION_MAX_PACKET_SIZE)
         return 1;
 
     if (length <= 1 + RETURN_3)
@@ -320,19 +328,19 @@ static int handle_recv_3(void *object, IP_Port source, uint8_t *packet, uint32_t
 
     change_symmetric_key(onion);
 
-    uint8_t plain[sizeof(IP_Port) + RETURN_2];
-    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + crypto_secretbox_NONCEBYTES,
-                                     sizeof(IP_Port) + RETURN_2 + crypto_secretbox_MACBYTES, plain);
+    uint8_t plain[SIZE_IPPORT + RETURN_2];
+    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES,
+                                     SIZE_IPPORT + RETURN_2 + crypto_box_MACBYTES, plain);
 
     if ((uint32_t)len != sizeof(plain))
         return 1;
 
     IP_Port send_to;
-    memcpy(&send_to, plain, sizeof(IP_Port));
+    ipport_unpack(&send_to, plain);
 
-    uint8_t data[MAX_ONION_SIZE];
+    uint8_t data[ONION_MAX_PACKET_SIZE];
     data[0] = NET_PACKET_ONION_RECV_2;
-    memcpy(data + 1, plain + sizeof(IP_Port), RETURN_2);
+    memcpy(data + 1, plain + SIZE_IPPORT, RETURN_2);
     memcpy(data + 1 + RETURN_2, packet + 1 + RETURN_3, length - (1 + RETURN_3));
     uint32_t data_len = 1 + RETURN_2 + (length - (1 + RETURN_3));
 
@@ -346,7 +354,7 @@ static int handle_recv_2(void *object, IP_Port source, uint8_t *packet, uint32_t
 {
     Onion *onion = object;
 
-    if (length > MAX_ONION_SIZE)
+    if (length > ONION_MAX_PACKET_SIZE)
         return 1;
 
     if (length <= 1 + RETURN_2)
@@ -354,19 +362,19 @@ static int handle_recv_2(void *object, IP_Port source, uint8_t *packet, uint32_t
 
     change_symmetric_key(onion);
 
-    uint8_t plain[sizeof(IP_Port) + RETURN_1];
-    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + crypto_secretbox_NONCEBYTES,
-                                     sizeof(IP_Port) + RETURN_1 + crypto_secretbox_MACBYTES, plain);
+    uint8_t plain[SIZE_IPPORT + RETURN_1];
+    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES,
+                                     SIZE_IPPORT + RETURN_1 + crypto_box_MACBYTES, plain);
 
     if ((uint32_t)len != sizeof(plain))
         return 1;
 
     IP_Port send_to;
-    memcpy(&send_to, plain, sizeof(IP_Port));
+    ipport_unpack(&send_to, plain);
 
-    uint8_t data[MAX_ONION_SIZE];
+    uint8_t data[ONION_MAX_PACKET_SIZE];
     data[0] = NET_PACKET_ONION_RECV_1;
-    memcpy(data + 1, plain + sizeof(IP_Port), RETURN_1);
+    memcpy(data + 1, plain + SIZE_IPPORT, RETURN_1);
     memcpy(data + 1 + RETURN_1, packet + 1 + RETURN_2, length - (1 + RETURN_2));
     uint32_t data_len = 1 + RETURN_1 + (length - (1 + RETURN_2));
 
@@ -380,7 +388,7 @@ static int handle_recv_1(void *object, IP_Port source, uint8_t *packet, uint32_t
 {
     Onion *onion = object;
 
-    if (length > MAX_ONION_SIZE)
+    if (length > ONION_MAX_PACKET_SIZE)
         return 1;
 
     if (length <= 1 + RETURN_1)
@@ -388,14 +396,16 @@ static int handle_recv_1(void *object, IP_Port source, uint8_t *packet, uint32_t
 
     change_symmetric_key(onion);
 
-    IP_Port send_to;
-
-    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + crypto_secretbox_NONCEBYTES,
-                                     sizeof(IP_Port) + crypto_secretbox_MACBYTES, (uint8_t *) &send_to);
+    uint8_t plain[SIZE_IPPORT];
+    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES,
+                                     SIZE_IPPORT + crypto_box_MACBYTES, plain);
 
-    if ((uint32_t)len != sizeof(IP_Port))
+    if ((uint32_t)len != SIZE_IPPORT)
         return 1;
 
+    IP_Port send_to;
+    ipport_unpack(&send_to, plain);
+
     uint32_t data_len = length - (1 + RETURN_1);
 
     if (onion->recv_1_function && send_to.ip.family != AF_INET && send_to.ip.family != AF_INET6)
@@ -424,7 +434,7 @@ Onion *new_onion(DHT *dht)
         return NULL;
 
     onion->dht = dht;
-    onion->net = dht->c->lossless_udp->net;
+    onion->net = dht->net;
     new_symmetric_key(onion->secret_symmetric_key);
     onion->timestamp = unix_time();