12 files changed, 360 insertions, 294 deletions

diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index c286567f..5232deed 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -41,7 +41,7 @@
 #define MAX_SENT_NODES 8
 
 /* Ping timeout in seconds */
-#define PING_TIMEOUT 5
+#define PING_TIMEOUT 3
 
 /* The timeout after which a node is discarded completely. */
 #define KILL_NODE_TIMEOUT 300
@@ -120,6 +120,7 @@ static int client_in_list(Client_data *list, uint32_t length, uint8_t *client_id
     uint32_t i;
 
     for (i = 0; i < length; i++)
+
         /* Dead nodes are considered dead (not in the list)*/
         if (!is_timeout(list[i].assoc4.timestamp, KILL_NODE_TIMEOUT) ||
                 !is_timeout(list[i].assoc6.timestamp, KILL_NODE_TIMEOUT))
@@ -278,6 +279,7 @@ static void get_close_nodes_inner(DHT *dht, uint8_t *client_id, Node_format *nod
             continue;
 
         IPPTsPng *ipptp = NULL;
+
         if (sa_family == AF_INET)
             ipptp = &client->assoc4;
         else
@@ -311,7 +313,8 @@ static void get_close_nodes_inner(DHT *dht, uint8_t *client_id, Node_format *nod
         if (ipv46x)
             continue;
 
-        if (!LAN_ip(ipptp->ip_port.ip) && !is_LAN)
+        /* don't send LAN ips to non LAN peers */
+        if (LAN_ip(ipptp->ip_port.ip) == 0 && !is_LAN)
             continue;
 
         if (num_nodes < MAX_SENT_NODES) {
@@ -570,78 +573,58 @@ static void returnedip_ports(DHT *dht, IP_Port ip_port, uint8_t *client_id, uint
     }
 }
 
-static int is_gettingnodes(DHT *dht, IP_Port ip_port, uint64_t ping_id)
-{
-    uint32_t i;
-    uint8_t pinging;
-
-    for (i = 0; i < LSEND_NODES_ARRAY; ++i ) {
-        if (!is_timeout(dht->send_nodes[i].timestamp, PING_TIMEOUT)) {
-            pinging = 0;
-
-            if (ping_id != 0 && dht->send_nodes[i].id == ping_id)
-                ++pinging;
-
-            if (ip_isset(&ip_port.ip) && ipport_equal(&dht->send_nodes[i].ip_port, &ip_port))
-                ++pinging;
-
-            if (pinging == (ping_id != 0) + ip_isset(&ip_port.ip))
-                return 1;
-        }
-    }
-
-    return 0;
-}
-
-/* Same but for get node requests. */
-static uint64_t add_gettingnodes(DHT *dht, IP_Port ip_port)
-{
-    uint32_t i, j;
-    uint64_t ping_id = ((uint64_t)random_int() << 32) + random_int();
-
-    for (i = 0; i < PING_TIMEOUT; ++i ) {
-        for (j = 0; j < LSEND_NODES_ARRAY; ++j ) {
-            if (is_timeout(dht->send_nodes[j].timestamp, PING_TIMEOUT - i)) {
-                dht->send_nodes[j].timestamp = unix_time();
-                dht->send_nodes[j].ip_port = ip_port;
-                dht->send_nodes[j].id = ping_id;
-                return ping_id;
-            }
-        }
-    }
-
-    return 0;
-}
+#define NODES_ENCRYPTED_MESSAGE_LENGTH (crypto_secretbox_NONCEBYTES + sizeof(uint64_t) + sizeof(Node_format) + sizeof(Node_format) + crypto_secretbox_MACBYTES)
 
-/* Send a getnodes request. */
-static int getnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *client_id)
+/* Send a getnodes request.
+   sendback_node is the node that it will send back the response to (set to NULL to disable this) */
+static int getnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *client_id, Node_format *sendback_node)
 {
     /* Check if packet is going to be sent to ourself. */
-    if (id_equal(public_key, dht->c->self_public_key) || is_gettingnodes(dht, ip_port, 0))
+    if (id_equal(public_key, dht->c->self_public_key))
         return -1;
 
-    uint64_t ping_id = add_gettingnodes(dht, ip_port);
+    uint8_t plain_message[NODES_ENCRYPTED_MESSAGE_LENGTH] = {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);
 
-    if (ping_id == 0)
+    uint64_t temp_time = unix_time();
+    memcpy(plain_message, &temp_time, sizeof(temp_time));
+    Node_format reciever;
+    memcpy(reciever.client_id, public_key, CLIENT_ID_SIZE);
+    reciever.ip_port = ip_port;
+    memcpy(plain_message + sizeof(temp_time), &reciever, sizeof(reciever));
+
+    if (sendback_node != NULL)
+        memcpy(plain_message + sizeof(temp_time) + sizeof(reciever), sendback_node, sizeof(Node_format));
+
+    int len_m = encrypt_data_symmetric(dht->secret_symmetric_key,
+                                       nonce,
+                                       plain_message,
+                                       sizeof(temp_time) + sizeof(reciever) + sizeof(Node_format),
+                                       encrypted_message + crypto_secretbox_NONCEBYTES);
+
+    if (len_m != NODES_ENCRYPTED_MESSAGE_LENGTH - crypto_secretbox_NONCEBYTES)
         return -1;
 
-    uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING];
-    uint8_t plain[sizeof(ping_id) + CLIENT_ID_SIZE];
-    uint8_t encrypt[sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING];
-    uint8_t nonce[crypto_box_NONCEBYTES];
-    new_nonce(nonce);
+    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 + NODES_ENCRYPTED_MESSAGE_LENGTH];
+    uint8_t encrypt[CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES];
+
 
-    memcpy(plain, &ping_id, sizeof(ping_id));
-    memcpy(plain + sizeof(ping_id), client_id, CLIENT_ID_SIZE);
+    memcpy(plain, client_id, CLIENT_ID_SIZE);
+    memcpy(plain + CLIENT_ID_SIZE, encrypted_message, NODES_ENCRYPTED_MESSAGE_LENGTH);
 
     int len = encrypt_data( public_key,
                             dht->c->self_secret_key,
                             nonce,
                             plain,
-                            sizeof(ping_id) + CLIENT_ID_SIZE,
+                            CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH,
                             encrypt );
 
-    if (len != sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING)
+    if (len != CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES)
         return -1;
 
     data[0] = NET_PACKET_GET_NODES;
@@ -652,18 +635,20 @@ static int getnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *cli
     return sendpacket(dht->c->lossless_udp->net, ip_port, data, sizeof(data));
 }
 
+
 /* Send a send nodes response. */
 /* because of BINARY compatibility, the Node_format MUST BE Node4_format,
- * IPv6 nodes are sent in a different message */
-static int sendnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *client_id, uint64_t ping_id)
+ * IPv6 nodes are sent in a different message
+ * encrypted_data must be of size NODES_ENCRYPTED_MESSAGE_LENGTH */
+static int sendnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *client_id, uint8_t *encrypted_data)
 {
     /* Check if packet is going to be sent to ourself. */
     if (id_equal(public_key, dht->c->self_public_key))
         return -1;
 
     size_t Node4_format_size = sizeof(Node4_format);
-    uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id)
-                 + Node4_format_size * MAX_SENT_NODES + ENCRYPTION_PADDING];
+    uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES
+                 + Node4_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES];
 
     Node_format nodes_list[MAX_SENT_NODES];
     int num_nodes = get_close_nodes(dht, client_id, nodes_list, AF_INET, LAN_ip(ip_port.ip) == 0);
