ffi-tox 0.1.1 → 0.1.3

data/ProjectTox-Core/auto_tests/dht_test.c

@@ -0,0 +1,362 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <sys/param.h>
+#include <time.h>
+
+#include "../toxcore/tox.h"
+#include "../toxcore/DHT.c"
+
+#include "helpers.h"
+
+#define swap(x,y) do \
+   { unsigned char swap_temp[sizeof(x) == sizeof(y) ? (signed)sizeof(x) : -1]; \
+     memcpy(swap_temp,&y,sizeof(x)); \
+     memcpy(&y,&x,       sizeof(x)); \
+     memcpy(&x,swap_temp,sizeof(x)); \
+    } while(0)
+
+
+void mark_bad(IPPTsPng *ipptp)
+{
+    ipptp->timestamp = unix_time() - 2 * BAD_NODE_TIMEOUT;
+    ipptp->hardening.routes_requests_ok = 0;
+    ipptp->hardening.send_nodes_ok = 0;
+    ipptp->hardening.testing_requests = 0;
+}
+
+void mark_possible_bad(IPPTsPng *ipptp)
+{
+    ipptp->timestamp = unix_time();
+    ipptp->hardening.routes_requests_ok = 0;
+    ipptp->hardening.send_nodes_ok = 0;
+    ipptp->hardening.testing_requests = 0;
+}
+
+void mark_good(IPPTsPng *ipptp)
+{
+    ipptp->timestamp = unix_time();
+    ipptp->hardening.routes_requests_ok = (HARDENING_ALL_OK >> 0) & 1;
+    ipptp->hardening.send_nodes_ok = (HARDENING_ALL_OK >> 1) & 1;
+    ipptp->hardening.testing_requests = (HARDENING_ALL_OK >> 2) & 1;
+}
+
+void mark_all_good(Client_data *list, uint32_t length, uint8_t ipv6)
+{
+    uint32_t i;
+    for (i = 0; i < length; ++i) {
+        if (ipv6)
+            mark_good(&list[i].assoc6);
+        else
+            mark_good(&list[i].assoc4);
+    }
+}
+
+/* Returns 1 if client_id has a furthest distance to comp_client_id
+   than all client_id's  in the list */
+uint8_t is_furthest(const uint8_t *comp_client_id, Client_data *list, uint32_t length, const uint8_t *client_id)
+{
+    uint32_t i;
+    for (i = 0; i < length; ++i)
+        if (id_closest(comp_client_id, client_id, list[i].client_id) == 1)
+            return 0;
+    return 1;
+}
+
+int client_in_list(Client_data *list, uint32_t length, const uint8_t *client_id)
+{
+    int i;
+    for (i = 0; i < (int)length; ++i)
+        if (id_equal(client_id, list[i].client_id))
+            return i;
+    return -1;
+}
+
+void test_addto_lists_update(DHT            *dht,
+                             Client_data    *list,
+                             uint32_t        length,
+                             IP_Port        *ip_port)
+{
+    int used, test, test1, test2, found;
+    IP_Port test_ipp;
+    uint8_t test_id[CLIENT_ID_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));
+    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
+    found = client_in_list(list, length, test_id);
+    ck_assert_msg(found >= 0, "Client id is not in the list");
+    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[found].assoc6.ip_port : &list[found].assoc4.ip_port), "Client IP_Port is incorrect");
+
+    // check ip_port update for existing id
+    test = rand() % length;
+    test_ipp.port = rand() % TOX_PORT_DEFAULT;
+    id_copy(test_id, list[test].client_id);
+
+    used = addto_lists(dht, test_ipp, test_id);
+    ck_assert_msg(used >= 1, "Wrong number of added clients");
+    // it is not possible to have id duplicates in the list, so id @ found must be equal id @ test
+    ck_assert_msg(client_in_list(list, length, test_id) == test, "Client id is not in the list");
+    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[test].assoc6.ip_port : &list[test].assoc4.ip_port), "Client IP_Port is incorrect");
+
+    // check ip_port update for existing id and ip_port (... port ... id ...)
+    test1 = rand() % (length / 2);
+    test2 = rand() % (length / 2) + length / 2;
+
+    ipport_copy(&test_ipp, ipv6 ? &list[test1].assoc6.ip_port : &list[test1].assoc4.ip_port);
+    id_copy(test_id, list[test2].client_id);
+    if (ipv6) list[test2].assoc6.ip_port.port = -1; else list[test2].assoc4.ip_port.port = -1;
+    used = addto_lists(dht, test_ipp, test_id);
+    ck_assert_msg(used >= 1, "Wrong number of added clients");
+    ck_assert_msg(client_in_list(list, length, test_id) == test2, "Client id is not in the list");
+    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[test2].assoc6.ip_port : &list[test2].assoc4.ip_port), "Client IP_Port is incorrect");
+
+    // check ip_port update for existing id and ip_port (... id ... port ...)
+    test1 = rand() % (length / 2);
+    test2 = rand() % (length / 2) + length / 2;
+
+    ipport_copy(&test_ipp, ipv6 ? &list[test2].assoc6.ip_port : &list[test2].assoc4.ip_port);
+    id_copy(test_id, list[test1].client_id);
+    if (ipv6) list[test1].assoc6.ip_port.port = -1; else list[test1].assoc4.ip_port.port = -1;
+    used = addto_lists(dht, test_ipp, test_id);
+    ck_assert_msg(used >= 1, "Wrong number of added clients");
+    ck_assert_msg(client_in_list(list, length, test_id) == test1, "Client id is not in the list");
+    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[test1].assoc6.ip_port : &list[test1].assoc4.ip_port), "Client IP_Port is incorrect");
+}
+
+void test_addto_lists_bad(DHT            *dht,
+                          Client_data    *list,
+                          uint32_t        length,
+                          IP_Port        *ip_port)
+{
+    // check "bad" clients replacement
+    int used, test1, test2, test3;
+    uint8_t client_id[CLIENT_ID_SIZE], test_id1[CLIENT_ID_SIZE], test_id2[CLIENT_ID_SIZE], test_id3[CLIENT_ID_SIZE];
+    uint8_t ipv6 = ip_port->ip.family == AF_INET6 ? 1 : 0;
+
+    randombytes(client_id, sizeof(client_id));
+    mark_all_good(list, length, ipv6);
+
+    test1 = rand() % (length / 3);
+    test2 = rand() % (length / 3) + length / 3;
+    test3 = rand() % (length / 3) + 2 * length / 3;
+    ck_assert_msg(!(test1 == test2 || test1 == test3 || test2 == test3), "Wrong test indices are chosen");
+
+    id_copy((uint8_t*)&test_id1, list[test1].client_id);
+    id_copy((uint8_t*)&test_id2, list[test2].client_id);
+    id_copy((uint8_t*)&test_id3, list[test3].client_id);
+
+    // mark nodes as "bad"
+    if (ipv6) {
+        mark_bad(&list[test1].assoc6);
+        mark_bad(&list[test2].assoc6);
+        mark_bad(&list[test3].assoc6);
+    } else {
+        mark_bad(&list[test1].assoc4);
+        mark_bad(&list[test2].assoc4);
+        mark_bad(&list[test3].assoc4);
+    }
+
+    ip_port->port += 1;
+    used = addto_lists(dht, *ip_port, client_id);
+    ck_assert_msg(used >= 1, "Wrong number of added clients");
+
+    ck_assert_msg(client_in_list(list, length, client_id) >= 0, "Client id is not in the list");
+    ck_assert_msg(id_equal(client_id, list[test1].client_id), "Wrong bad client removed");
+    ck_assert_msg(id_equal(test_id2, list[test2].client_id), "Wrong bad client removed");
+    ck_assert_msg(id_equal(test_id3, list[test3].client_id), "Wrong bad client removed");
+}
+
+void test_addto_lists_possible_bad(DHT            *dht,
+                                   Client_data    *list,
+                                   uint32_t        length,
+                                   IP_Port        *ip_port,
+                                   const uint8_t  *comp_client_id)
+{
+    // check "possibly bad" clients replacement
+    int used, test1, test2, test3;
+    uint8_t client_id[CLIENT_ID_SIZE], test_id1[CLIENT_ID_SIZE], test_id2[CLIENT_ID_SIZE], test_id3[CLIENT_ID_SIZE];
+    uint8_t ipv6 = ip_port->ip.family == AF_INET6 ? 1 : 0;
+
+    randombytes(client_id, sizeof(client_id));
+    mark_all_good(list, length, ipv6);
+
+    test1 = rand() % (length / 3);
+    test2 = rand() % (length / 3) + length / 3;
+    test3 = rand() % (length / 3) + 2 * length / 3;
+    ck_assert_msg(!(test1 == test2 || test1 == test3 || test2 == test3), "Wrong test indices are chosen");
+
+    id_copy((uint8_t*)&test_id1, list[test1].client_id);
+    id_copy((uint8_t*)&test_id2, list[test2].client_id);
+    id_copy((uint8_t*)&test_id3, list[test3].client_id);
+
+    // mark nodes as "possibly bad"
+    if (ipv6) {
+        mark_possible_bad(&list[test1].assoc6);
+        mark_possible_bad(&list[test2].assoc6);
+        mark_possible_bad(&list[test3].assoc6);
+    } else {
+        mark_possible_bad(&list[test1].assoc4);
+        mark_possible_bad(&list[test2].assoc4);
+        mark_possible_bad(&list[test3].assoc4);
+    }
+
+    ip_port->port += 1;
+    used = addto_lists(dht, *ip_port, client_id);
+    ck_assert_msg(used >= 1, "Wrong number of added clients");
+
+    ck_assert_msg(client_in_list(list, length, client_id) >= 0, "Client id is not in the list");
+
+    int inlist_id1 = client_in_list(list, length, test_id1) >= 0;
+    int inlist_id2 = client_in_list(list, length, test_id2) >= 0;
+    int inlist_id3 = client_in_list(list, length, test_id3) >= 0;
+
+    ck_assert_msg(inlist_id1 + inlist_id2 + inlist_id3 == 2, "Wrong client removed");
+
+    if (!inlist_id1) {
+        ck_assert_msg(id_closest(comp_client_id, test_id2, test_id1) == 1, "Id has been removed but is closer to than another one");
+        ck_assert_msg(id_closest(comp_client_id, test_id3, test_id1) == 1, "Id has been removed but is closer to than another one");
+    } else if (!inlist_id2) {
+        ck_assert_msg(id_closest(comp_client_id, test_id1, test_id2) == 1, "Id has been removed but is closer to than another one");
+        ck_assert_msg(id_closest(comp_client_id, test_id3, test_id2) == 1, "Id has been removed but is closer to than another one");
+    } else if (!inlist_id3) {
+        ck_assert_msg(id_closest(comp_client_id, test_id1, test_id3) == 1, "Id has been removed but is closer to than another one");
+        ck_assert_msg(id_closest(comp_client_id, test_id2, test_id3) == 1, "Id has been removed but is closer to than another one");
+    }
+}
+
+void test_addto_lists_good(DHT            *dht,
+                           Client_data    *list,
+                           uint32_t        length,
+                           IP_Port        *ip_port,
+                           const uint8_t  *comp_client_id)
+{
+    uint8_t client_id[CLIENT_ID_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(client_id, sizeof(client_id));
+    } while (is_furthest(comp_client_id, list, length, client_id));
+    ip_port->port += 1;
+    addto_lists(dht, *ip_port, client_id);
+    ck_assert_msg(client_in_list(list, length, client_id) >= 0, "Good client id is not in the list");
+
+    // check "good" client id skip
+    do {
+        randombytes(client_id, sizeof(client_id));
+    } while (!is_furthest(comp_client_id, list, length, client_id));
+
+    ip_port->port += 1;
+    addto_lists(dht, *ip_port, client_id);
+    ck_assert_msg(client_in_list(list, length, client_id) == -1, "Good client id is in the list");
+}
+
+void test_addto_lists(IP ip)
+{
+    Networking_Core* net = new_networking(ip, TOX_PORT_DEFAULT);
+    ck_assert_msg(net != 0, "Failed to create Networking_Core");
+
+    DHT* dht = new_DHT(net);
+    ck_assert_msg(dht != 0, "Failed to create DHT");
+
+    IP_Port ip_port = { .ip = ip, .port = TOX_PORT_DEFAULT };
+    uint8_t client_id[CLIENT_ID_SIZE];
+    int i, used;
+
+    // check lists filling
+    for (i = 0; i < MAX(LCLIENT_LIST, MAX_FRIEND_CLIENTS); ++i) {
+        randombytes(client_id, sizeof(client_id));
+        used = addto_lists(dht, ip_port, client_id);
+        ck_assert_msg(used == dht->num_friends + 1, "Wrong number of added clients with existing ip_port");
+    }
+
+    for (i = 0; i < MAX(LCLIENT_LIST, MAX_FRIEND_CLIENTS); ++i) {
+        ip_port.port += 1;
+        used = addto_lists(dht, ip_port, client_id);
+        ck_assert_msg(used == dht->num_friends + 1, "Wrong number of added clients with existing client_id");
+    }
+
+    for (i = 0; i < MAX(LCLIENT_LIST, MAX_FRIEND_CLIENTS); ++i) {
+        ip_port.port += 1;
+        randombytes(client_id, sizeof(client_id));
+        used = addto_lists(dht, ip_port, client_id);
+        ck_assert_msg(used >= 1, "Wrong number of added clients");
+    }
+
+    /*check: Current behavior if there are two clients with the same id is
+     * to replace the first ip by the second. */
+    test_addto_lists_update(dht, dht->close_clientlist, LCLIENT_LIST, &ip_port);
+    for (i = 0; i < dht->num_friends; ++i)
+        test_addto_lists_update(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &ip_port);
+
+    // check "bad" entries
+    test_addto_lists_bad(dht, dht->close_clientlist, LCLIENT_LIST, &ip_port);
+    for (i = 0; i < dht->num_friends; ++i)
+        test_addto_lists_bad(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &ip_port);
+
+    // check "possibly bad" entries
+    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].client_id);
+
+    // check "good" entries
+    test_addto_lists_good(dht, dht->close_clientlist, LCLIENT_LIST, &ip_port, dht->self_public_key);
+    for (i = 0; i < dht->num_friends; ++i)
+        test_addto_lists_good(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &ip_port, dht->friends_list[i].client_id);
+
+    kill_DHT(dht);
+    kill_networking(net);
+}
+
+START_TEST(test_addto_lists_ipv4)
+{
+    IP ip;
+    ip_init(&ip, 0);
+    test_addto_lists(ip);
+
+}
+END_TEST
+
+START_TEST(test_addto_lists_ipv6)
+{
+    IP ip;
+    ip_init(&ip, 1);
+    test_addto_lists(ip);
+
+}
+END_TEST
+
+Suite *dht_suite(void)
+{
+    Suite *s = suite_create("DHT");
+
+    DEFTESTCASE(addto_lists_ipv4);
+    DEFTESTCASE(addto_lists_ipv6);
+    return s;
+}
+
+int main(int argc, char *argv[])
+{
+    srand((unsigned int) time(NULL));
+
+    Suite *dht = dht_suite();
+    SRunner *test_runner = srunner_create(dht);
+
+    int number_failed = 0;
+    srunner_run_all(test_runner, CK_NORMAL);
+    number_failed = srunner_ntests_failed(test_runner);
+
+    srunner_free(test_runner);
+
+    return number_failed;
+}

