1 files changed, 113 insertions, 40 deletions

diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index 2b8ec5b5..1089e2ff 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -44,7 +44,7 @@
 #define KILL_NODE_TIMEOUT 300
 
 /* Ping interval in seconds for each random sending of a get nodes request. */
-#define GET_NODE_INTERVAL 5
+#define GET_NODE_INTERVAL 20
 
 #define MAX_PUNCHING_PORTS 48
 
@@ -56,6 +56,9 @@
 #define NAT_PING_REQUEST    0
 #define NAT_PING_RESPONSE   1
 
+/* Number of get node requests to send to quickly find close nodes. */
+#define MAX_BOOTSTRAP_TIMES 10
+
 /* Used in the comparison function for sorting lists of Client_data. */
 typedef struct {
     Client_data c1;
@@ -111,6 +114,72 @@ static int client_id_cmp(ClientPair p1, ClientPair p2)
     return c;
 }
 
+/* Shared key generations are costly, it is therefor smart to store commonly used
+ * ones so that they can re used later without being computed again.
+ *
+ * If shared key is already in shared_keys, copy it to shared_key.
+ * else generate it into shared_key and copy it to shared_keys
+ */
+void get_shared_key(Shared_Keys *shared_keys, uint8_t *shared_key, uint8_t *secret_key, uint8_t *client_id)
+{
+    uint32_t i, num = ~0, curr = 0;
+
+    for (i = 0; i < MAX_KEYS_PER_SLOT; ++i) {
+        int index = client_id[30] * MAX_KEYS_PER_SLOT + i;
+
+        if (shared_keys->keys[index].stored) {
+            if (memcmp(client_id, shared_keys->keys[index].client_id, CLIENT_ID_SIZE) == 0) {
+                memcpy(shared_key, shared_keys->keys[index].shared_key, crypto_box_BEFORENMBYTES);
+                ++shared_keys->keys[index].times_requested;
+                shared_keys->keys[index].time_last_requested = unix_time();
+                return;
+            }
+
+            if (num != 0) {
+                if (is_timeout(shared_keys->keys[index].time_last_requested, KEYS_TIMEOUT)) {
+                    num = 0;
+                    curr = index;
+                } else if (num > shared_keys->keys[index].times_requested) {
+                    num = shared_keys->keys[index].times_requested;
+                    curr = index;
+                }
+            }
+        } else {
+            if (num != 0) {
+                num = 0;
+                curr = index;
+            }
+        }
+    }
+
+    encrypt_precompute(client_id, secret_key, shared_key);
+
+    if (num != (uint32_t)~0) {
+        shared_keys->keys[curr].stored = 1;
+        shared_keys->keys[curr].times_requested = 1;
+        memcpy(shared_keys->keys[curr].client_id, client_id, CLIENT_ID_SIZE);
+        memcpy(shared_keys->keys[curr].shared_key, shared_key, crypto_box_BEFORENMBYTES);
+        shared_keys->keys[curr].time_last_requested = unix_time();
+    }
+}
+
+/* Copy shared_key to decrypt DHT packet from client_id into shared_key
+ * for packets that we recieve.
+ */
+void DHT_get_shared_key_recv(DHT *dht, uint8_t *shared_key, uint8_t *client_id)
+{
+    return get_shared_key(&dht->shared_keys_recv, shared_key, dht->self_secret_key, client_id);
+}
+
+/* Copy shared_key to decrypt DHT packet from client_id into shared_key
+ * for packets that we send.
+ */
+void DHT_get_shared_key_sent(DHT *dht, uint8_t *shared_key, uint8_t *client_id)
+{
+    return get_shared_key(&dht->shared_keys_sent, shared_key, dht->self_secret_key, client_id);
+}
+
+
 /* Check if client with client_id is already in list of length length.
  * If it is then set its corresponding timestamp to current time.
  * If the id is already in the list with a different ip_port, update it.
@@ -819,12 +888,13 @@ static int getnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *cli
     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->self_secret_key,
-                            nonce,
-                            plain,
-                            CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH,
-                            encrypt );
+    uint8_t shared_key[crypto_box_BEFORENMBYTES];
+    DHT_get_shared_key_sent(dht, shared_key, public_key);
+    int len = encrypt_data_fast( shared_key,
+                                 nonce,
+                                 plain,
+                                 CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH,
+                                 encrypt );
 
     if (len != CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES)
         return -1;
@@ -841,7 +911,8 @@ static int getnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *cli
 /* because of BINARY compatibility, the Node_format MUST BE Node4_format,
  * 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)
+static int sendnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *client_id, uint8_t *encrypted_data,
+                     uint8_t *shared_encryption_key)
 {
     /* Check if packet is going to be sent to ourself. */
     if (id_equal(public_key, dht->self_public_key))
