1 files changed, 47 insertions, 43 deletions

diff --git a/auto_tests/dht_test.c b/auto_tests/dht_test.c
index 11406554..7734e64a 100644
--- a/auto_tests/dht_test.c
+++ b/auto_tests/dht_test.c
@@ -12,7 +12,8 @@
 
 
 // These tests currently fail.
-#if 0
+static bool enable_broken_tests = false;
+
 #define swap(x,y) do \
    { unsigned char swap_temp[sizeof(x) == sizeof(y) ? (signed)sizeof(x) : -1]; \
      memcpy(swap_temp,&y,sizeof(x)); \
@@ -93,14 +94,14 @@ static void test_addto_lists_update(DHT            *dht,
 {
     int used, test, test1, test2, found;
     IP_Port test_ipp;
-    uint8_t test_id[crypto_box_PUBLICKEYBYTES];
+    uint8_t test_id[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t ipv6 = ip_port->ip.family == AF_INET6 ? 1 : 0;
 
     // check id update for existing ip_port
     test = rand() % length;
     ipport_copy(&test_ipp, ipv6 ? &list[test].assoc6.ip_port : &list[test].assoc4.ip_port);
 
-    randombytes(test_id, sizeof(test_id));
+    random_bytes(test_id, sizeof(test_id));
     used = addto_lists(dht, test_ipp, test_id);
     ck_assert_msg(used >= 1, "Wrong number of added clients");
     // it is possible to have ip_port duplicates in the list, so ip_port @ found not always equal to ip_port @ test
@@ -167,11 +168,11 @@ static void test_addto_lists_bad(DHT            *dht,
 {
     // check "bad" clients replacement
     int used, test1, test2, test3;
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES], test_id1[crypto_box_PUBLICKEYBYTES], test_id2[crypto_box_PUBLICKEYBYTES],
-            test_id3[crypto_box_PUBLICKEYBYTES];
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE], test_id1[CRYPTO_PUBLIC_KEY_SIZE], test_id2[CRYPTO_PUBLIC_KEY_SIZE],
+            test_id3[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t ipv6 = ip_port->ip.family == AF_INET6 ? 1 : 0;
 
-    randombytes(public_key, sizeof(public_key));
+    random_bytes(public_key, sizeof(public_key));
     mark_all_good(list, length, ipv6);
 
     test1 = rand() % (length / 3);
@@ -211,11 +212,11 @@ static void test_addto_lists_possible_bad(DHT            *dht,
 {
     // check "possibly bad" clients replacement
     int used, test1, test2, test3;
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES], test_id1[crypto_box_PUBLICKEYBYTES], test_id2[crypto_box_PUBLICKEYBYTES],
-            test_id3[crypto_box_PUBLICKEYBYTES];
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE], test_id1[CRYPTO_PUBLIC_KEY_SIZE], test_id2[CRYPTO_PUBLIC_KEY_SIZE],
+            test_id3[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t ipv6 = ip_port->ip.family == AF_INET6 ? 1 : 0;
 
-    randombytes(public_key, sizeof(public_key));
+    random_bytes(public_key, sizeof(public_key));
     mark_all_good(list, length, ipv6);
 
     test1 = rand() % (length / 3);
@@ -274,14 +275,14 @@ static void test_addto_lists_good(DHT            *dht,
                                   IP_Port        *ip_port,
                                   const uint8_t  *comp_client_id)
 {
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES];
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t ipv6 = ip_port->ip.family == AF_INET6 ? 1 : 0;
 
     mark_all_good(list, length, ipv6);
 
     // check "good" client id replacement
     do {
-        randombytes(public_key, sizeof(public_key));
+        random_bytes(public_key, sizeof(public_key));
     } while (is_furthest(comp_client_id, list, length, public_key));
 
     ip_port->port += 1;
@@ -290,7 +291,7 @@ static void test_addto_lists_good(DHT            *dht,
 
     // check "good" client id skip
     do {
-        randombytes(public_key, sizeof(public_key));
+        random_bytes(public_key, sizeof(public_key));
     } while (!is_furthest(comp_client_id, list, length, public_key));
 
     ip_port->port += 1;
@@ -307,12 +308,12 @@ static void test_addto_lists(IP ip)
     ck_assert_msg(dht != 0, "Failed to create DHT");
 
     IP_Port ip_port = { .ip = ip, .port = TOX_PORT_DEFAULT };
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES];
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
     int i, used;
 
     // check lists filling
     for (i = 0; i < MAX(LCLIENT_LIST, MAX_FRIEND_CLIENTS); ++i) {
-        randombytes(public_key, sizeof(public_key));
+        random_bytes(public_key, sizeof(public_key));
         used = addto_lists(dht, ip_port, public_key);
         ck_assert_msg(used == dht->num_friends + 1, "Wrong number of added clients with existing ip_port");
     }
@@ -325,7 +326,7 @@ static void test_addto_lists(IP ip)
 
     for (i = 0; i < MAX(LCLIENT_LIST, MAX_FRIEND_CLIENTS); ++i) {
         ip_port.port += 1;
-        randombytes(public_key, sizeof(public_key));
+        random_bytes(public_key, sizeof(public_key));
         used = addto_lists(dht, ip_port, public_key);
         ck_assert_msg(used >= 1, "Wrong number of added clients");
     }
@@ -346,13 +347,15 @@ static void test_addto_lists(IP ip)
     }
 
     // check "possibly bad" entries
-    /*
-    test_addto_lists_possible_bad(dht, dht->close_clientlist, LCLIENT_LIST, &ip_port, dht->self_public_key);
+    if (enable_broken_tests) {
+        test_addto_lists_possible_bad(dht, dht->close_clientlist, LCLIENT_LIST, &ip_port, dht->self_public_key);
+
+        for (i = 0; i < dht->num_friends; ++i) {
+            test_addto_lists_possible_bad(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &ip_port,
+                                          dht->friends_list[i].public_key);
+        }
+    }
 
-    for (i = 0; i < dht->num_friends; ++i)
-        test_addto_lists_possible_bad(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &ip_port,
-                                      dht->friends_list[i].public_key);
-    */
     // check "good" entries
     test_addto_lists_good(dht, dht->close_clientlist, LCLIENT_LIST, &ip_port, dht->self_public_key);
 
@@ -379,7 +382,6 @@ START_TEST(test_addto_lists_ipv6)
     test_addto_lists(ip);
 }
 END_TEST
-#endif
 
 #define DHT_DEFAULT_PORT (TOX_PORT_DEFAULT + 20)
 
@@ -389,36 +391,36 @@ static void print_pk(uint8_t *public_key)
 {
     uint32_t j;
 
-    for (j = 0; j < crypto_box_PUBLICKEYBYTES; j++) {
+    for (j = 0; j < CRYPTO_PUBLIC_KEY_SIZE; j++) {
         printf("%02hhX", public_key[j]);
     }
 
     printf("\n");
 }
 
-static void test_add_to_list(uint8_t cmp_list[][crypto_box_PUBLICKEYBYTES + 1],
+static void test_add_to_list(uint8_t cmp_list[][CRYPTO_PUBLIC_KEY_SIZE + 1],
                              unsigned int length, const uint8_t *pk,
                              const uint8_t *cmp_pk)
 {
-    uint8_t p_b[crypto_box_PUBLICKEYBYTES];
+    uint8_t p_b[CRYPTO_PUBLIC_KEY_SIZE];
     unsigned int i;
 
     for (i = 0; i < length; ++i) {
-        if (!cmp_list[i][crypto_box_PUBLICKEYBYTES]) {
-            memcpy(cmp_list[i], pk, crypto_box_PUBLICKEYBYTES);
-            cmp_list[i][crypto_box_PUBLICKEYBYTES] = 1;
+        if (!cmp_list[i][CRYPTO_PUBLIC_KEY_SIZE]) {
+            memcpy(cmp_list[i], pk, CRYPTO_PUBLIC_KEY_SIZE);
+            cmp_list[i][CRYPTO_PUBLIC_KEY_SIZE] = 1;
             return;
         }
 
-        if (memcmp(cmp_list[i], pk, crypto_box_PUBLICKEYBYTES) == 0) {
+        if (memcmp(cmp_list[i], pk, CRYPTO_PUBLIC_KEY_SIZE) == 0) {
             return;
         }
     }
 
     for (i = 0; i < length; ++i) {
         if (id_closest(cmp_pk, cmp_list[i], pk) == 2) {
-            memcpy(p_b, cmp_list[i], crypto_box_PUBLICKEYBYTES);
-            memcpy(cmp_list[i], pk, crypto_box_PUBLICKEYBYTES);
+            memcpy(p_b, cmp_list[i], CRYPTO_PUBLIC_KEY_SIZE);
+            memcpy(cmp_list[i], pk, CRYPTO_PUBLIC_KEY_SIZE);
             test_add_to_list(cmp_list, length, p_b, cmp_pk);
             break;
         }
@@ -431,7 +433,7 @@ static void test_list_main(void)
 {
     DHT *dhts[NUM_DHT];
 
-    uint8_t cmp_list1[NUM_DHT][MAX_FRIEND_CLIENTS][crypto_box_PUBLICKEYBYTES + 1];
+    uint8_t cmp_list1[NUM_DHT][MAX_FRIEND_CLIENTS][CRYPTO_PUBLIC_KEY_SIZE + 1];
     memset(cmp_list1, 0, sizeof(cmp_list1));
 
     unsigned int i, j, k, l;
@@ -480,7 +482,7 @@ static void test_list_main(void)
     for (l = 0; l < NUM_DHT; ++l) {
         for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
             for (j = 1; j < NUM_DHT; ++j) {
-                if (memcmp(cmp_list1[l][i], dhts[(l + j) % NUM_DHT]->self_public_key, crypto_box_PUBLICKEYBYTES) != 0) {
+                if (memcmp(cmp_list1[l][i], dhts[(l + j) % NUM_DHT]->self_public_key, CRYPTO_PUBLIC_KEY_SIZE) != 0) {
                     continue;
                 }
 
@@ -488,7 +490,7 @@ static void test_list_main(void)
 
                 for (k = 0; k < LCLIENT_LIST; ++k) {
                     if (memcmp(dhts[l]->self_public_key, dhts[(l + j) % NUM_DHT]->close_clientlist[k].public_key,
-                               crypto_box_PUBLICKEYBYTES) == 0) {
+                               CRYPTO_PUBLIC_KEY_SIZE) == 0) {
                         ++count;
                     }
                 }
@@ -519,7 +521,7 @@ static void test_list_main(void)
                 count = 0;
 
                 for (k = 0; k < MAX_SENT_NODES; ++k) {
-                    if (memcmp(dhts[l]->self_public_key, ln[k].public_key, crypto_box_PUBLICKEYBYTES) == 0) {
+                    if (memcmp(dhts[l]->self_public_key, ln[k].public_key, CRYPTO_PUBLIC_KEY_SIZE) == 0) {
                         ++count;
                     }
                 }
@@ -653,16 +655,16 @@ END_TEST
 START_TEST(test_dht_create_packet)
 {
     uint8_t plain[100] = {0};
-    uint8_t pkt[1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + sizeof(plain) + crypto_box_MACBYTES];
+    uint8_t pkt[1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + sizeof(plain) + CRYPTO_MAC_SIZE];
 
-    uint8_t key[crypto_box_KEYBYTES];
+    uint8_t key[CRYPTO_SYMMETRIC_KEY_SIZE];
     new_symmetric_key(key);
 
     int length = DHT_create_packet(key, key, NET_PACKET_GET_NODES, plain, sizeof(plain), pkt);
 
     ck_assert_msg(pkt[0] == NET_PACKET_GET_NODES, "Malformed packet.");
-    ck_assert_msg(memcmp(pkt + 1, key, crypto_box_KEYBYTES) == 0, "Malformed packet.");
-    ck_assert_msg(length == 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + sizeof(plain) + crypto_box_MACBYTES,
+    ck_assert_msg(memcmp(pkt + 1, key, CRYPTO_SYMMETRIC_KEY_SIZE) == 0, "Malformed packet.");
+    ck_assert_msg(length == 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + sizeof(plain) + CRYPTO_MAC_SIZE,
                   "Invalid size. Should be %d got %d", sizeof(pkt), length);
 
     printf("Create Packet Successful!\n");
@@ -676,10 +678,12 @@ static Suite *dht_suite(void)
 
     DEFTESTCASE_SLOW(list, 20);
     DEFTESTCASE_SLOW(DHT_test, 50);
-#if 0
-    DEFTESTCASE(addto_lists_ipv4);
-    DEFTESTCASE(addto_lists_ipv6);
-#endif
+
+    if (enable_broken_tests) {
+        DEFTESTCASE(addto_lists_ipv4);
+        DEFTESTCASE(addto_lists_ipv6);
+    }
+
     return s;
 }