@@ -671,14 +656,12 @@ static int sendnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *cl
     if (num_nodes == 0)
         return 0;
 
-    uint8_t plain[sizeof(ping_id) + Node4_format_size * MAX_SENT_NODES];
-    uint8_t encrypt[sizeof(ping_id) + Node4_format_size * MAX_SENT_NODES + ENCRYPTION_PADDING];
+    uint8_t plain[Node4_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH];
+    uint8_t encrypt[Node4_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES];
     uint8_t nonce[crypto_box_NONCEBYTES];
     new_nonce(nonce);
 
-    memcpy(plain, &ping_id, sizeof(ping_id));
-
-    Node4_format *nodes4_list = (Node4_format *)(plain + sizeof(ping_id));
+    Node4_format *nodes4_list = (Node4_format *)(plain);
     int i, num_nodes_ok = 0;
 
     for (i = 0; i < num_nodes; i++) {
@@ -703,17 +686,16 @@ static int sendnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *cl
         num_nodes = num_nodes_ok;
     }
 
+    memcpy(plain + num_nodes * Node4_format_size, encrypted_data, NODES_ENCRYPTED_MESSAGE_LENGTH);
     int len = encrypt_data( public_key,
                             dht->c->self_secret_key,
                             nonce,
                             plain,
-                            sizeof(ping_id) + num_nodes * Node4_format_size,
+                            num_nodes * Node4_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH,
                             encrypt );
 
-    if (len == -1)
-        return -1;
-
-    if ((unsigned int)len != sizeof(ping_id) + num_nodes * Node4_format_size + ENCRYPTION_PADDING)
+    if ((unsigned int)len != num_nodes * Node4_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH +
+            crypto_box_MACBYTES)
         return -1;
 
     data[0] = NET_PACKET_SEND_NODES;
@@ -725,15 +707,15 @@ static int sendnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *cl
 }
 
 /* Send a send nodes response: message for IPv6 nodes */
-static int sendnodes_ipv6(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *client_id, uint64_t ping_id)
+static int sendnodes_ipv6(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *client_id, uint8_t *encrypted_data)
 {
     /* Check if packet is going to be sent to ourself. */
     if (id_equal(public_key, dht->c->self_public_key))
         return -1;
 
     size_t Node_format_size = sizeof(Node_format);
-    uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id)
-                 + Node_format_size * MAX_SENT_NODES + ENCRYPTION_PADDING];
+    uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES
+                 + Node_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES];
 
     Node_format nodes_list[MAX_SENT_NODES];
     int num_nodes = get_close_nodes(dht, client_id, nodes_list, AF_INET6, LAN_ip(ip_port.ip) == 0);