data/ProjectTox-Core/auto_tests/encryptsave_test.c

@@ -0,0 +1,104 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <string.h>
+#include <check.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "helpers.h"
+
+#include "../toxcore/tox.h"
+
+#include "../toxencryptsave/toxencryptsave.h"
+#include "../toxcore/crypto_core.h"
+#ifdef VANILLA_NACL
+#include "../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_pwhash_scryptsalsa208sha256.h"
+#include "../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/utils.h" /* sodium_memzero */
+#endif
+
+unsigned char salt[32] = {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};
+unsigned char key[crypto_box_BEFORENMBYTES] = {0xd1, 0x7, 0x4e, 0xfc, 0x49, 0x2d, 0x99, 0x16, 0xba, 0x4a, 0x4c, 0xc4, 0x92, 0x9, 0xb0, 0x9a, 0xa1, 0xa2, 0xe8, 0xe3, 0x45, 0xe7, 0xf5, 0x50, 0x54, 0x61, 0xd7, 0x3e, 0x2, 0x38, 0xe6, 0xa4};
+char* pw = "hunter2";
+unsigned int pwlen = 7;
+
+/* cause I'm shameless */
+void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata)
+{
+    if (*((uint32_t *)userdata) != 974536)
+        return;
+
+    if (length == 7 && memcmp("Gentoo", data, 7) == 0) {
+        tox_add_friend_norequest(m, public_key);
+    }
+}
+
+START_TEST(test_known_kdf)
+{
+    unsigned char out[crypto_box_BEFORENMBYTES];
+    crypto_pwhash_scryptsalsa208sha256(out,
+                                       crypto_box_BEFORENMBYTES,
+                                       pw,
+                                       pwlen,
+                                       salt,
+                                       crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE,
+                                       crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE);
+     ck_assert_msg(memcmp(out, key, crypto_box_BEFORENMBYTES) == 0, "derived key is wrong");
+}
+END_TEST
+
+START_TEST(test_save_friend)
+{
+    Tox *tox1 = tox_new(0);
+    Tox *tox2 = tox_new(0);
+    ck_assert_msg(tox1 || tox2, "Failed to create 2 tox instances");
+    uint32_t to_compare = 974536;
+    tox_callback_friend_request(tox2, accept_friend_request, &to_compare);
+    uint8_t address[TOX_FRIEND_ADDRESS_SIZE];
+    tox_get_address(tox2, address);
+    int test = tox_add_friend(tox1, address, (uint8_t *)"Gentoo", 7);
+    ck_assert_msg(test == 0, "Failed to add friend error code: %i", test);
+    uint32_t size = tox_encrypted_size(tox1);
+    uint8_t data[size];
+    test = tox_encrypted_save(tox1, data, "correcthorsebatterystaple", 25);
+    ck_assert_msg(test == 0, "failed to encrypted save");
+    ck_assert_msg(tox_is_data_encrypted(data) == 1, "magic number missing");
+    Tox *tox3 = tox_new(0);
+    test = tox_encrypted_load(tox3, data, size, "correcthorsebatterystaple", 25);
+    ck_assert_msg(test == 0, "failed to encrypted load");
+    uint8_t address2[TOX_CLIENT_ID_SIZE];
+    test = tox_get_client_id(tox3, 0, address2);
+    ck_assert_msg(test == 0, "no friends!");
+    ck_assert_msg(memcmp(address, address2, TOX_CLIENT_ID_SIZE) == 0, "addresses don't match!");
+}
+END_TEST
+
+Suite * encryptsave_suite(void)
+{
+    Suite *s = suite_create("encryptsave");
+
+    DEFTESTCASE_SLOW(known_kdf, 60); /* is 5-10 seconds on my computer, but is directly dependent on CPU */
+    DEFTESTCASE(save_friend);
+
+    return s;
+}
+
+int main(int argc, char *argv[])
+{
+    srand((unsigned int) time(NULL));
+
+    Suite * encryptsave =  encryptsave_suite();
+    SRunner *test_runner = srunner_create(encryptsave);
+
+    int number_failed = 0;
+    srunner_run_all(test_runner, CK_NORMAL);
+    number_failed = srunner_ntests_failed(test_runner);
+
+    srunner_free(test_runner);
+
+    return number_failed;
+}
+