@@ -888,12 +959,11 @@ static int sendnodes(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *cl
     }
 
     memcpy(plain + num_nodes * Node4_format_size, encrypted_data, NODES_ENCRYPTED_MESSAGE_LENGTH);
-    int len = encrypt_data( public_key,
-                            dht->self_secret_key,
-                            nonce,
-                            plain,
-                            num_nodes * Node4_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH,
-                            encrypt );
+    int len = encrypt_data_fast( shared_encryption_key,
+                                 nonce,
+                                 plain,
+                                 num_nodes * Node4_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH,
+                                 encrypt );
 
     if ((unsigned int)len != num_nodes * Node4_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH +
             crypto_box_MACBYTES)
@@ -927,7 +997,8 @@ void to_host_family(IP *ip)
         ip->family = AF_INET6;
 }
 /* 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, uint8_t *encrypted_data)
+static int sendnodes_ipv6(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_t *client_id, uint8_t *encrypted_data,
+                          uint8_t *shared_encryption_key)
 {
     /* Check if packet is going to be sent to ourself. */
     if (id_equal(public_key, dht->self_public_key))
@@ -955,12 +1026,11 @@ static int sendnodes_ipv6(DHT *dht, IP_Port ip_port, uint8_t *public_key, uint8_
 
     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->self_secret_key,
-                            nonce,
-                            plain,
-                            num_nodes * Node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH,
-                            encrypt );
+    int len = encrypt_data_fast( shared_encryption_key,
+                                 nonce,
+                                 plain,
+                                 num_nodes * Node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH,
+                                 encrypt );
 
     if ((unsigned int)len != num_nodes * Node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES)
         return -1;
@@ -986,22 +1056,23 @@ static int handle_getnodes(void *object, IP_Port source, uint8_t *packet, uint32
         return 1;
 
     uint8_t plain[CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH];
+    uint8_t shared_key[crypto_box_BEFORENMBYTES];
 
-    int len = decrypt_data( packet + 1,
-                            dht->self_secret_key,
-                            packet + 1 + CLIENT_ID_SIZE,
-                            packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                            CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES,
-                            plain );
+    DHT_get_shared_key_recv(dht, shared_key, packet + 1);
+    int len = decrypt_data_fast( shared_key,
+                                 packet + 1 + CLIENT_ID_SIZE,
+                                 packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
+                                 CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES,
+                                 plain );
 
     if (len != CLIENT_ID_SIZE + NODES_ENCRYPTED_MESSAGE_LENGTH)
         return 1;
 
-    sendnodes(dht, source, packet + 1, plain, plain + CLIENT_ID_SIZE);
+    sendnodes(dht, source, packet + 1, plain, plain + CLIENT_ID_SIZE, shared_key);
     sendnodes_ipv6(dht, source, packet + 1, plain,
-                   plain + CLIENT_ID_SIZE); /* TODO: prevent possible amplification attacks */
+                   plain + CLIENT_ID_SIZE, shared_key); /* TODO: prevent possible amplification attacks */
 
