5 files changed, 225 insertions, 215 deletions

diff --git a/auto_tests/TCP_test.c b/auto_tests/TCP_test.c
index 4fdb8a88..d9013378 100644
--- a/auto_tests/TCP_test.c
+++ b/auto_tests/TCP_test.c
@@ -29,9 +29,9 @@ static uint16_t ports[NUM_PORTS] = {1234, 33445, 25643};
 
 START_TEST(test_basic)
 {
-    uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
-    crypto_box_keypair(self_public_key, self_secret_key);
+    uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(self_public_key, self_secret_key);
     TCP_Server *tcp_s = new_TCP_server(1, NUM_PORTS, ports, self_secret_key, NULL);
     ck_assert_msg(tcp_s != NULL, "Failed to create TCP relay server");
     ck_assert_msg(tcp_server_listen_count(tcp_s) == NUM_PORTS, "Failed to bind to all ports");
@@ -45,23 +45,23 @@ START_TEST(test_basic)
     int ret = connect(sock, (struct sockaddr *)&addr6_loopback, sizeof(addr6_loopback));
     ck_assert_msg(ret == 0, "Failed to connect to TCP relay server");
 
-    uint8_t f_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t f_secret_key[crypto_box_SECRETKEYBYTES];
-    uint8_t f_nonce[crypto_box_NONCEBYTES];
-    crypto_box_keypair(f_public_key, f_secret_key);
+    uint8_t f_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t f_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    uint8_t f_nonce[CRYPTO_NONCE_SIZE];
+    crypto_new_keypair(f_public_key, f_secret_key);
     random_nonce(f_nonce);
 
-    uint8_t t_secret_key[crypto_box_SECRETKEYBYTES];
+    uint8_t t_secret_key[CRYPTO_SECRET_KEY_SIZE];
     uint8_t handshake_plain[TCP_HANDSHAKE_PLAIN_SIZE];
-    crypto_box_keypair(handshake_plain, t_secret_key);
-    memcpy(handshake_plain + crypto_box_PUBLICKEYBYTES, f_nonce, crypto_box_NONCEBYTES);
+    crypto_new_keypair(handshake_plain, t_secret_key);
+    memcpy(handshake_plain + CRYPTO_PUBLIC_KEY_SIZE, f_nonce, CRYPTO_NONCE_SIZE);
     uint8_t handshake[TCP_CLIENT_HANDSHAKE_SIZE];
-    memcpy(handshake, f_public_key, crypto_box_PUBLICKEYBYTES);
-    random_nonce(handshake + crypto_box_PUBLICKEYBYTES);
+    memcpy(handshake, f_public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    random_nonce(handshake + CRYPTO_PUBLIC_KEY_SIZE);
 
-    ret = encrypt_data(self_public_key, f_secret_key, handshake + crypto_box_PUBLICKEYBYTES, handshake_plain,
-                       TCP_HANDSHAKE_PLAIN_SIZE, handshake + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES);
-    ck_assert_msg(ret == TCP_CLIENT_HANDSHAKE_SIZE - (crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES),
+    ret = encrypt_data(self_public_key, f_secret_key, handshake + CRYPTO_PUBLIC_KEY_SIZE, handshake_plain,
+                       TCP_HANDSHAKE_PLAIN_SIZE, handshake + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE);
+    ck_assert_msg(ret == TCP_CLIENT_HANDSHAKE_SIZE - (CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE),
                   "Encrypt failed.");
     ck_assert_msg(send(sock, (const char *)handshake, TCP_CLIENT_HANDSHAKE_SIZE - 1, 0) == TCP_CLIENT_HANDSHAKE_SIZE - 1,
                   "send Failed.");
@@ -79,20 +79,20 @@ START_TEST(test_basic)
     uint8_t response[TCP_SERVER_HANDSHAKE_SIZE];
     uint8_t response_plain[TCP_HANDSHAKE_PLAIN_SIZE];
     ck_assert_msg(recv(sock, (char *)response, TCP_SERVER_HANDSHAKE_SIZE, 0) == TCP_SERVER_HANDSHAKE_SIZE, "recv Failed.");
-    ret = decrypt_data(self_public_key, f_secret_key, response, response + crypto_box_NONCEBYTES,
-                       TCP_SERVER_HANDSHAKE_SIZE - crypto_box_NONCEBYTES, response_plain);
+    ret = decrypt_data(self_public_key, f_secret_key, response, response + CRYPTO_NONCE_SIZE,
+                       TCP_SERVER_HANDSHAKE_SIZE - CRYPTO_NONCE_SIZE, response_plain);
     ck_assert_msg(ret == TCP_HANDSHAKE_PLAIN_SIZE, "Decrypt Failed.");
-    uint8_t f_nonce_r[crypto_box_NONCEBYTES];
-    uint8_t f_shared_key[crypto_box_BEFORENMBYTES];
+    uint8_t f_nonce_r[CRYPTO_NONCE_SIZE];
+    uint8_t f_shared_key[CRYPTO_SHARED_KEY_SIZE];
     encrypt_precompute(response_plain, t_secret_key, f_shared_key);
-    memcpy(f_nonce_r, response_plain + crypto_box_BEFORENMBYTES, crypto_box_NONCEBYTES);
+    memcpy(f_nonce_r, response_plain + CRYPTO_SHARED_KEY_SIZE, CRYPTO_NONCE_SIZE);
 
-    uint8_t r_req_p[1 + crypto_box_PUBLICKEYBYTES] = {0};
-    memcpy(r_req_p + 1, f_public_key, crypto_box_PUBLICKEYBYTES);
-    uint8_t r_req[2 + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES];
-    uint16_t size = 1 + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES;
+    uint8_t r_req_p[1 + CRYPTO_PUBLIC_KEY_SIZE] = {0};
+    memcpy(r_req_p + 1, f_public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    uint8_t r_req[2 + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE];
+    uint16_t size = 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE;
     size = htons(size);
-    encrypt_data_symmetric(f_shared_key, f_nonce, r_req_p, 1 + crypto_box_PUBLICKEYBYTES, r_req + 2);
+    encrypt_data_symmetric(f_shared_key, f_nonce, r_req_p, 1 + CRYPTO_PUBLIC_KEY_SIZE, r_req + 2);
     increment_nonce(f_nonce);
     memcpy(r_req, &size, 2);
     uint32_t i;
@@ -107,11 +107,11 @@ START_TEST(test_basic)
     do_TCP_server(tcp_s);
     c_sleep(50);
     uint8_t packet_resp[4096];
-    int recv_data_len = recv(sock, (char *)packet_resp, 2 + 2 + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES, 0);
-    ck_assert_msg(recv_data_len == 2 + 2 + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES,
+    int recv_data_len = recv(sock, (char *)packet_resp, 2 + 2 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE, 0);
+    ck_assert_msg(recv_data_len == 2 + 2 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE,
                   "recv Failed. %u", recv_data_len);
     memcpy(&size, packet_resp, 2);
-    ck_assert_msg(ntohs(size) == 2 + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES, "Wrong packet size.");
+    ck_assert_msg(ntohs(size) == 2 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE, "Wrong packet size.");
     uint8_t packet_resp_plain[4096];
     ret = decrypt_data_symmetric(f_shared_key, f_nonce_r, packet_resp + 2, recv_data_len - 2, packet_resp_plain);
     ck_assert_msg(ret != -1, "decryption failed");
@@ -125,10 +125,10 @@ END_TEST
 
 struct sec_TCP_con {
     sock_t  sock;
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t recv_nonce[crypto_box_NONCEBYTES];
-    uint8_t sent_nonce[crypto_box_NONCEBYTES];
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t recv_nonce[CRYPTO_NONCE_SIZE];
+    uint8_t sent_nonce[CRYPTO_NONCE_SIZE];
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
 };
 
 static struct sec_TCP_con *new_TCP_con(TCP_Server *tcp_s)
@@ -143,21 +143,21 @@ static struct sec_TCP_con *new_TCP_con(TCP_Server *tcp_s)
     int ret = connect(sock, (struct sockaddr *)&addr6_loopback, sizeof(addr6_loopback));
     ck_assert_msg(ret == 0, "Failed to connect to TCP relay server");
 
-    uint8_t f_secret_key[crypto_box_SECRETKEYBYTES];
-    crypto_box_keypair(sec_c->public_key, f_secret_key);
+    uint8_t f_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(sec_c->public_key, f_secret_key);
     random_nonce(sec_c->sent_nonce);
 
-    uint8_t t_secret_key[crypto_box_SECRETKEYBYTES];
+    uint8_t t_secret_key[CRYPTO_SECRET_KEY_SIZE];
     uint8_t handshake_plain[TCP_HANDSHAKE_PLAIN_SIZE];
-    crypto_box_keypair(handshake_plain, t_secret_key);
-    memcpy(handshake_plain + crypto_box_PUBLICKEYBYTES, sec_c->sent_nonce, crypto_box_NONCEBYTES);
+    crypto_new_keypair(handshake_plain, t_secret_key);
+    memcpy(handshake_plain + CRYPTO_PUBLIC_KEY_SIZE, sec_c->sent_nonce, CRYPTO_NONCE_SIZE);
     uint8_t handshake[TCP_CLIENT_HANDSHAKE_SIZE];
-    memcpy(handshake, sec_c->public_key, crypto_box_PUBLICKEYBYTES);
-    random_nonce(handshake + crypto_box_PUBLICKEYBYTES);
+    memcpy(handshake, sec_c->public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    random_nonce(handshake + CRYPTO_PUBLIC_KEY_SIZE);
 
-    ret = encrypt_data(tcp_server_public_key(tcp_s), f_secret_key, handshake + crypto_box_PUBLICKEYBYTES, handshake_plain,
-                       TCP_HANDSHAKE_PLAIN_SIZE, handshake + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES);
-    ck_assert_msg(ret == TCP_CLIENT_HANDSHAKE_SIZE - (crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES),
+    ret = encrypt_data(tcp_server_public_key(tcp_s), f_secret_key, handshake + CRYPTO_PUBLIC_KEY_SIZE, handshake_plain,
+                       TCP_HANDSHAKE_PLAIN_SIZE, handshake + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE);
+    ck_assert_msg(ret == TCP_CLIENT_HANDSHAKE_SIZE - (CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE),
                   "Encrypt failed.");
     ck_assert_msg(send(sock, (const char *)handshake, TCP_CLIENT_HANDSHAKE_SIZE - 1, 0) == TCP_CLIENT_HANDSHAKE_SIZE - 1,
                   "send Failed.");
@@ -169,11 +169,11 @@ static struct sec_TCP_con *new_TCP_con(TCP_Server *tcp_s)
     uint8_t response[TCP_SERVER_HANDSHAKE_SIZE];
     uint8_t response_plain[TCP_HANDSHAKE_PLAIN_SIZE];
     ck_assert_msg(recv(sock, (char *)response, TCP_SERVER_HANDSHAKE_SIZE, 0) == TCP_SERVER_HANDSHAKE_SIZE, "recv Failed.");
-    ret = decrypt_data(tcp_server_public_key(tcp_s), f_secret_key, response, response + crypto_box_NONCEBYTES,
-                       TCP_SERVER_HANDSHAKE_SIZE - crypto_box_NONCEBYTES, response_plain);
+    ret = decrypt_data(tcp_server_public_key(tcp_s), f_secret_key, response, response + CRYPTO_NONCE_SIZE,
+                       TCP_SERVER_HANDSHAKE_SIZE - CRYPTO_NONCE_SIZE, response_plain);
     ck_assert_msg(ret == TCP_HANDSHAKE_PLAIN_SIZE, "Decrypt Failed.");
     encrypt_precompute(response_plain, t_secret_key, sec_c->shared_key);
-    memcpy(sec_c->recv_nonce, response_plain + crypto_box_BEFORENMBYTES, crypto_box_NONCEBYTES);
+    memcpy(sec_c->recv_nonce, response_plain + CRYPTO_SHARED_KEY_SIZE, CRYPTO_NONCE_SIZE);
     sec_c->sock = sock;
     return sec_c;
 }
@@ -186,9 +186,9 @@ static void kill_TCP_con(struct sec_TCP_con *con)
 
 static int write_packet_TCP_secure_connection(struct sec_TCP_con *con, uint8_t *data, uint16_t length)
 {
-    uint8_t packet[sizeof(uint16_t) + length + crypto_box_MACBYTES];
+    uint8_t packet[sizeof(uint16_t) + length + CRYPTO_MAC_SIZE];
 
-    uint16_t c_length = htons(length + crypto_box_MACBYTES);
+    uint16_t c_length = htons(length + CRYPTO_MAC_SIZE);
     memcpy(packet, &c_length, sizeof(uint16_t));
     int len = encrypt_data_symmetric(con->shared_key, con->sent_nonce, data, length, packet + sizeof(uint16_t));
 
@@ -214,9 +214,9 @@ static int read_packet_sec_TCP(struct sec_TCP_con *con, uint8_t *data, uint16_t
 
 START_TEST(test_some)
 {
-    uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
-    crypto_box_keypair(self_public_key, self_secret_key);
+    uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(self_public_key, self_secret_key);
     TCP_Server *tcp_s = new_TCP_server(1, NUM_PORTS, ports, self_secret_key, NULL);
     ck_assert_msg(tcp_s != NULL, "Failed to create TCP relay server");
     ck_assert_msg(tcp_server_listen_count(tcp_s) == NUM_PORTS, "Failed to bind to all ports");
@@ -225,22 +225,22 @@ START_TEST(test_some)
     struct sec_TCP_con *con2 = new_TCP_con(tcp_s);
     struct sec_TCP_con *con3 = new_TCP_con(tcp_s);
 
-    uint8_t requ_p[1 + crypto_box_PUBLICKEYBYTES];
+    uint8_t requ_p[1 + CRYPTO_PUBLIC_KEY_SIZE];
     requ_p[0] = 0;
-    memcpy(requ_p + 1, con3->public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(requ_p + 1, con3->public_key, CRYPTO_PUBLIC_KEY_SIZE);
     write_packet_TCP_secure_connection(con1, requ_p, sizeof(requ_p));
-    memcpy(requ_p + 1, con1->public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(requ_p + 1, con1->public_key, CRYPTO_PUBLIC_KEY_SIZE);
     write_packet_TCP_secure_connection(con3, requ_p, sizeof(requ_p));
     do_TCP_server(tcp_s);
     c_sleep(50);
     uint8_t data[2048];
-    int len = read_packet_sec_TCP(con1, data, 2 + 1 + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES);
-    ck_assert_msg(len == 1 + 1 + crypto_box_PUBLICKEYBYTES, "wrong len %u", len);
+    int len = read_packet_sec_TCP(con1, data, 2 + 1 + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE);
+    ck_assert_msg(len == 1 + 1 + CRYPTO_PUBLIC_KEY_SIZE, "wrong len %u", len);
     ck_assert_msg(data[0] == 1, "wrong packet id %u", data[0]);
     ck_assert_msg(data[1] == 16, "connection not refused %u", data[1]);
     ck_assert_msg(public_key_cmp(data + 2, con3->public_key) == 0, "key in packet wrong");
-    len = read_packet_sec_TCP(con3, data, 2 + 1 + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES);
-    ck_assert_msg(len == 1 + 1 + crypto_box_PUBLICKEYBYTES, "wrong len %u", len);
+    len = read_packet_sec_TCP(con3, data, 2 + 1 + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE);
+    ck_assert_msg(len == 1 + 1 + CRYPTO_PUBLIC_KEY_SIZE, "wrong len %u", len);
     ck_assert_msg(data[0] == 1, "wrong packet id %u", data[0]);
     ck_assert_msg(data[1] == 16, "connection not refused %u", data[1]);
     ck_assert_msg(public_key_cmp(data + 2, con1->public_key) == 0, "key in packet wrong");
@@ -252,23 +252,23 @@ START_TEST(test_some)
     c_sleep(50);
     do_TCP_server(tcp_s);
     c_sleep(50);
-    len = read_packet_sec_TCP(con1, data, 2 + 2 + crypto_box_MACBYTES);
+    len = read_packet_sec_TCP(con1, data, 2 + 2 + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == 2, "wrong len %u", len);
     ck_assert_msg(data[0] == 2, "wrong packet id %u", data[0]);
     ck_assert_msg(data[1] == 16, "wrong peer id %u", data[1]);
-    len = read_packet_sec_TCP(con3, data, 2 + 2 + crypto_box_MACBYTES);
+    len = read_packet_sec_TCP(con3, data, 2 + 2 + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == 2, "wrong len %u", len);
     ck_assert_msg(data[0] == 2, "wrong packet id %u", data[0]);
     ck_assert_msg(data[1] == 16, "wrong peer id %u", data[1]);
-    len = read_packet_sec_TCP(con1, data, 2 + sizeof(test_packet) + crypto_box_MACBYTES);
+    len = read_packet_sec_TCP(con1, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %u", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
-    len = read_packet_sec_TCP(con1, data, 2 + sizeof(test_packet) + crypto_box_MACBYTES);
+    len = read_packet_sec_TCP(con1, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %u", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
-    len = read_packet_sec_TCP(con1, data, 2 + sizeof(test_packet) + crypto_box_MACBYTES);
+    len = read_packet_sec_TCP(con1, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %u", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
@@ -278,15 +278,15 @@ START_TEST(test_some)
     c_sleep(50);
     do_TCP_server(tcp_s);
     c_sleep(50);
-    len = read_packet_sec_TCP(con3, data, 2 + sizeof(test_packet) + crypto_box_MACBYTES);
+    len = read_packet_sec_TCP(con3, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %u", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
-    len = read_packet_sec_TCP(con3, data, 2 + sizeof(test_packet) + crypto_box_MACBYTES);
+    len = read_packet_sec_TCP(con3, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %u", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
-    len = read_packet_sec_TCP(con3, data, 2 + sizeof(test_packet) + crypto_box_MACBYTES);
+    len = read_packet_sec_TCP(con3, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %u", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
@@ -296,7 +296,7 @@ START_TEST(test_some)
     c_sleep(50);
     do_TCP_server(tcp_s);
     c_sleep(50);
-    len = read_packet_sec_TCP(con1, data, 2 + sizeof(ping_packet) + crypto_box_MACBYTES);
+    len = read_packet_sec_TCP(con1, data, 2 + sizeof(ping_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(ping_packet), "wrong len %u", len);
     ck_assert_msg(data[0] == 5, "wrong packet id %u", data[0]);
     ck_assert_msg(memcmp(ping_packet + 1, data + 1, sizeof(uint64_t)) == 0, "wrong packet data");
@@ -309,7 +309,7 @@ END_TEST
 
 static int response_callback_good;
 static uint8_t response_callback_connection_id;
-static uint8_t response_callback_public_key[crypto_box_PUBLICKEYBYTES];
+static uint8_t response_callback_public_key[CRYPTO_PUBLIC_KEY_SIZE];
 static int response_callback(void *object, uint8_t connection_id, const uint8_t *public_key)
 {
     if (set_tcp_connection_number((TCP_Client_Connection *)((char *)object - 2), connection_id, 7) != 0) {
@@ -317,7 +317,7 @@ static int response_callback(void *object, uint8_t connection_id, const uint8_t
     }
 
     response_callback_connection_id = connection_id;
-    memcpy(response_callback_public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(response_callback_public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
     response_callback_good++;
     return 0;
 }
@@ -364,7 +364,7 @@ static int data_callback(void *object, uint32_t number, uint8_t connection_id, c
 }
 
 static int oob_data_callback_good;
-static uint8_t oob_pubkey[crypto_box_PUBLICKEYBYTES];
+static uint8_t oob_pubkey[CRYPTO_PUBLIC_KEY_SIZE];
 static int oob_data_callback(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length,
                              void *userdata)
 {
@@ -391,16 +391,16 @@ static int oob_data_callback(void *object, const uint8_t *public_key, const uint
 START_TEST(test_client)
 {
     unix_time_update();
-    uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
-    crypto_box_keypair(self_public_key, self_secret_key);
+    uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(self_public_key, self_secret_key);
     TCP_Server *tcp_s = new_TCP_server(1, NUM_PORTS, ports, self_secret_key, NULL);
     ck_assert_msg(tcp_s != NULL, "Failed to create TCP relay server");
     ck_assert_msg(tcp_server_listen_count(tcp_s) == NUM_PORTS, "Failed to bind to all ports");
 
-    uint8_t f_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t f_secret_key[crypto_box_SECRETKEYBYTES];
-    crypto_box_keypair(f_public_key, f_secret_key);
+    uint8_t f_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t f_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(f_public_key, f_secret_key);
     IP_Port ip_port_tcp_s;
 
     ip_port_tcp_s.port = htons(ports[rand() % NUM_PORTS]);
@@ -430,9 +430,9 @@ START_TEST(test_client)
     ck_assert_msg(conn->status == TCP_CLIENT_CONFIRMED, "Wrong status. Expected: %u, is: %u", TCP_CLIENT_CONFIRMED,
                   conn->status);
 
-    uint8_t f2_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t f2_secret_key[crypto_box_SECRETKEYBYTES];
-    crypto_box_keypair(f2_public_key, f2_secret_key);
+    uint8_t f2_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t f2_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(f2_public_key, f2_secret_key);
     ip_port_tcp_s.port = htons(ports[rand() % NUM_PORTS]);
     TCP_Client_Connection *conn2 = new_TCP_connection(ip_port_tcp_s, self_public_key, f2_public_key, f2_secret_key, 0);
     routing_response_handler(conn, response_callback, (char *)conn + 2);
@@ -450,7 +450,7 @@ START_TEST(test_client)
     do_TCP_connection(conn2, NULL);
     c_sleep(50);
     uint8_t data[5] = {1, 2, 3, 4, 5};
-    memcpy(oob_pubkey, f2_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(oob_pubkey, f2_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     send_oob_packet(conn2, f_public_key, data, 5);
     send_routing_request(conn, f2_public_key);
     send_routing_request(conn2, f_public_key);
@@ -492,13 +492,13 @@ END_TEST
 START_TEST(test_client_invalid)
 {
     unix_time_update();
-    uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
-    crypto_box_keypair(self_public_key, self_secret_key);
+    uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(self_public_key, self_secret_key);
 
-    uint8_t f_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t f_secret_key[crypto_box_SECRETKEYBYTES];
-    crypto_box_keypair(f_public_key, f_secret_key);
+    uint8_t f_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t f_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(f_public_key, f_secret_key);
     IP_Port ip_port_tcp_s;
 
     ip_port_tcp_s.port = htons(ports[rand() % NUM_PORTS]);
@@ -552,19 +552,19 @@ START_TEST(test_tcp_connection)
 {
     tcp_data_callback_called = 0;
     unix_time_update();
-    uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
-    crypto_box_keypair(self_public_key, self_secret_key);
+    uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(self_public_key, self_secret_key);
     TCP_Server *tcp_s = new_TCP_server(1, NUM_PORTS, ports, self_secret_key, NULL);
     ck_assert_msg(public_key_cmp(tcp_server_public_key(tcp_s), self_public_key) == 0, "Wrong public key");
 
     TCP_Proxy_Info proxy_info;
     proxy_info.proxy_type = TCP_PROXY_NONE;
-    crypto_box_keypair(self_public_key, self_secret_key);
+    crypto_new_keypair(self_public_key, self_secret_key);
     TCP_Connections *tc_1 = new_tcp_connections(self_secret_key, &proxy_info);
     ck_assert_msg(public_key_cmp(tcp_connections_public_key(tc_1), self_public_key) == 0, "Wrong public key");
 
-    crypto_box_keypair(self_public_key, self_secret_key);
+    crypto_new_keypair(self_public_key, self_secret_key);
     TCP_Connections *tc_2 = new_tcp_connections(self_secret_key, &proxy_info);
     ck_assert_msg(public_key_cmp(tcp_connections_public_key(tc_2), self_public_key) == 0, "Wrong public key");
 
@@ -661,19 +661,19 @@ START_TEST(test_tcp_connection2)
     tcp_data_callback_called = 0;
 
     unix_time_update();
-    uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
-    crypto_box_keypair(self_public_key, self_secret_key);
+    uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(self_public_key, self_secret_key);
     TCP_Server *tcp_s = new_TCP_server(1, NUM_PORTS, ports, self_secret_key, NULL);
     ck_assert_msg(public_key_cmp(tcp_server_public_key(tcp_s), self_public_key) == 0, "Wrong public key");
 
     TCP_Proxy_Info proxy_info;
     proxy_info.proxy_type = TCP_PROXY_NONE;
-    crypto_box_keypair(self_public_key, self_secret_key);
+    crypto_new_keypair(self_public_key, self_secret_key);
     TCP_Connections *tc_1 = new_tcp_connections(self_secret_key, &proxy_info);
     ck_assert_msg(public_key_cmp(tcp_connections_public_key(tc_1), self_public_key) == 0, "Wrong public key");
 
-    crypto_box_keypair(self_public_key, self_secret_key);
+    crypto_new_keypair(self_public_key, self_secret_key);
     TCP_Connections *tc_2 = new_tcp_connections(self_secret_key, &proxy_info);
     ck_assert_msg(public_key_cmp(tcp_connections_public_key(tc_2), self_public_key) == 0, "Wrong public key");
 
diff --git a/auto_tests/crypto_test.c b/auto_tests/crypto_test.c
index ce2101cc..c1003f80 100644
--- a/auto_tests/crypto_test.c
+++ b/auto_tests/crypto_test.c
@@ -91,8 +91,8 @@ START_TEST(test_known)
     unsigned char m[131];
     int clen, mlen;
 
-    ck_assert_msg(sizeof(c) == sizeof(m) + crypto_box_MACBYTES * sizeof(unsigned char),
-                  "cyphertext should be crypto_box_MACBYTES bytes longer than plaintext");
+    ck_assert_msg(sizeof(c) == sizeof(m) + CRYPTO_MAC_SIZE * sizeof(unsigned char),
+                  "cyphertext should be CRYPTO_MAC_SIZE bytes longer than plaintext");
     ck_assert_msg(sizeof(test_c) == sizeof(c), "sanity check failed");
     ck_assert_msg(sizeof(test_m) == sizeof(m), "sanity check failed");
 
@@ -110,15 +110,15 @@ END_TEST
 
 START_TEST(test_fast_known)
 {
-    unsigned char k[crypto_box_BEFORENMBYTES];
+    unsigned char k[CRYPTO_SHARED_KEY_SIZE];
     unsigned char c[147];
     unsigned char m[131];
     int clen, mlen;
 
     encrypt_precompute(bobpk, alicesk, k);
 
-    ck_assert_msg(sizeof(c) == sizeof(m) + crypto_box_MACBYTES * sizeof(unsigned char),
-                  "cyphertext should be crypto_box_MACBYTES bytes longer than plaintext");
+    ck_assert_msg(sizeof(c) == sizeof(m) + CRYPTO_MAC_SIZE * sizeof(unsigned char),
+                  "cyphertext should be CRYPTO_MAC_SIZE bytes longer than plaintext");
     ck_assert_msg(sizeof(test_c) == sizeof(c), "sanity check failed");
     ck_assert_msg(sizeof(test_m) == sizeof(m), "sanity check failed");
 
@@ -136,20 +136,20 @@ END_TEST
 
 START_TEST(test_endtoend)
 {
-    unsigned char pk1[crypto_box_PUBLICKEYBYTES];
-    unsigned char sk1[crypto_box_SECRETKEYBYTES];
-    unsigned char pk2[crypto_box_PUBLICKEYBYTES];
-    unsigned char sk2[crypto_box_SECRETKEYBYTES];
-    unsigned char k1[crypto_box_BEFORENMBYTES];
-    unsigned char k2[crypto_box_BEFORENMBYTES];
+    unsigned char pk1[CRYPTO_PUBLIC_KEY_SIZE];
+    unsigned char sk1[CRYPTO_SECRET_KEY_SIZE];
+    unsigned char pk2[CRYPTO_PUBLIC_KEY_SIZE];
+    unsigned char sk2[CRYPTO_SECRET_KEY_SIZE];
+    unsigned char k1[CRYPTO_SHARED_KEY_SIZE];
+    unsigned char k2[CRYPTO_SHARED_KEY_SIZE];
 
-    unsigned char n[crypto_box_NONCEBYTES];
+    unsigned char n[CRYPTO_NONCE_SIZE];
 
     unsigned char m[500];
-    unsigned char c1[sizeof(m) + crypto_box_MACBYTES];
-    unsigned char c2[sizeof(m) + crypto_box_MACBYTES];
-    unsigned char c3[sizeof(m) + crypto_box_MACBYTES];
-    unsigned char c4[sizeof(m) + crypto_box_MACBYTES];
+    unsigned char c1[sizeof(m) + CRYPTO_MAC_SIZE];
+    unsigned char c2[sizeof(m) + CRYPTO_MAC_SIZE];
+    unsigned char c3[sizeof(m) + CRYPTO_MAC_SIZE];
+    unsigned char c4[sizeof(m) + CRYPTO_MAC_SIZE];
     unsigned char m1[sizeof(m)];
     unsigned char m2[sizeof(m)];
     unsigned char m3[sizeof(m)];
@@ -166,17 +166,17 @@ START_TEST(test_endtoend)
         //Generate random message (random length from 100 to 500)
         mlen = (rand() % 400) + 100;
         rand_bytes(m, mlen);
-        rand_bytes(n, crypto_box_NONCEBYTES);
+        rand_bytes(n, CRYPTO_NONCE_SIZE);
 
         //Generate keypairs
-        crypto_box_keypair(pk1, sk1);
-        crypto_box_keypair(pk2, sk2);
+        crypto_new_keypair(pk1, sk1);
+        crypto_new_keypair(pk2, sk2);
 
         //Precompute shared keys
         encrypt_precompute(pk2, sk1, k1);
         encrypt_precompute(pk1, sk2, k2);
 
-        ck_assert_msg(memcmp(k1, k2, crypto_box_BEFORENMBYTES) == 0, "encrypt_precompute: bad");
+        ck_assert_msg(memcmp(k1, k2, CRYPTO_SHARED_KEY_SIZE) == 0, "encrypt_precompute: bad");
 
         //Encrypt all four ways
         c1len = encrypt_data(pk2, sk1, n, m, mlen, c1);
@@ -185,7 +185,7 @@ START_TEST(test_endtoend)
         c4len = encrypt_data_symmetric(k2, n, m, mlen, c4);
 
         ck_assert_msg(c1len == c2len && c1len == c3len && c1len == c4len, "cyphertext lengths differ");
-        ck_assert_msg(c1len == mlen + (int)crypto_box_MACBYTES, "wrong cyphertext length");
+        ck_assert_msg(c1len == mlen + (int)CRYPTO_MAC_SIZE, "wrong cyphertext length");
         ck_assert_msg(memcmp(c1, c2, c1len) == 0 && memcmp(c1, c3, c1len) == 0
                       && memcmp(c1, c4, c1len) == 0, "crypertexts differ");
 
@@ -206,16 +206,16 @@ END_TEST
 
 START_TEST(test_large_data)
 {
-    unsigned char k[crypto_box_BEFORENMBYTES];
+    unsigned char k[CRYPTO_SHARED_KEY_SIZE];
 
-    unsigned char n[crypto_box_NONCEBYTES];
+    unsigned char n[CRYPTO_NONCE_SIZE];
 
-    unsigned char m1[MAX_CRYPTO_PACKET_SIZE - crypto_box_MACBYTES];
-    unsigned char c1[sizeof(m1) + crypto_box_MACBYTES];
+    unsigned char m1[MAX_CRYPTO_PACKET_SIZE - CRYPTO_MAC_SIZE];
+    unsigned char c1[sizeof(m1) + CRYPTO_MAC_SIZE];
     unsigned char m1prime[sizeof(m1)];
 
     unsigned char m2[MAX_CRYPTO_PACKET_SIZE];
-    unsigned char c2[sizeof(m2) + crypto_box_MACBYTES];
+    unsigned char c2[sizeof(m2) + CRYPTO_MAC_SIZE];
 
     int c1len, c2len;
     int m1plen;
@@ -223,16 +223,16 @@ START_TEST(test_large_data)
     //Generate random messages
     rand_bytes(m1, sizeof(m1));
     rand_bytes(m2, sizeof(m2));
-    rand_bytes(n, crypto_box_NONCEBYTES);
+    rand_bytes(n, CRYPTO_NONCE_SIZE);
 
     //Generate key
-    rand_bytes(k, crypto_box_BEFORENMBYTES);
+    rand_bytes(k, CRYPTO_SHARED_KEY_SIZE);
 
     c1len = encrypt_data_symmetric(k, n, m1, sizeof(m1), c1);
     c2len = encrypt_data_symmetric(k, n, m2, sizeof(m2), c2);
 
-    ck_assert_msg(c1len == sizeof(m1) + crypto_box_MACBYTES, "could not encrypt");
-    ck_assert_msg(c2len == sizeof(m2) + crypto_box_MACBYTES, "could not encrypt");
+    ck_assert_msg(c1len == sizeof(m1) + CRYPTO_MAC_SIZE, "could not encrypt");
+    ck_assert_msg(c2len == sizeof(m2) + CRYPTO_MAC_SIZE, "could not encrypt");
 
     m1plen = decrypt_data_symmetric(k, n, c1, c1len, m1prime);
 
@@ -243,12 +243,12 @@ END_TEST
 
 START_TEST(test_large_data_symmetric)
 {
-    unsigned char k[crypto_box_KEYBYTES];
+    unsigned char k[CRYPTO_SYMMETRIC_KEY_SIZE];
 
-    unsigned char n[crypto_box_NONCEBYTES];
+    unsigned char n[CRYPTO_NONCE_SIZE];
 
     unsigned char m1[16 * 16 * 16];
-    unsigned char c1[sizeof(m1) + crypto_box_MACBYTES];
+    unsigned char c1[sizeof(m1) + CRYPTO_MAC_SIZE];
     unsigned char m1prime[sizeof(m1)];
 
     int c1len;
@@ -256,13 +256,13 @@ START_TEST(test_large_data_symmetric)
 
     //Generate random messages
     rand_bytes(m1, sizeof(m1));
-    rand_bytes(n, crypto_box_NONCEBYTES);
+    rand_bytes(n, CRYPTO_NONCE_SIZE);
 
     //Generate key
     new_symmetric_key(k);
 
     c1len = encrypt_data_symmetric(k, n, m1, sizeof(m1), c1);
-    ck_assert_msg(c1len == sizeof(m1) + crypto_box_MACBYTES, "could not encrypt data");
+    ck_assert_msg(c1len == sizeof(m1) + CRYPTO_MAC_SIZE, "could not encrypt data");
 
     m1plen = decrypt_data_symmetric(k, n, c1, c1len, m1prime);
 
@@ -274,14 +274,14 @@ END_TEST
 static void increment_nonce_number_cmp(uint8_t *nonce, uint32_t num)
 {
     uint32_t num1, num2;
-    memcpy(&num1, nonce + (crypto_box_NONCEBYTES - sizeof(num1)), sizeof(num1));
+    memcpy(&num1, nonce + (CRYPTO_NONCE_SIZE - sizeof(num1)), sizeof(num1));
     num1 = ntohl(num1);
     num2 = num + num1;
 
     if (num2 < num1) {
         uint32_t i;
 
-        for (i = crypto_box_NONCEBYTES - sizeof(num1); i != 0; --i) {
+        for (i = CRYPTO_NONCE_SIZE - sizeof(num1); i != 0; --i) {
             ++nonce[i - 1];
 
             if (nonce[i - 1] != 0) {
@@ -291,34 +291,34 @@ static void increment_nonce_number_cmp(uint8_t *nonce, uint32_t num)
     }
 
     num2 = htonl(num2);
-    memcpy(nonce + (crypto_box_NONCEBYTES - sizeof(num2)), &num2, sizeof(num2));
+    memcpy(nonce + (CRYPTO_NONCE_SIZE - sizeof(num2)), &num2, sizeof(num2));
 }
 
 START_TEST(test_increment_nonce)
 {
     long long unsigned int i;
 
-    uint8_t n[crypto_box_NONCEBYTES];
+    uint8_t n[CRYPTO_NONCE_SIZE];
 
-    for (i = 0; i < crypto_box_NONCEBYTES; ++i) {
+    for (i = 0; i < CRYPTO_NONCE_SIZE; ++i) {
         n[i] = rand();
     }
 
-    uint8_t n1[crypto_box_NONCEBYTES];
+    uint8_t n1[CRYPTO_NONCE_SIZE];
 
-    memcpy(n1, n, crypto_box_NONCEBYTES);
+    memcpy(n1, n, CRYPTO_NONCE_SIZE);
 
     for (i = 0; i < (1 << 18); ++i) {
         increment_nonce_number_cmp(n, 1);
         increment_nonce(n1);
-        ck_assert_msg(memcmp(n, n1, crypto_box_NONCEBYTES) == 0, "Bad increment_nonce function");
+        ck_assert_msg(memcmp(n, n1, CRYPTO_NONCE_SIZE) == 0, "Bad increment_nonce function");
     }
 
     for (i = 0; i < (1 << 18); ++i) {
         uint32_t r = rand();
         increment_nonce_number_cmp(n, r);
         increment_nonce_number(n1, r);
-        ck_assert_msg(memcmp(n, n1, crypto_box_NONCEBYTES) == 0, "Bad increment_nonce_number function");
+        ck_assert_msg(memcmp(n, n1, CRYPTO_NONCE_SIZE) == 0, "Bad increment_nonce_number function");
     }
 }
 END_TEST
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;
 }
 
diff --git a/auto_tests/encryptsave_test.c b/auto_tests/encryptsave_test.c
index 895d129b..ec98797c 100644
--- a/auto_tests/encryptsave_test.c
+++ b/auto_tests/encryptsave_test.c
@@ -17,6 +17,8 @@
 #include "../toxencryptsave/toxencryptsave.h"
 #ifdef VANILLA_NACL
 #include "../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_pwhash_scryptsalsa208sha256.h"
+#else
+#include <sodium.h>
 #endif
 
 static unsigned char test_salt[TOX_PASS_SALT_LENGTH] = {0xB1, 0xC2, 0x09, 0xEE, 0x50, 0x6C, 0xF0, 0x20, 0xC4, 0xD6, 0xEB, 0xC0, 0x44, 0x51, 0x3B, 0x60, 0x4B, 0x39, 0x4A, 0xCF, 0x09, 0x53, 0x4F, 0xEA, 0x08, 0x41, 0xFA, 0xCA, 0x66, 0xD2, 0x68, 0x7F};
@@ -24,7 +26,7 @@ static unsigned char known_key[TOX_PASS_KEY_LENGTH] = {0x29, 0x36, 0x1c, 0x9e, 0
 static const char *pw = "hunter2";
 static unsigned int pwlen = 7;
 
-static unsigned char known_key2[crypto_box_BEFORENMBYTES] = {0x7a, 0xfa, 0x95, 0x45, 0x36, 0x8a, 0xa2, 0x5c, 0x40, 0xfd, 0xc0, 0xe2, 0x35, 0x8, 0x7, 0x88, 0xfa, 0xf9, 0x37, 0x86, 0xeb, 0xff, 0x50, 0x4f, 0x3, 0xe2, 0xf6, 0xd9, 0xef, 0x9, 0x17, 0x1};
+static unsigned char known_key2[CRYPTO_SHARED_KEY_SIZE] = {0x7a, 0xfa, 0x95, 0x45, 0x36, 0x8a, 0xa2, 0x5c, 0x40, 0xfd, 0xc0, 0xe2, 0x35, 0x8, 0x7, 0x88, 0xfa, 0xf9, 0x37, 0x86, 0xeb, 0xff, 0x50, 0x4f, 0x3, 0xe2, 0xf6, 0xd9, 0xef, 0x9, 0x17, 0x1};
 // same as above, except standard opslimit instead of extra ops limit for test_known_kdf, and hash pw before kdf for compat
 
 /* cause I'm shameless */
@@ -41,16 +43,16 @@ static void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8
 
 START_TEST(test_known_kdf)
 {
-    unsigned char out[crypto_box_BEFORENMBYTES];
+    unsigned char out[CRYPTO_SHARED_KEY_SIZE];
     int res = crypto_pwhash_scryptsalsa208sha256(out,
-              crypto_box_BEFORENMBYTES,
+              CRYPTO_SHARED_KEY_SIZE,
               pw,
               pwlen,
               test_salt,
               crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE * 8,
               crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE);
     ck_assert_msg(res != -1, "crypto function failed");
-    ck_assert_msg(memcmp(out, known_key, crypto_box_BEFORENMBYTES) == 0, "derived key is wrong");
+    ck_assert_msg(memcmp(out, known_key, CRYPTO_SHARED_KEY_SIZE) == 0, "derived key is wrong");
 }
 END_TEST
 
diff --git a/auto_tests/onion_test.c b/auto_tests/onion_test.c
index 329d7371..44ea9c7d 100644
--- a/auto_tests/onion_test.c
+++ b/auto_tests/onion_test.c
@@ -75,22 +75,24 @@ void print_client_id(uint8_t *client_id, uint32_t length)
 #endif
 static uint8_t sb_data[ONION_ANNOUNCE_SENDBACK_DATA_LENGTH];
 static int handled_test_3;
-static uint8_t test_3_pub_key[crypto_box_PUBLICKEYBYTES];
-static uint8_t test_3_ping_id[crypto_hash_sha256_BYTES];
+static uint8_t test_3_pub_key[CRYPTO_PUBLIC_KEY_SIZE];
+static uint8_t test_3_ping_id[CRYPTO_SHA256_SIZE];
 static int handle_test_3(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
     Onion *onion = (Onion *)object;
 
-    if (length != (1 + crypto_box_NONCEBYTES + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + 1 + crypto_hash_sha256_BYTES +
-                   crypto_box_MACBYTES)) {
+    if (length != (1 + CRYPTO_NONCE_SIZE + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + 1 + CRYPTO_SHA256_SIZE +
+                   CRYPTO_MAC_SIZE)) {
         return 1;
     }
 
-    uint8_t plain[1 + crypto_hash_sha256_BYTES];
-    //print_client_id(packet, length);
+    uint8_t plain[1 + CRYPTO_SHA256_SIZE];
+#if 0
+    print_client_id(packet, length);
+#endif
     int len = decrypt_data(test_3_pub_key, onion->dht->self_secret_key, packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH,
-                           packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES,
-                           1 + crypto_hash_sha256_BYTES + crypto_box_MACBYTES, plain);
+                           packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE,
+                           1 + CRYPTO_SHA256_SIZE + CRYPTO_MAC_SIZE, plain);
 
     if (len == -1) {
         return 1;
@@ -101,31 +103,33 @@ static int handle_test_3(void *object, IP_Port source, const uint8_t *packet, ui
         return 1;
     }
 
-    memcpy(test_3_ping_id, plain + 1, crypto_hash_sha256_BYTES);
-    //print_client_id(test_3_ping_id, sizeof(test_3_ping_id));
+    memcpy(test_3_ping_id, plain + 1, CRYPTO_SHA256_SIZE);
+#if 0
+    print_client_id(test_3_ping_id, sizeof(test_3_ping_id));
+#endif
     handled_test_3 = 1;
     return 0;
 }
 
-static uint8_t nonce[crypto_box_NONCEBYTES];
+static uint8_t nonce[CRYPTO_NONCE_SIZE];
 static int handled_test_4;
 static int handle_test_4(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
     Onion *onion = (Onion *)object;
 
-    if (length != (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + sizeof("Install gentoo") +
-                   crypto_box_MACBYTES)) {
+    if (length != (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + sizeof("Install gentoo") +
+                   CRYPTO_MAC_SIZE)) {
         return 1;
     }
 
     uint8_t plain[sizeof("Install gentoo")] = {0};
 
-    if (memcmp(nonce, packet + 1, crypto_box_NONCEBYTES) != 0) {
+    if (memcmp(nonce, packet + 1, CRYPTO_NONCE_SIZE) != 0) {
         return 1;
     }
 
-    int len = decrypt_data(packet + 1 + crypto_box_NONCEBYTES, onion->dht->self_secret_key, packet + 1,
-                           packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES, sizeof("Install gentoo") + crypto_box_MACBYTES, plain);
+    int len = decrypt_data(packet + 1 + CRYPTO_NONCE_SIZE, onion->dht->self_secret_key, packet + 1,
+                           packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE, sizeof("Install gentoo") + CRYPTO_MAC_SIZE, plain);
 
     if (len == -1) {
         return 1;
@@ -151,12 +155,12 @@ START_TEST(test_basic)
 
     IP_Port on1 = {ip, onion1->net->port};
     Node_format n1;
-    memcpy(n1.public_key, onion1->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(n1.public_key, onion1->dht->self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     n1.ip_port = on1;
 
     IP_Port on2 = {ip, onion2->net->port};
     Node_format n2;
-    memcpy(n2.public_key, onion2->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(n2.public_key, onion2->dht->self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     n2.ip_port = on2;
 
     Node_format nodes[4];
@@ -190,10 +194,10 @@ START_TEST(test_basic)
     networking_registerhandler(onion1->net, NET_PACKET_ANNOUNCE_RESPONSE, &handle_test_3, onion1);
     ck_assert_msg((onion1_a != NULL) && (onion2_a != NULL), "Onion_Announce failed initializing.");
     uint8_t zeroes[64] = {0};
-    randombytes(sb_data, sizeof(sb_data));
+    random_bytes(sb_data, sizeof(sb_data));
     uint64_t s;
     memcpy(&s, sb_data, sizeof(uint64_t));
-    memcpy(test_3_pub_key, nodes[3].public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(test_3_pub_key, nodes[3].public_key, CRYPTO_PUBLIC_KEY_SIZE);
     ret = send_announce_request(onion1->net, &path, nodes[3], onion1->dht->self_public_key,
                                 onion1->dht->self_secret_key,
                                 zeroes, onion1->dht->self_public_key, onion1->dht->self_public_key, s);
@@ -206,16 +210,16 @@ START_TEST(test_basic)
         c_sleep(50);
     }
 
-    randombytes(sb_data, sizeof(sb_data));
+    random_bytes(sb_data, sizeof(sb_data));
     memcpy(&s, sb_data, sizeof(uint64_t));
-    memcpy(onion2_a->entries[1].public_key, onion2->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(onion2_a->entries[1].public_key, onion2->dht->self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     onion2_a->entries[1].time = unix_time();
     networking_registerhandler(onion1->net, NET_PACKET_ONION_DATA_RESPONSE, &handle_test_4, onion1);
     send_announce_request(onion1->net, &path, nodes[3], onion1->dht->self_public_key, onion1->dht->self_secret_key,
                           test_3_ping_id, onion1->dht->self_public_key, onion1->dht->self_public_key, s);
 
     while (memcmp(onion2_a->entries[ONION_ANNOUNCE_MAX_ENTRIES - 2].public_key, onion1->dht->self_public_key,
-                  crypto_box_PUBLICKEYBYTES) != 0) {
+                  CRYPTO_PUBLIC_KEY_SIZE) != 0) {
         do_onion(onion1);
         do_onion(onion2);
         c_sleep(50);
@@ -340,8 +344,8 @@ static void dht_ip_callback(void *object, int32_t number, IP_Port ip_port)
 }
 
 static bool first, last;
-static uint8_t first_dht_pk[crypto_box_PUBLICKEYBYTES];
-static uint8_t last_dht_pk[crypto_box_PUBLICKEYBYTES];
+static uint8_t first_dht_pk[CRYPTO_PUBLIC_KEY_SIZE];
+static uint8_t last_dht_pk[CRYPTO_PUBLIC_KEY_SIZE];
 
 static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_public_key, void *userdata)
 {
@@ -355,7 +359,7 @@ static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_pub
         if (NUM_FIRST == number && !first) {
             first = 1;
 
-            if (memcmp(dht_public_key, last_dht_pk, crypto_box_PUBLICKEYBYTES) != 0) {
+            if (memcmp(dht_public_key, last_dht_pk, CRYPTO_PUBLIC_KEY_SIZE) != 0) {
                 ck_abort_msg("Error wrong dht key.");
             }
 
@@ -365,7 +369,7 @@ static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_pub
         if (NUM_LAST == number && !last) {
             last = 1;
 
-            if (memcmp(dht_public_key, first_dht_pk, crypto_box_PUBLICKEYBYTES) != 0) {
+            if (memcmp(dht_public_key, first_dht_pk, CRYPTO_PUBLIC_KEY_SIZE) != 0) {
                 ck_abort_msg("Error wrong dht key.");
             }
 
@@ -422,8 +426,8 @@ START_TEST(test_announce)
         c_sleep(50);
     }
 
-    memcpy(first_dht_pk, onions[NUM_FIRST]->onion->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(last_dht_pk, onions[NUM_LAST]->onion->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(first_dht_pk, onions[NUM_FIRST]->onion->dht->self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(last_dht_pk, onions[NUM_LAST]->onion->dht->self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
 
     printf("adding friend\n");
     int frnum_f = onion_addfriend(onions[NUM_FIRST]->onion_c, onions[NUM_LAST]->onion_c->c->self_public_key);