@@ -741,25 +723,21 @@ static int sendnodes_ipv6(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_
     if (num_nodes == 0)
         return 0;
 
-    uint8_t plain[sizeof(ping_id) + Node_format_size * MAX_SENT_NODES];
-    uint8_t encrypt[sizeof(ping_id) + Node_format_size * MAX_SENT_NODES + ENCRYPTION_PADDING];
+    uint8_t plain[Node_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH];
+    uint8_t encrypt[Node_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES];
     uint8_t nonce[crypto_box_NONCEBYTES];
     new_nonce(nonce);
 
-    memcpy(plain, &ping_id, sizeof(ping_id));
-    memcpy(plain + sizeof(ping_id), nodes_list, num_nodes * Node_format_size);
-
+    memcpy(plain, nodes_list, num_nodes * Node_format_size);
+    memcpy(plain + num_nodes * Node_format_size, encrypted_data, NODES_ENCRYPTED_MESSAGE_LENGTH);
     int len = encrypt_data( public_key,
                             dht->c->self_secret_key,
                             nonce,
                             plain,
-                            sizeof(ping_id) + num_nodes * Node_format_size,
+                            num_nodes * Node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH,
                             encrypt );
 
-    if (len == -1)
-        return -1;
-
-    if ((unsigned int)len != sizeof(ping_id) + num_nodes * Node_format_size + ENCRYPTION_PADDING)
+    if ((unsigned int)len != num_nodes * Node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES)
         return -1;
 
     data[0] = NET_PACKET_SEND_NODES_IPV6;
@@ -773,45 +751,74 @@ static int sendnodes_ipv6(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_
 static int handle_getnodes(void *object, IP_Port source, uint8_t *packet, uint32_t length)
 {
     DHT *dht = object;
-    uint64_t ping_id;
 
-    if (length != ( 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES
-                    + sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING ))
+    if (length != ( 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH +
+                    crypto_box_MACBYTES ))
         return 1;
 
     /* Check if packet is from ourself. */
     if (id_equal(packet + 1, dht->c->self_public_key))
         return 1;
 
-    uint8_t plain[sizeof(ping_id) + CLIENT_ID_SIZE];
+    uint8_t plain[CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH];
 
     int len = decrypt_data( packet + 1,
                             dht->c->self_secret_key,
                             packet + 1 + CLIENT_ID_SIZE,
                             packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                            sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING,
+                            CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES,
                             plain );
 
-    if (len != sizeof(ping_id) + CLIENT_ID_SIZE)
+    if (len != CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH)
         return 1;
 
-    memcpy(&ping_id, plain, sizeof(ping_id));
-    sendnodes(dht, source, packet + 1, plain + sizeof(ping_id), ping_id);
-    sendnodes_ipv6(dht, source, packet + 1, plain + sizeof(ping_id),
-                   ping_id); /* TODO: prevent possible amplification attacks */
+    sendnodes(dht, source, packet + 1, plain, plain + CLIENT_ID_SIZE);
+    sendnodes_ipv6(dht, source, packet + 1, plain,
+                   plain + CLIENT_ID_SIZE); /* TODO: prevent possible amplification attacks */
 
     add_toping(dht->ping, packet + 1, source);
     //send_ping_request(dht, source, packet + 1); /* TODO: make this smarter? */
 
     return 0;
 }
+/* return 0 if no
+   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, uint8_t *encrypted_data,
+                                    Node_format *sendback_node)
+{
+    uint8_t plain_message[NODES_ENCRYPTED_MESSAGE_LENGTH];
+
+    if (decrypt_data_symmetric(dht->secret_symmetric_key, encrypted_data, encrypted_data + crypto_secretbox_NONCEBYTES,
+                               NODES_ENCRYPTED_MESSAGE_LENGTH - crypto_secretbox_NONCEBYTES,
+                               plain_message) != sizeof(uint64_t) + sizeof(Node_format) * 2)
+        return 0;
+
+    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;
+
+    Node_format test;
+    memcpy(&test, plain_message + sizeof(uint64_t), sizeof(Node_format));
+
+    if (!ipport_equal(&test.ip_port, &node_ip_port) || memcmp(test.client_id, client_id, CLIENT_ID_SIZE) != 0)
+        return 0;
+
+    memcpy(sendback_node, plain_message + sizeof(uint64_t) + sizeof(Node_format), sizeof(Node_format));
+    return 1;
+}
+
+/* Function is needed in following functions. */
+static int send_hardening_getnode_res(DHT *dht, Node_format *sendto, Node_format *list, uint16_t num_nodes);
 
 static int handle_sendnodes(void *object, IP_Port source, uint8_t *packet, uint32_t length)
 {
     DHT *dht = object;
-    uint64_t ping_id;
     uint32_t cid_size = 1 + CLIENT_ID_SIZE;
-    cid_size += crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING;
+    cid_size += crypto_box_NONCEBYTES + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES;
 
     size_t Node4_format_size = sizeof(Node4_format);
 
@@ -821,24 +828,24 @@ static int handle_sendnodes(void *object, IP_Port source, uint8_t *packet, uint3
         return 1;
 
     uint32_t num_nodes = (length - cid_size) / Node4_format_size;
-    uint8_t plain[sizeof(ping_id) + Node4_format_size * MAX_SENT_NODES];
+    uint8_t plain[Node4_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH];
 
     int len = decrypt_data(
                   packet + 1,
                   dht->c->self_secret_key,
                   packet + 1 + CLIENT_ID_SIZE,
                   packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                  sizeof(ping_id) + num_nodes * Node4_format_size + ENCRYPTION_PADDING, plain );
+                  num_nodes * Node4_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES, plain );
 
-    if ((unsigned int)len != sizeof(ping_id) + num_nodes * Node4_format_size)
+    if ((unsigned int)len != num_nodes * Node4_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH)
         return 1;
 
-    memcpy(&ping_id, plain, sizeof(ping_id));
+    Node_format sendback_node;
 
-    if (!is_gettingnodes(dht, source, ping_id))
+    if (!sent_getnode_to_node(dht, packet + 1, source, plain + num_nodes * Node4_format_size, &sendback_node))
         return 1;
 
-    Node4_format *nodes4_list = (Node4_format *)(plain + sizeof(ping_id));
+    Node4_format *nodes4_list = (Node4_format *)(plain);
     Node_format nodes_list[MAX_SENT_NODES];
     uint32_t i, num_nodes_ok = 0;
 
@@ -858,6 +865,7 @@ static int handle_sendnodes(void *object, IP_Port source, uint8_t *packet, uint3
         num_nodes = num_nodes_ok;
     }
 
+    send_hardening_getnode_res(dht, &sendback_node, nodes_list, num_nodes);
     addto_lists(dht, source, packet + 1);
 
     for (i = 0; i < num_nodes; ++i)  {
@@ -871,9 +879,8 @@ static int handle_sendnodes(void *object, IP_Port source, uint8_t *packet, uint3
 static int handle_sendnodes_ipv6(void *object, IP_Port source, uint8_t *packet, uint32_t length)
 {
     DHT *dht = object;
-    uint64_t ping_id;
     uint32_t cid_size = 1 + CLIENT_ID_SIZE;
-    cid_size += crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING;
+    cid_size += crypto_box_NONCEBYTES + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES;
 
     size_t Node_format_size = sizeof(Node_format);
 
@@ -883,27 +890,28 @@ static int handle_sendnodes_ipv6(void *object, IP_Port source, uint8_t *packet,
         return 1;
 
     uint32_t num_nodes = (length - cid_size) / Node_format_size;
-    uint8_t plain[sizeof(ping_id) + Node_format_size * MAX_SENT_NODES];
+    uint8_t plain[Node_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH];
 
     int len = decrypt_data(
                   packet + 1,
                   dht->c->self_secret_key,
                   packet + 1 + CLIENT_ID_SIZE,
                   packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                  sizeof(ping_id) + num_nodes * Node_format_size + ENCRYPTION_PADDING, plain );
+                  num_nodes * Node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES, plain );
 
-    if ((unsigned int)len != sizeof(ping_id) + num_nodes * Node_format_size)
+    if ((unsigned int)len != num_nodes * Node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH)
         return 1;
 
-    memcpy(&ping_id, plain, sizeof(ping_id));
+    Node_format sendback_node;
 
-    if (!is_gettingnodes(dht, source, ping_id))
+    if (!sent_getnode_to_node(dht, packet + 1, source, plain + num_nodes * Node_format_size, &sendback_node))
         return 1;
 
     uint32_t i;
     Node_format nodes_list[MAX_SENT_NODES];
-    memcpy(nodes_list, plain + sizeof(ping_id), num_nodes * sizeof(Node_format));
+    memcpy(nodes_list, plain, num_nodes * sizeof(Node_format));
 
+    send_hardening_getnode_res(dht, &sendback_node, nodes_list, num_nodes);
     addto_lists(dht, source, packet + 1);
 
     for (i = 0; i < num_nodes; ++i)  {
@@ -931,7 +939,7 @@ static void get_bunchnodes(DHT *dht, Client_data *list, uint16_t length, uint16_
         for (a = 0, assoc = &list[i].assoc6; a < 2; a++, assoc = &list[i].assoc4)
             if (ipport_isset(&(assoc->ip_port)) &&
                     !is_timeout(assoc->ret_timestamp, BAD_NODE_TIMEOUT)) {
-                getnodes(dht, assoc->ip_port, list[i].client_id, client_id);
+                getnodes(dht, assoc->ip_port, list[i].client_id, client_id, NULL);
                 ++num;
 
                 if (num >= max_num)
@@ -1064,7 +1072,7 @@ static void do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, uint8
     if ((num_nodes != 0) && is_timeout(*lastgetnode, GET_NODE_INTERVAL)) {
         uint32_t rand_node = rand() % num_nodes;
         getnodes(dht, assoc_list[rand_node]->ip_port, client_list[rand_node]->client_id,
-                 client_id);
+                 client_id, NULL);
         *lastgetnode = temp_time;
     }
 }
@@ -1092,7 +1100,7 @@ static void do_Close(DHT *dht)
 
 void DHT_bootstrap(DHT *dht, IP_Port ip_port, uint8_t *public_key)
 {
-    getnodes(dht, ip_port, public_key, dht->c->self_public_key);
+    getnodes(dht, ip_port, public_key, dht->c->self_public_key, NULL);
 }
 int DHT_bootstrap_from_address(DHT *dht, const char *address, uint8_t ipv6enabled,
                                uint16_t port, uint8_t *public_key)
@@ -1193,12 +1201,15 @@ static int friend_iplist(DHT *dht, IP_Port *ip_portlist, uint16_t friend_num)
 
 #ifdef FRIEND_IPLIST_PAD
     memcpy(ip_portlist, ipv6s, num_ipv6s * sizeof(IP_Port));
+
     if (num_ipv6s == MAX_FRIEND_CLIENTS)
         return MAX_FRIEND_CLIENTS;
 
     int num_ipv4s_used = MAX_FRIEND_CLIENTS - num_ipv6s;
+
     if (num_ipv4s_used > num_ipv4s)
         num_ipv4s_used = num_ipv4s;
+
     memcpy(&ip_portlist[num_ipv6s], ipv4s, num_ipv4s_used * sizeof(IP_Port));
     return num_ipv6s + num_ipv4s_used;
 
@@ -1532,6 +1543,104 @@ static void do_NAT(DHT *dht)
 /*----------------------------------------------------------------------------------*/
 /*-----------------------END OF NAT PUNCHING FUNCTIONS------------------------------*/
 
+#define HARDREQ_DATA_SIZE 768 /* Attempt to prevent amplification/other attacks*/
+
+#define CHECK_TYPE_GETNODE_REQ 0
+#define CHECK_TYPE_GETNODE_RES 1
+
+static int send_hardening_req(DHT *dht, Node_format *sendto, uint8_t type, uint8_t *contents, uint16_t length)
+{
+    if (length > HARDREQ_DATA_SIZE - 1)
+        return -1;
+
+    uint8_t packet[MAX_DATA_SIZE];
+    uint8_t data[HARDREQ_DATA_SIZE] = {0};
+    data[0] = type;
+    memcpy(data + 1, contents, length);
+    int len = create_request(dht->c->self_public_key, dht->c->self_secret_key, packet, sendto->client_id, data,
+                             sizeof(data), CRYPTO_PACKET_HARDENING);
+
+    if (len == -1)
+        return -1;
+
+    return sendpacket(dht->c->lossless_udp->net, sendto->ip_port, packet, len);
+}
+
+/* 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];
+    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);
+}
+
+/* Send a get node hardening response */
+static int send_hardening_getnode_res(DHT *dht, Node_format *sendto, Node_format *list, uint16_t num_nodes)
+{
+    if (!ip_isset(&sendto->ip_port.ip))
+        return -1;
+
+    uint8_t packet[MAX_DATA_SIZE];
+    uint8_t data[1 + num_nodes * sizeof(Node_format)];
+    data[0] = CHECK_TYPE_GETNODE_RES;
+    memcpy(data + 1, list, num_nodes * sizeof(Node_format));
+    int len = create_request(dht->c->self_public_key, dht->c->self_secret_key, packet, sendto->client_id, data,
+                             sizeof(data), CRYPTO_PACKET_HARDENING);
+
+    if (len == -1)
+        return -1;
+
+    return sendpacket(dht->c->lossless_udp->net, sendto->ip_port, packet, len);
+}
+
+/* Handle a received hardening packet */
+static int handle_hardening(void *object, IP_Port source, uint8_t *source_pubkey, uint8_t *packet, uint32_t length)
+{
+    DHT *dht = object;
+
+    if (length < 2) {
+        return 1;
+    }
+
+    switch (packet[0]) {
+        case CHECK_TYPE_GETNODE_REQ: {
+            if (length != HARDREQ_DATA_SIZE)
+                return 1;
+
+            Node_format node, tocheck_node;
+            node.ip_port = source;
+            memcpy(node.client_id, source_pubkey, CLIENT_ID_SIZE);
+            memcpy(&tocheck_node, packet + 1, sizeof(Node_format));
+
+            if (getnodes(dht, tocheck_node.ip_port, tocheck_node.client_id, packet + 1 + sizeof(Node_format), &node) == -1)
+                return 1;
+
+            return 0;
+        }
+
+        case CHECK_TYPE_GETNODE_RES: {
+            if ((length - 1) % sizeof(Node_format) != 0)
+                return 1;
+
+            uint16_t num = (length - 1) / sizeof(Node_format);
+
+            if (num > MAX_SENT_NODES || num == 0)
+                return 1;
+
+            Node_format nodes[num];
+            memcpy(nodes, packet + 1, sizeof(Node_format)*num);
+            /* If Nodes look good and the request checks out */
+            //TODO
+            return 0;/* success*/
+        }
+    }
+
+    return 1;
+}
+
+/*----------------------------------------------------------------------------------*/
+
 DHT *new_DHT(Net_Crypto *c)
 {
     /* init time */
@@ -1556,10 +1665,11 @@ DHT *new_DHT(Net_Crypto *c)
     networking_registerhandler(c->lossless_udp->net, NET_PACKET_GET_NODES, &handle_getnodes, dht);
     networking_registerhandler(c->lossless_udp->net, NET_PACKET_SEND_NODES, &handle_sendnodes, dht);
     networking_registerhandler(c->lossless_udp->net, NET_PACKET_SEND_NODES_IPV6, &handle_sendnodes_ipv6, dht);
-
     init_cryptopackets(dht);
     cryptopacket_registerhandler(c, CRYPTO_PACKET_NAT_PING, &handle_NATping, dht);
+    cryptopacket_registerhandler(c, CRYPTO_PACKET_HARDENING, &handle_hardening, dht);
 
+    new_symmetric_key(dht->secret_symmetric_key);
     return dht;
 }
 
@@ -1579,82 +1689,11 @@ void kill_DHT(DHT *dht)
     free(dht);
 }
 
-/* Get the size of the DHT (for saving). */
-uint32_t DHT_size_old(DHT *dht)
-{
-    return sizeof(dht->close_clientlist) + sizeof(DHT_Friend) * dht->num_friends;
-}
-
-/* Save the DHT in data where data is an array of size DHT_size(). */
-void DHT_save_old(DHT *dht, uint8_t *data)
-{
-    memcpy(data, dht->close_clientlist, sizeof(dht->close_clientlist));
-    memcpy(data + sizeof(dht->close_clientlist), dht->friends_list, sizeof(DHT_Friend) * dht->num_friends);
-}
-
-/* Load the DHT from data of size size.
- *
- *  return -1 if failure.
- *  return 0 if success.
- */
-int DHT_load_old(DHT *dht, uint8_t *data, uint32_t size)
-{
-    size_t clientlist_oldsize = sizeof(Client_data_old) * LCLIENT_LIST;
-
-    if (size < clientlist_oldsize) {
-#ifdef DEBUG
-        fprintf(stderr, "DHT_load: Expected at least %u bytes, got %u.\n", sizeof(dht->close_clientlist), size);
-#endif
-        return -1;
-    }
-
-    uint32_t friendlistsize = size - clientlist_oldsize;
-
-    if (friendlistsize % sizeof(DHT_Friend_old) != 0) {
-#ifdef DEBUG
-        fprintf(stderr, "DHT_load: Expected a multiple of %u, got %u.\n", sizeof(DHT_Friend), friendlistsize);
-#endif
-        return -1;
-    }
-
-    uint32_t i, j;
-    Client_data_old *client;
-    uint16_t friends_num = friendlistsize / sizeof(DHT_Friend_old);
-
-    if (friends_num != 0) {
-        DHT_Friend_old *tempfriends_list = (DHT_Friend_old *)(data + sizeof(dht->close_clientlist));
-
-        for (i = 0; i < friends_num; ++i) {
-            DHT_addfriend(dht, tempfriends_list[i].client_id);
-
-            for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
-                client = &tempfriends_list[i].client_list[j];
-
-                if (client->assoc.timestamp != 0)
-                    getnodes(dht, client->assoc.ip_port, client->client_id, tempfriends_list[i].client_id);
-            }
-        }
-    }
-
-    Client_data_old *tempclose_clientlist = (Client_data_old *)data;
-
-    for (i = 0; i < LCLIENT_LIST; ++i) {
-        if (tempclose_clientlist[i].assoc.timestamp != 0)
-            DHT_bootstrap(dht, tempclose_clientlist[i].assoc.ip_port,
-                          tempclose_clientlist[i].client_id );
-    }
-
-    return 0;
-}
-
-
 /* new DHT format for load/save, more robust and forward compatible */
 
 #define DHT_STATE_COOKIE_GLOBAL 0x159000d
 
 #define DHT_STATE_COOKIE_TYPE      0x11ce
-#define DHT_STATE_TYPE_FRIENDS          1
-#define DHT_STATE_TYPE_CLIENTS          2
 #define DHT_STATE_TYPE_FRIENDS_ASSOC46  3
 #define DHT_STATE_TYPE_CLIENTS_ASSOC46  4
 
@@ -1726,43 +1765,6 @@ static int dht_load_state_callback(void *outer, uint8_t *data, uint32_t length,
     uint32_t num, i, j;
 
     switch (type) {
-        case DHT_STATE_TYPE_FRIENDS:
-            if (length % sizeof(DHT_Friend_old) != 0)
-                break;
-
-            { /* localize declarations */
-                DHT_Friend_old *friend_list = (DHT_Friend_old *)data;
-                num = length / sizeof(DHT_Friend_old);
-
-                for (i = 0; i < num; ++i) {
-                    DHT_addfriend(dht, friend_list[i].client_id);
-
-                    for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
-                        Client_data_old *client = &friend_list[i].client_list[j];
-
-                        if (client->assoc.timestamp != 0)
-                            getnodes(dht, client->assoc.ip_port, client->client_id, friend_list[i].client_id);
-                    }
-                }
-            } /* localize declarations */
-
-            break;
-
-        case DHT_STATE_TYPE_CLIENTS:
-            if ((length % sizeof(Client_data_old)) != 0)
-                break;
-
-            { /* localize declarations */
-                num = length / sizeof(Client_data_old);
-                Client_data_old *client_list = (Client_data_old *)data;
-
-                for (i = 0; i < num; ++i)
-                    if (client_list[i].assoc.timestamp != 0)
-                        DHT_bootstrap(dht, client_list[i].assoc.ip_port, client_list[i].client_id);
-            } /* localize declarations */
-
-            break;
-
         case DHT_STATE_TYPE_FRIENDS_ASSOC46:
             if (length % sizeof(DHT_Friend) != 0)
                 break;
@@ -1778,10 +1780,10 @@ static int dht_load_state_callback(void *outer, uint8_t *data, uint32_t length,
                         Client_data *client = &friend_list[i].client_list[j];
 
                         if (client->assoc4.timestamp != 0)
-                            getnodes(dht, client->assoc4.ip_port, client->client_id, friend_list[i].client_id);
+                            getnodes(dht, client->assoc4.ip_port, client->client_id, friend_list[i].client_id, NULL);
 
                         if (client->assoc6.timestamp != 0)
-                            getnodes(dht, client->assoc6.ip_port, client->client_id, friend_list[i].client_id);
+                            getnodes(dht, client->assoc6.ip_port, client->client_id, friend_list[i].client_id, NULL);
                     }
                 }
             } /* localize declarations */
@@ -1808,6 +1810,7 @@ static int dht_load_state_callback(void *outer, uint8_t *data, uint32_t length,
             break;
 
 #ifdef DEBUG
+
         default:
             fprintf(stderr, "Load state (DHT): contains unrecognized part (len %u, type %u)\n",
                     length, type);
@@ -1835,7 +1838,7 @@ int DHT_load_new(DHT *dht, uint8_t *data, uint32_t length)
                               length - cookie_len, DHT_STATE_COOKIE_TYPE);
     }
 
-    return DHT_load_old(dht, data, length);
+    return -1;
 }
 /*  return 0 if we are not connected to the DHT.
  *  return 1 if we are.
diff --git a/toxcore/DHT.h b/toxcore/DHT.h
index 360773ff..ac02710f 100644
--- a/toxcore/DHT.h
+++ b/toxcore/DHT.h
@@ -35,11 +35,6 @@
 /* A list of the clients mathematically closest to ours. */
 #define LCLIENT_LIST 32
 
-/* The list of ip ports along with the ping_id of what we sent them and a timestamp. */
-#define LPING_ARRAY 256 // NOTE: Deprecated (doesn't do anything).
-
-#define LSEND_NODES_ARRAY LPING_ARRAY/2
-
 /* Maximum newly announced nodes to ping per TIME_TOPING seconds. */
 #define MAX_TOPING 16
 
@@ -55,11 +50,6 @@ typedef struct {
 
 typedef struct {
     uint8_t     client_id[CLIENT_ID_SIZE];
-    IPPTsPng    assoc;
-} Client_data_old; /* required to load old state files */
-
-typedef struct {
-    uint8_t     client_id[CLIENT_ID_SIZE];
     IPPTsPng    assoc4;
     IPPTsPng    assoc6;
 } Client_data;
@@ -77,15 +67,19 @@ typedef struct {
 } NAT;
 
 typedef struct {
-    uint8_t     client_id[CLIENT_ID_SIZE];
-    Client_data_old client_list[MAX_FRIEND_CLIENTS];
-
-    /* Time at which the last get_nodes request was sent. */
-    uint64_t    lastgetnode;
-
-    /* Symetric NAT hole punching stuff. */
-    NAT         nat;
-} DHT_Friend_old;  /* required to load old state files */
+    /* Node routes request correctly (true (1) or false/didn't check (0)) */
+    uint8_t     routes_requests_ok;
+    /* Time which we last checked this.*/
+    uint64_t    routes_requests_timestamp;
+    /* 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;
+    /* 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;
+} Hardening;
 
 typedef struct {
     uint8_t     client_id[CLIENT_ID_SIZE];
@@ -94,6 +88,7 @@ typedef struct {
     /* Time at which the last get_nodes request was sent. */
     uint64_t    lastgetnode;
 
+    Hardening hardening;
     /* Symetric NAT hole punching stuff. */
     NAT         nat;
 } DHT_Friend;
@@ -111,11 +106,6 @@ typedef struct {
 
 /*----------------------------------------------------------------------------------*/
 
-typedef struct {
-    IP_Port  ip_port;
-    uint64_t id;
-    uint64_t timestamp;
-} pinged_t;
 
 typedef struct {
     Net_Crypto  *c;
@@ -125,8 +115,10 @@ typedef struct {
     uint16_t     num_friends;
     uint64_t     close_lastgetnodes;
 
-    pinged_t     send_nodes[LSEND_NODES_ARRAY];
     void        *ping;
+
+    /* Note: this key should not be/is not used to transmit any sensitive materials */
+    uint8_t      secret_symmetric_key[crypto_secretbox_KEYBYTES];
 } DHT;
 /*----------------------------------------------------------------------------------*/
 
@@ -240,15 +232,6 @@ DHT *new_DHT(Net_Crypto *c);
 
 void kill_DHT(DHT *dht);
 
-/* Load the DHT from data of size size.
- *  old/new: version of config file
- *
- *  return -1 if failure.
- *  return 0 if success.
- */
-int DHT_load_old(DHT *dht, uint8_t *data, uint32_t size);
-int DHT_load_new(DHT *dht, uint8_t *data, uint32_t size);
-
 /*  return 0 if we are not connected to the DHT.
  *  return 1 if we are.
  */
diff --git a/toxcore/Lossless_UDP.c b/toxcore/Lossless_UDP.c
index e291340d..04533a3b 100644
--- a/toxcore/Lossless_UDP.c
+++ b/toxcore/Lossless_UDP.c
@@ -455,8 +455,9 @@ uint32_t sendqueue_total(Lossless_UDP *ludp)
 {
     uint32_t i, total = 0;
 
-    for(i = 0; i < ludp->connections.len; i++) {
+    for (i = 0; i < ludp->connections.len; i++) {
         Connection *connection = &tox_array_get(&ludp->connections, i, Connection);
+
         if (connection->status != 0)
             total += connection->sendbuff_packetnum - connection->successful_sent;
     }
diff --git a/toxcore/misc_tools.h b/toxcore/misc_tools.h
index 5fd0cb7a..4bf28ac7 100644
--- a/toxcore/misc_tools.h
+++ b/toxcore/misc_tools.h
@@ -89,7 +89,7 @@ int main()
 {
    tox_list_t head;
    tox_list_new(&head); //initialize head
-   
+
    //input a new character, until user enters q or e
    char c = '\0';
    while (c != 'q' && c != 'e') {
@@ -98,16 +98,16 @@ int main()
       tmp->c = c;
       tox_list_add(&head, &tmp->tox_lst); //add it to the list
    }
-   
+
 TOX_LIST_FOR_EACH() takes a struct tox_list and a name for a temporary pointer to use in the loop.
-   
+
 TOX_LIST_GET_VALUE() uses magic to return an instance of a structure that contains tox_list_t.
 You have to give it a temporary tox_string_t, name of tox_list_t member inside our structure (tox_lst),
 and the type of structure to return.
-   
+
    TOX_LIST_FOR_EACH(head, tmp)
       printf("%c", TOX_LIST_GET_VALUE(*tmp, tox_lst, tox_string_t).c);
-   
+
    TOX_LIST_FOR_EACH(head, tmp) {
       if (TOX_LIST_GET_VALUE(*tmp, tox_lst, tox_string_t).c == 'z') {
          //If you delete tmp, you have to quit the loop, or it will go on infinitly.
@@ -116,12 +116,12 @@ and the type of structure to return.
          break;
       }
    }
-   
+
    printf("\n");
    TOX_LIST_FOR_EACH(head, tmp)
       printf("%c", TOX_LIST_GET_VALUE(*tmp, tox_lst, tox_string_t).c);
-   
-   
+
+
    return 0;
 }
 */
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index 3c7c114e..d58f4c27 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -77,7 +77,7 @@ int encrypt_data_fast(uint8_t *enc_key, uint8_t *nonce,
 
     /* Unpad the encrypted message. */
     memcpy(encrypted, temp_encrypted + crypto_box_BOXZEROBYTES, length + crypto_box_MACBYTES);
-    return length - crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES;
+    return length + crypto_box_MACBYTES;
 }
 
 /* Fast decrypt. Depends on enc_ley from encrypt_precompute. */
@@ -104,7 +104,7 @@ int decrypt_data_fast(uint8_t *enc_key, uint8_t *nonce,
 
     /* Unpad the plain message. */
     memcpy(plain, temp_plain + crypto_box_ZEROBYTES, length - crypto_box_MACBYTES);
-    return length - crypto_box_ZEROBYTES + crypto_box_BOXZEROBYTES;
+    return length - crypto_box_MACBYTES;
 }
 
 int encrypt_data(uint8_t *public_key, uint8_t *secret_key, uint8_t *nonce,
@@ -123,6 +123,39 @@ int decrypt_data(uint8_t *public_key, uint8_t *secret_key, uint8_t *nonce,
     return decrypt_data_fast(k, nonce, encrypted, length, plain);
 }
 
+int encrypt_data_symmetric(uint8_t *secret_key, uint8_t *nonce, uint8_t *plain, uint32_t length, uint8_t *encrypted)
+{
+    if (length + crypto_secretbox_MACBYTES > MAX_DATA_SIZE || length == 0)
+        return -1;
+
+    uint8_t temp_plain[MAX_DATA_SIZE + crypto_secretbox_ZEROBYTES] = {0};
+    uint8_t temp_encrypted[MAX_DATA_SIZE + crypto_secretbox_BOXZEROBYTES];
+
+    memcpy(temp_plain + crypto_secretbox_ZEROBYTES, plain, length); // Pad the message with 32 0 bytes.
+
+    crypto_secretbox(temp_encrypted, temp_plain, length + crypto_secretbox_ZEROBYTES, nonce, secret_key);
+    /* Unpad the encrypted message. */
+    memcpy(encrypted, temp_encrypted + crypto_secretbox_BOXZEROBYTES, length + crypto_secretbox_MACBYTES);
+    return length + crypto_secretbox_MACBYTES;
+}
+
+int decrypt_data_symmetric(uint8_t *secret_key, uint8_t *nonce, uint8_t *encrypted, uint32_t length, uint8_t *plain)
+{
+    if (length > MAX_DATA_SIZE || length <= crypto_secretbox_BOXZEROBYTES)
+        return -1;
+
+    uint8_t temp_plain[MAX_DATA_SIZE + crypto_secretbox_ZEROBYTES];
+    uint8_t temp_encrypted[MAX_DATA_SIZE + crypto_secretbox_BOXZEROBYTES] = {0};
+
+    memcpy(temp_encrypted + crypto_secretbox_BOXZEROBYTES, encrypted, length); // Pad the message with 16 0 bytes.
+
+    if (crypto_secretbox_open(temp_plain, temp_encrypted, length + crypto_secretbox_BOXZEROBYTES, nonce, secret_key) == -1)
+        return -1;
+
+    memcpy(plain, temp_plain + crypto_secretbox_ZEROBYTES, length - crypto_secretbox_MACBYTES);
+    return length - crypto_secretbox_MACBYTES;
+}
+
 /* Increment the given nonce by 1. */
 static void increment_nonce(uint8_t *nonce)
 {
@@ -136,16 +169,29 @@ static void increment_nonce(uint8_t *nonce)
     }
 }
 
+#if crypto_box_NONCEBYTES != crypto_secretbox_NONCEBYTES
+/*if they no longer equal each other, this function must be slit into two.*/
+#error random_nonce(): crypto_box_NONCEBYTES must equal crypto_secretbox_NONCEBYTES.
+#endif
 /* Fill the given nonce with random bytes. */
 void random_nonce(uint8_t *nonce)
 {
     randombytes(nonce, crypto_box_NONCEBYTES);
 }
 
+/* Fill a key crypto_secretbox_KEYBYTES big with random bytes */
+void new_symmetric_key(uint8_t *key)
+{
+    randombytes(key, crypto_secretbox_KEYBYTES);
+}
 
 static uint8_t base_nonce[crypto_box_NONCEBYTES];
 static uint8_t nonce_set = 0;
 
+#if crypto_box_NONCEBYTES != crypto_secretbox_NONCEBYTES
+/*if they no longer equal each other, this function must be slit into two.*/
+#error new_nonce(): crypto_box_NONCEBYTES must equal crypto_secretbox_NONCEBYTES.
+#endif
 /* Gives a nonce guaranteed to be different from previous ones.*/
 void new_nonce(uint8_t *nonce)
 {
@@ -247,7 +293,7 @@ int write_cryptpacket(Net_Crypto *c, int crypt_connection_id, uint8_t *data, uin
 int create_request(uint8_t *send_public_key, uint8_t *send_secret_key, uint8_t *packet, uint8_t *recv_public_key,
                    uint8_t *data, uint32_t length, uint8_t request_id)
 {
-    if (MAX_DATA_SIZE < length + 1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + ENCRYPTION_PADDING)
+    if (MAX_DATA_SIZE < length + 1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + crypto_box_MACBYTES)
         return -1;
 
     uint8_t nonce[crypto_box_NONCEBYTES];
@@ -278,7 +324,7 @@ int create_request(uint8_t *send_public_key, uint8_t *send_secret_key, uint8_t *
 int handle_request(uint8_t *self_public_key, uint8_t *self_secret_key, uint8_t *public_key, uint8_t *data,
                    uint8_t *request_id, uint8_t *packet, uint16_t length)
 {
-    if (length > crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + ENCRYPTION_PADDING &&
+    if (length > crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + crypto_box_MACBYTES &&
             length <= MAX_DATA_SIZE) {
         if (memcmp(packet + 1, self_public_key, crypto_box_PUBLICKEYBYTES) == 0) {
             memcpy(public_key, packet + 1 + crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
@@ -313,8 +359,8 @@ static int cryptopacket_handle(void *object, IP_Port source, uint8_t *packet, ui
     DHT *dht = object;
 
     if (packet[0] == NET_PACKET_CRYPTO) {
-        if (length <= crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + ENCRYPTION_PADDING ||
-                length > MAX_DATA_SIZE + ENCRYPTION_PADDING)
+        if (length <= crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + crypto_box_MACBYTES ||
+                length > MAX_DATA_SIZE + crypto_box_MACBYTES)
             return 1;
 
         if (memcmp(packet + 1, dht->c->self_public_key, crypto_box_PUBLICKEYBYTES) == 0) { // Check if request is for us.
diff --git a/toxcore/net_crypto.h b/toxcore/net_crypto.h
index 0de66e98..38400ebc 100644
--- a/toxcore/net_crypto.h
+++ b/toxcore/net_crypto.h
@@ -27,6 +27,7 @@
 #include "Lossless_UDP.h"
 
 #define CRYPTO_PACKET_FRIEND_REQ    32  /* Friend request crypto packet ID. */
+#define CRYPTO_PACKET_HARDENING     48  /* Hardening crypto packet ID. */
 #define CRYPTO_PACKET_NAT_PING      254 /* NAT ping crypto packet ID. */
 #define CRYPTO_HANDSHAKE_TIMEOUT (CONNECTION_TIMEOUT * 2)
 
@@ -77,8 +78,6 @@ typedef struct {
 
 #include "DHT.h"
 
-#define ENCRYPTION_PADDING (crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES)
-
 /* return zero if the buffer contains only zeros. */
 uint8_t crypto_iszero(uint8_t *buffer, uint32_t blen);
 
@@ -114,10 +113,28 @@ int encrypt_data_fast(uint8_t *enc_key, uint8_t *nonce,
 int decrypt_data_fast(uint8_t *enc_key, uint8_t *nonce,
                       uint8_t *encrypted, uint32_t length, uint8_t *plain);
 
+/* Encrypts plain of length length to encrypted of length + 16 using a
+ * secret key crypto_secretbox_KEYBYTES big and a 24 byte nonce.
+ *
+ *  return -1 if there was a problem.
+ *  return length of encrypted data if everything was fine.
+ */
+int encrypt_data_symmetric(uint8_t *secret_key, uint8_t *nonce, uint8_t *plain, uint32_t length, uint8_t *encrypted);
+
+/* Decrypts encrypted of length length to plain of length length - 16 using a
+ * secret key crypto_secretbox_KEYBYTES big and a 24 byte nonce.
+ *
+ *  return -1 if there was a problem (decryption failed).
+ *  return length of plain data if everything was fine.
+ */
+int decrypt_data_symmetric(uint8_t *secret_key, uint8_t *nonce, uint8_t *encrypted, uint32_t length, uint8_t *plain);
 
 /* Fill the given nonce with random bytes. */
 void random_nonce(uint8_t *nonce);
 
+/* Fill a key crypto_secretbox_KEYBYTES big with random bytes */
+void new_symmetric_key(uint8_t *key);
+
 /*Gives a nonce guaranteed to be different from previous ones.*/
 void new_nonce(uint8_t *nonce);
 
diff --git a/toxcore/network.c b/toxcore/network.c
index 0f96083c..d163c0eb 100644
--- a/toxcore/network.c
+++ b/toxcore/network.c
@@ -373,13 +373,15 @@ int networking_wait_execute(uint8_t *data, uint16_t len, uint16_t milliseconds)
     /* returns -1 on error, 0 on timeout, the socket on activity */
     int res = select(nfds, &readfds, &writefds, &exceptfds, &timeout);
 #ifdef LOGGING
+
     /* only dump if not timeout */
     if (res) {
         sprintf(logbuffer, "select(%d): %d (%d, %s) - %d %d %d\n", milliseconds, res, errno,
-                           strerror(errno), FD_ISSET(s->sock, &readfds), FD_ISSET(s->sock, &writefds),
-                           FD_ISSET(s->sock, &exceptfds));
+                strerror(errno), FD_ISSET(s->sock, &readfds), FD_ISSET(s->sock, &writefds),
+                FD_ISSET(s->sock, &exceptfds));
         loglog(logbuffer);
     }
+
 #endif
 
     if (FD_ISSET(s->sock, &writefds))
@@ -527,14 +529,14 @@ Networking_Core *new_networking(IP ip, uint16_t port)
     } else
         return NULL;
 
-    if (ip.family == AF_INET6)
-    {
+    if (ip.family == AF_INET6) {
         char ipv6only = 0;
         socklen_t optsize = sizeof(ipv6only);
 #ifdef LOGGING
         errno = 0;
 #endif
         int res = getsockopt(temp->sock, IPPROTO_IPV6, IPV6_V6ONLY, &ipv6only, &optsize);
+
         if ((res == 0) && (ipv6only == 0)) {
 #ifdef LOGGING
             loglog("Dual-stack socket: enabled per default.\n");
@@ -542,6 +544,7 @@ Networking_Core *new_networking(IP ip, uint16_t port)
         } else {
             ipv6only = 0;
 #ifdef LOGGING
+
             if (res < 0) {
                 sprintf(logbuffer, "Dual-stack socket: Failed to query default. (%d, %s)\n",
                         errno, strerror(errno));
@@ -551,8 +554,9 @@ Networking_Core *new_networking(IP ip, uint16_t port)
             errno = 0;
             res =
 #endif
-                  setsockopt(temp->sock, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&ipv6only, sizeof(ipv6only));
+                setsockopt(temp->sock, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&ipv6only, sizeof(ipv6only));
 #ifdef LOGGING
+
             if (res < 0) {
                 sprintf(logbuffer,
                         "Dual-stack socket: Failed to enable, won't be able to receive from/send to IPv4 addresses. (%u, %s)\n",
@@ -560,6 +564,7 @@ Networking_Core *new_networking(IP ip, uint16_t port)
                 loglog(logbuffer);
             } else
                 loglog("Dual-stack socket: Enabled successfully.\n");
+
 #endif
         }
 
@@ -607,8 +612,7 @@ Networking_Core *new_networking(IP ip, uint16_t port)
     *portptr = htons(port_to_try);
     int tries, res;
 
-    for (tries = TOX_PORTRANGE_FROM; tries <= TOX_PORTRANGE_TO; tries++)
-    {
+    for (tries = TOX_PORTRANGE_FROM; tries <= TOX_PORTRANGE_TO; tries++) {
         res = bind(temp->sock, (struct sockaddr *)&addr, addrsize);
 
         if (!res) {
@@ -676,6 +680,7 @@ int ip_equal(IP *a, IP *b)
         else if (a->family == AF_INET6)
 #ifdef WIN32
             return IN6_ADDR_EQUAL(&a->ip6.in6_addr, &b->ip6.in6_addr);
+
 #else
             return IN6_ARE_ADDR_EQUAL(&a->ip6.in6_addr, &b->ip6.in6_addr);
 #endif
diff --git a/toxcore/network.h b/toxcore/network.h
index 8b9b8b2f..bb851dcb 100644
--- a/toxcore/network.h
+++ b/toxcore/network.h
@@ -68,10 +68,15 @@ typedef int sock_t;
 #include <sodium.h>
 #else
 #include <crypto_box.h>
+#include <crypto_secretbox.h>
 #include <randombytes.h>
 #define crypto_box_MACBYTES (crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES)
 #endif
 
+#ifndef crypto_secretbox_MACBYTES
+#define crypto_secretbox_MACBYTES (crypto_secretbox_ZEROBYTES - crypto_secretbox_BOXZEROBYTES)
+#endif
+
 #ifndef IPV6_ADD_MEMBERSHIP
 #ifdef  IPV6_JOIN_GROUP
 #define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
diff --git a/toxcore/ping.c b/toxcore/ping.c
index c7b829b4..3f237836 100644
--- a/toxcore/ping.c
+++ b/toxcore/ping.c
@@ -3,7 +3,7 @@
  *
  * This file is donated to the Tox Project.
  * Copyright 2013  plutooo
- * 
+ *
  *  Copyright (C) 2013 Tox project All Rights Reserved.
  *
  *  This file is part of Tox.
@@ -20,7 +20,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
- * 
+ *
  */
 
 #ifdef HAVE_CONFIG_H
@@ -40,6 +40,12 @@
 #define TIME_TOPING 5
 
 typedef struct {
+    IP_Port  ip_port;
+    uint64_t id;
+    uint64_t timestamp;
+} pinged_t;
+
+typedef struct {
     Net_Crypto *c;
 
     pinged_t    pings[PING_NUM_MAX];
@@ -132,7 +138,7 @@ static bool is_pinging(PING *ping, IP_Port ipp, uint64_t ping_id)    // O(n) TOD
     return false;
 }
 
-#define DHT_PING_SIZE (1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(uint64_t) + ENCRYPTION_PADDING)
+#define DHT_PING_SIZE (1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(uint64_t) + crypto_box_MACBYTES)
 
 int send_ping_request(PING *ping, IP_Port ipp, uint8_t *client_id)
 {
@@ -157,7 +163,7 @@ int send_ping_request(PING *ping, IP_Port ipp, uint8_t *client_id)
                       (uint8_t *) &ping_id, sizeof(ping_id),
                       pk + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES);
 
-    if (rc != sizeof(ping_id) + ENCRYPTION_PADDING)
+    if (rc != sizeof(ping_id) + crypto_box_MACBYTES)
         return 1;
 
     return sendpacket(ping->c->lossless_udp->net, ipp, pk, sizeof(pk));
@@ -182,7 +188,7 @@ static int send_ping_response(PING *ping, IP_Port ipp, uint8_t *client_id, uint6
                       (uint8_t *) &ping_id, sizeof(ping_id),
                       pk + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES);
 
-    if (rc != sizeof(ping_id) + ENCRYPTION_PADDING)
+    if (rc != sizeof(ping_id) + crypto_box_MACBYTES)
         return 1;
 
     return sendpacket(ping->c->lossless_udp->net, ipp, pk, sizeof(pk));
@@ -207,7 +213,7 @@ static int handle_ping_request(void *_dht, IP_Port source, uint8_t *packet, uint
                       ping->c->self_secret_key,
                       packet + 1 + CLIENT_ID_SIZE,
                       packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                      sizeof(ping_id) + ENCRYPTION_PADDING,
+                      sizeof(ping_id) + crypto_box_MACBYTES,
                       (uint8_t *) &ping_id);
 
     if (rc != sizeof(ping_id))
@@ -239,7 +245,7 @@ static int handle_ping_response(void *_dht, IP_Port source, uint8_t *packet, uin
                       ping->c->self_secret_key,
                       packet + 1 + CLIENT_ID_SIZE,
                       packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                      sizeof(ping_id) + ENCRYPTION_PADDING,
+                      sizeof(ping_id) + crypto_box_MACBYTES,
                       (uint8_t *) &ping_id);
 
     if (rc != sizeof(ping_id))
diff --git a/toxcore/ping.h b/toxcore/ping.h
index 32742401..c2437e1b 100644
--- a/toxcore/ping.h
+++ b/toxcore/ping.h
@@ -3,7 +3,7 @@
  *
  * This file is donated to the Tox Project.
  * Copyright 2013  plutooo
- * 
+ *
  *  Copyright (C) 2013 Tox project All Rights Reserved.
  *
  *  This file is part of Tox.
diff --git a/toxcore/util.c b/toxcore/util.c
index d3df64c1..fab9f660 100644
--- a/toxcore/util.c
+++ b/toxcore/util.c
@@ -3,7 +3,7 @@
  *
  * This file is donated to the Tox Project.
  * Copyright 2013  plutooo
- * 
+ *
  *  Copyright (C) 2013 Tox project All Rights Reserved.
  *
  *  This file is part of Tox.
diff --git a/toxcore/util.h b/toxcore/util.h
index f69f294b..20dcb2de 100644
--- a/toxcore/util.h
+++ b/toxcore/util.h
@@ -3,7 +3,7 @@
  *
  * This file is donated to the Tox Project.
  * Copyright 2013  plutooo
- * 
+ *
  *  Copyright (C) 2013 Tox project All Rights Reserved.
  *
  *  This file is part of Tox.