-    add_toping(dht->ping, packet + 1, source);
+    add_to_ping(dht->ping, packet + 1, source);
     //send_ping_request(dht, source, packet + 1); /* TODO: make this smarter? */
 
     return 0;
@@ -1062,9 +1133,10 @@ static int handle_sendnodes_core(void *object, IP_Port source, uint8_t *packet,
     if (num_nodes > MAX_SENT_NODES) /* too long */
         return 1;
 
-    int len = decrypt_data(
-                  packet + 1,
-                  dht->self_secret_key,
+    uint8_t shared_key[crypto_box_BEFORENMBYTES];
+    DHT_get_shared_key_sent(dht, shared_key, packet + 1);
+    int len = decrypt_data_fast(
+                  shared_key,
                   packet + 1 + CLIENT_ID_SIZE,
                   packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
                   num_nodes * node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES,
@@ -1311,7 +1383,7 @@ int DHT_getfriendip(DHT *dht, uint8_t *client_id, IP_Port *ip_port)
 
 /* returns number of nodes not in kill-timeout */
 static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, uint8_t *client_id,
-        Client_data *list, uint32_t list_count)
+        Client_data *list, uint32_t list_count, uint32_t *bootstrap_times)
 {
     uint32_t i;
     uint8_t not_kill = 0;
@@ -1345,11 +1417,12 @@ static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, ui
             }
     }
 
-    if ((num_nodes != 0) && is_timeout(*lastgetnode, GET_NODE_INTERVAL)) {
+    if ((num_nodes != 0) && (is_timeout(*lastgetnode, GET_NODE_INTERVAL) || *bootstrap_times < MAX_BOOTSTRAP_TIMES)) {
         uint32_t rand_node = rand() % num_nodes;
         getnodes(dht, assoc_list[rand_node]->ip_port, client_list[rand_node]->client_id,
                  client_id, NULL);
         *lastgetnode = temp_time;
+        ++*bootstrap_times;
     }
 
     return not_kill;
@@ -1364,7 +1437,7 @@ static void do_DHT_friends(DHT *dht)
 
     for (i = 0; i < dht->num_friends; ++i)
         do_ping_and_sendnode_requests(dht, &dht->friends_list[i].lastgetnode, dht->friends_list[i].client_id,
-                                      dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS);
+                                      dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &dht->friends_list[i].bootstrap_times);
 }
 
 /* Ping each client in the close nodes list every PING_INTERVAL seconds.
@@ -1373,7 +1446,7 @@ static void do_DHT_friends(DHT *dht)
 static void do_Close(DHT *dht)
 {
     uint8_t not_killed = do_ping_and_sendnode_requests(dht, &dht->close_lastgetnodes, dht->self_public_key,
-                         dht->close_clientlist, LCLIENT_LIST);
+                         dht->close_clientlist, LCLIENT_LIST, &dht->close_bootstrap_times);
 
     if (!not_killed) {
         /* all existing nodes are at least KILL_NODE_TIMEOUT,
@@ -1970,8 +2043,8 @@ static uint32_t have_nodes_closelist(DHT *dht, Node_format *nodes, uint16_t num)
 }
 
 /* Interval in seconds between hardening checks */
-#define HARDENING_INTERVAL 20
-#define HARDEN_TIMEOUT 600
+#define HARDENING_INTERVAL 120
+#define HARDEN_TIMEOUT 1200
 
 /* Handle a received hardening packet */
 static int handle_hardening(void *object, IP_Port source, uint8_t *source_pubkey, uint8_t *packet, uint32_t length)
@@ -2289,7 +2362,7 @@ void do_DHT(DHT *dht)
     do_Close(dht);
     do_DHT_friends(dht);
     do_NAT(dht);
-    do_toping(dht->ping);
+    do_to_ping(dht->ping);
     do_hardening(dht);
 #ifdef ENABLE_ASSOC_DHT