ffi-tox 0.1.1 → 0.1.3

data/ProjectTox-Core/toxcore/util.c

@@ -0,0 +1,193 @@
+/*
+ * util.c -- Utilities.
+ *
+ * This file is donated to the Tox Project.
+ * Copyright 2013  plutooo
+ *
+ *  Copyright (C) 2013 Tox project All Rights Reserved.
+ *
+ *  This file is part of Tox.
+ *
+ *  Tox is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Tox is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <time.h>
+
+/* for CLIENT_ID_SIZE */
+#include "DHT.h"
+
+#include "util.h"
+
+
+/* don't call into system billions of times for no reason */
+static uint64_t unix_time_value;
+static uint64_t unix_base_time_value;
+
+void unix_time_update()
+{
+    if (unix_base_time_value == 0)
+        unix_base_time_value = ((uint64_t)time(NULL) - (current_time_monotonic() / 1000ULL));
+
+    unix_time_value = (current_time_monotonic() / 1000ULL) + unix_base_time_value;
+}
+
+uint64_t unix_time()
+{
+    return unix_time_value;
+}
+
+int is_timeout(uint64_t timestamp, uint64_t timeout)
+{
+    return timestamp + timeout <= unix_time();
+}
+
+
+/* id functions */
+bool id_equal(const uint8_t *dest, const uint8_t *src)
+{
+    return memcmp(dest, src, CLIENT_ID_SIZE) == 0;
+}
+
+uint32_t id_copy(uint8_t *dest, const uint8_t *src)
+{
+    memcpy(dest, src, CLIENT_ID_SIZE);
+    return CLIENT_ID_SIZE;
+}
+
+void host_to_net(uint8_t *num, uint16_t numbytes)
+{
+#ifndef WORDS_BIGENDIAN
+    uint32_t i;
+    uint8_t buff[numbytes];
+
+    for (i = 0; i < numbytes; ++i) {
+        buff[i] = num[numbytes - i - 1];
+    }
+
+    memcpy(num, buff, numbytes);
+#endif
+    return;
+}
+
+/* state load/save */
+int load_state(load_state_callback_func load_state_callback, void *outer,
+               const uint8_t *data, uint32_t length, uint16_t cookie_inner)
+{
+    if (!load_state_callback || !data) {
+#ifdef DEBUG
+        fprintf(stderr, "load_state() called with invalid args.\n");
+#endif
+        return -1;
+    }
+
+
+    uint16_t type;
+    uint32_t length_sub, cookie_type;
+    uint32_t size_head = sizeof(uint32_t) * 2;
+
+    while (length >= size_head) {
+        memcpy(&length_sub, data, sizeof(length_sub));
+        memcpy(&cookie_type, data + sizeof(length_sub), sizeof(cookie_type));
+        data += size_head;
+        length -= size_head;
+
+        if (length < length_sub) {
+            /* file truncated */
+#ifdef DEBUG
+            fprintf(stderr, "state file too short: %u < %u\n", length, length_sub);
+#endif
+            return -1;
+        }
+
+        if ((cookie_type >> 16) != cookie_inner) {
+            /* something is not matching up in a bad way, give up */
+#ifdef DEBUG
+            fprintf(stderr, "state file garbeled: %04hx != %04hx\n", (cookie_type >> 16), cookie_inner);
+#endif
+            return -1;
+        }
+
+        type = cookie_type & 0xFFFF;
+
+        if (-1 == load_state_callback(outer, data, length_sub, type))
+            return -1;
+
+        data += length_sub;
+        length -= length_sub;
+    }
+
+    return length == 0 ? 0 : -1;
+};
+
+/* Converts 4 bytes to uint32_t */
+inline__ void bytes_to_U32(uint32_t *dest, const uint8_t *bytes)
+{
+    *dest =
+#ifdef WORDS_BIGENDIAN
+        ( ( uint32_t ) *  bytes )              |
+        ( ( uint32_t ) * ( bytes + 1 ) << 8 )  |
+        ( ( uint32_t ) * ( bytes + 2 ) << 16 ) |
+        ( ( uint32_t ) * ( bytes + 3 ) << 24 ) ;
+#else
+        ( ( uint32_t ) *  bytes        << 24 ) |
+        ( ( uint32_t ) * ( bytes + 1 ) << 16 ) |
+        ( ( uint32_t ) * ( bytes + 2 ) << 8 )  |
+        ( ( uint32_t ) * ( bytes + 3 ) ) ;
+#endif
+}
+
+/* Converts 2 bytes to uint16_t */
+inline__ void bytes_to_U16(uint16_t *dest, const uint8_t *bytes)
+{
+    *dest =
+#ifdef WORDS_BIGENDIAN
+        ( ( uint16_t ) *   bytes ) |
+        ( ( uint16_t ) * ( bytes + 1 ) << 8 );
+#else
+        ( ( uint16_t ) *   bytes << 8 ) |
+        ( ( uint16_t ) * ( bytes + 1 ) );
+#endif
+}
+
+/* Convert uint32_t to byte string of size 4 */
+inline__ void U32_to_bytes(uint8_t *dest, uint32_t value)
+{
+#ifdef WORDS_BIGENDIAN
+    *(dest)     = ( value );
+    *(dest + 1) = ( value >> 8 );
+    *(dest + 2) = ( value >> 16 );
+    *(dest + 3) = ( value >> 24 );
+#else
+    *(dest)     = ( value >> 24 );
+    *(dest + 1) = ( value >> 16 );
+    *(dest + 2) = ( value >> 8 );
+    *(dest + 3) = ( value );
+#endif
+}
+
+/* Convert uint16_t to byte string of size 2 */
+inline__ void U16_to_bytes(uint8_t *dest, uint16_t value)
+{
+#ifdef WORDS_BIGENDIAN
+    *(dest)     = ( value );
+    *(dest + 1) = ( value >> 8 );
+#else
+    *(dest)     = ( value >> 8 );
+    *(dest + 1) = ( value );
+#endif
+}

data/ProjectTox-Core/toxcore/util.h

@@ -0,0 +1,63 @@
+/*
+ * util.h -- Utilities.
+ *
+ * This file is donated to the Tox Project.
+ * Copyright 2013  plutooo
+ *
+ *  Copyright (C) 2013 Tox project All Rights Reserved.
+ *
+ *  This file is part of Tox.
+ *
+ *  Tox is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Tox is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __UTIL_H__
+#define __UTIL_H__
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define inline__ inline __attribute__((always_inline))
+
+void unix_time_update();
+uint64_t unix_time();
+int is_timeout(uint64_t timestamp, uint64_t timeout);
+
+
+/* id functions */
+bool id_equal(const uint8_t *dest, const uint8_t *src);
+uint32_t id_copy(uint8_t *dest, const uint8_t *src); /* return value is CLIENT_ID_SIZE */
+
+void host_to_net(uint8_t *num, uint16_t numbytes);
+#define net_to_host(x, y) host_to_net(x, y)
+
+/* state load/save */
+typedef int (*load_state_callback_func)(void *outer, const uint8_t *data, uint32_t len, uint16_t type);
+int load_state(load_state_callback_func load_state_callback, void *outer,
+               const uint8_t *data, uint32_t length, uint16_t cookie_inner);
+
+/* Converts 4 bytes to uint32_t */
+void bytes_to_U32(uint32_t *dest, const uint8_t *bytes);
+
+/* Converts 2 bytes to uint16_t */
+void bytes_to_U16(uint16_t *dest, const uint8_t *bytes);
+
+/* Convert uint32_t to byte string of size 4 */
+void U32_to_bytes(uint8_t *dest, uint32_t value);
+
+/* Convert uint16_t to byte string of size 2 */
+void U16_to_bytes(uint8_t *dest, uint16_t value);
+
+
+#endif /* __UTIL_H__ */

data/ProjectTox-Core/toxdns/Makefile.inc

@@ -0,0 +1,29 @@
+lib_LTLIBRARIES += libtoxdns.la
+
+libtoxdns_la_include_HEADERS = \
+                        ../toxdns/toxdns.h
+
+libtoxdns_la_includedir = $(includedir)/tox
+
+libtoxdns_la_SOURCES =  ../toxdns/toxdns.h \
+                        ../toxdns/toxdns.c
+
+libtoxdns_la_CFLAGS =   -I$(top_srcdir) \
+                        -I$(top_srcdir)/toxcore \
+                        $(LIBSODIUM_CFLAGS) \
+                        $(NACL_CFLAGS) \
+                        $(PTHREAD_CFLAGS)
+
+libtoxdns_la_LDFLAGS =  $(TOXCORE_LT_LDFLAGS) \
+                        $(EXTRA_LT_LDFLAGS) \
+                        $(LIBSODIUM_LDFLAGS) \
+                        $(NACL_LDFLAGS) \
+                        $(MATH_LDFLAGS) \
+                        $(RT_LIBS) \
+                        $(WINSOCK2_LIBS)
+
+libtoxdns_la_LIBADD =   $(LIBSODIUM_LIBS) \
+                        $(NACL_OBJECTS) \
+                        $(NAC_LIBS) \
+                        $(PTHREAD_LIBS) \
+                        libtoxcore.la

data/ProjectTox-Core/toxdns/toxdns.c

@@ -0,0 +1,238 @@
+/* toxdns.c
+ *
+ * Tox secure username DNS toxid resolving functions.
+ *
+ *  Copyright (C) 2013 Tox project All Rights Reserved.
+ *
+ *  This file is part of Tox.
+ *
+ *  Tox is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Tox is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "../toxcore/Messenger.h"
+#include "../toxcore/logger.h"
+#include "toxdns.h"
+
+static const char base32[32] = {"abcdefghijklmnopqrstuvwxyz012345"};
+
+#define _encode(a, b, c) \
+{ \
+uint8_t i = 0; \
+    while(i != c) { \
+        *a++ = base32[((b[0] >> bits) | (b[1] << (8 - bits))) & 0x1F]; \
+        bits += 5; \
+        if(bits >= 8) { \
+            bits -= 8; \
+            b++; \
+            i++; \
+        } \
+    } \
+} \
+ 
+typedef struct {
+    uint8_t temp_pk[crypto_box_PUBLICKEYBYTES];
+    uint8_t temp_sk[crypto_box_SECRETKEYBYTES];
+    uint8_t server_public_key[crypto_box_PUBLICKEYBYTES];
+    uint8_t shared_key[crypto_box_KEYBYTES];
+    uint32_t nonce;
+    uint32_t nonce_start;
+} DNS_Object;
+
+static void dns_new_temp_keys(DNS_Object *d)
+{
+    d->nonce = d->nonce_start = random_int();
+    crypto_box_keypair(d->temp_pk, d->temp_sk);
+    encrypt_precompute(d->server_public_key, d->temp_sk, d->shared_key);
+}
+
+/* Create a new tox_dns3 object for server with server_public_key.
+ *
+ * return Null on failure.
+ * return pointer object on success.
+ */
+void *tox_dns3_new(uint8_t *server_public_key)
+{
+    DNS_Object *d = malloc(sizeof(DNS_Object));
+
+    if (d == NULL)
+        return NULL;
+
+    memcpy(d->server_public_key, server_public_key, crypto_box_PUBLICKEYBYTES);
+    dns_new_temp_keys(d);
+    return d;
+}
+
+/* Destroy the tox dns3 object.
+ */
+void tox_dns3_kill(void *dns3_object)
+{
+    memset(dns3_object, 0, sizeof(DNS_Object));
+    free(dns3_object);
+}
+
+/* Generate a dns3 string of string_max_len used to query the dns server referred to by to
+ * dns3_object for a tox id registered to user with name of name_len.
+ *
+ * the uint32_t pointed by request_id will be set to the request id which must be passed to
+ * tox_decrypt_dns3_TXT() to correctly decode the response.
+ *
+ * This is what the string returned looks like:
+ * 4haaaaipr1o3mz0bxweox541airydbovqlbju51mb4p0ebxq.rlqdj4kkisbep2ks3fj2nvtmk4daduqiueabmexqva1jc
+ *
+ * returns length of string on success.
+ * returns -1 on failure.
+ */
+int tox_generate_dns3_string(void *dns3_object, uint8_t *string, uint16_t string_max_len, uint32_t *request_id,
+                             uint8_t *name, uint8_t name_len)
+{
+#define DOT_INTERVAL (6 * 5)
+    int base = (sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES + name_len + crypto_box_MACBYTES);
+    int end_len = ((base * 8) / 5) + (base / DOT_INTERVAL) + !!(base % 5);
+    end_len -= !(base % DOT_INTERVAL);
+
+    if (end_len > string_max_len)
+        return -1;
+
+    DNS_Object *d = dns3_object;
+    uint8_t buffer[1024];
+    uint8_t nonce[crypto_box_NONCEBYTES] = {0};
+    memcpy(nonce, &d->nonce, sizeof(uint32_t));
+    memcpy(buffer, &d->nonce, sizeof(uint32_t));
+    memcpy(buffer + sizeof(uint32_t), d->temp_pk, crypto_box_PUBLICKEYBYTES);
+    int len = encrypt_data_symmetric(d->shared_key, nonce, name, name_len,
+                                     buffer + sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES);
+
+    if (len == -1)
+        return -1;
+
+    int total_len = len + sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES;
+    uint8_t *buff = buffer, *old_str = string;
+    buffer[total_len] = 0;
+    uint8_t bits = 0;
+    int i;
+
+    for (i = !(total_len % DOT_INTERVAL); i < (total_len / DOT_INTERVAL); ++i) {
+        _encode(string, buff, DOT_INTERVAL);
+        *string = '.';
+        ++string;
+    }
+
+    int left = total_len - (buff - buffer);
+    _encode(string, buff, left);
+#undef DOT_INTERVAL
+    *request_id = d->nonce;
+    ++d->nonce;
+
+    if (d->nonce == d->nonce_start) {
+        dns_new_temp_keys(d);
+    }
+
+    if (end_len != string - old_str) {
+        LOGGER_ERROR("tox_generate_dns3_string Fail, %u != %lu\n", end_len, string - old_str);
+        return -1;
+    }
+
+    return string - old_str;
+}
+
+
+static int decode(uint8_t *dest, uint8_t *src)
+{
+    uint8_t *p = src, *op = dest, bits = 0;
+    *op = 0;
+
+    while (*p) {
+        uint8_t ch = *p++;
+
+        switch (ch) {
+            case 'A' ... 'Z': {
+                ch = ch - 'A';
+                break;
+            }
+
+            case 'a' ... 'z': {
+                ch = ch - 'a';
+                break;
+            }
+
+            case '0' ... '5': {
+                ch = ch - '0' + 26;
+                break;
+            }
+
+            default: {
+                return - 1;
+            }
+        }
+
+        *op |= (ch << bits);
+        bits += 5;
+
+        if (bits >= 8) {
+            bits -= 8;
+            ++op;
+            *op = (ch >> (5 - bits));
+        }
+    }
+
+    return op - dest;
+}
+
+/* Decode and decrypt the id_record returned of length id_record_len into
+ * tox_id (needs to be at least TOX_FRIEND_ADDRESS_SIZE).
+ *
+ * request_id is the request id given by tox_generate_dns3_string() when creating the request.
+ *
+ * the id_record passed to this function should look somewhat like this:
+ * 2vgcxuycbuctvauik3plsv3d3aadv4zfjfhi3thaizwxinelrvigchv0ah3qjcsx5qhmaksb2lv2hm5cwbtx0yp
+ *
+ * returns -1 on failure.
+ * returns 0 on success.
+ *
+ */
+int tox_decrypt_dns3_TXT(void *dns3_object, uint8_t *tox_id, uint8_t *id_record, uint32_t id_record_len,
+                         uint32_t request_id)
+{
+    DNS_Object *d = dns3_object;
+
+    if (id_record_len != 87)
+        return -1;
+
+    /*if (id_record_len > 255 || id_record_len <= (sizeof(uint32_t) + crypto_box_MACBYTES))
+        return -1;*/
+
+    uint8_t id_record_null[id_record_len + 1];
+    memcpy(id_record_null, id_record, id_record_len);
+    id_record_null[id_record_len] = 0;
+    uint8_t data[id_record_len];
+    int length = decode(data, id_record_null);
+
+    if (length == -1)
+        return -1;
+
+    uint8_t nonce[crypto_box_NONCEBYTES] = {0};
+    memcpy(nonce, &request_id, sizeof(uint32_t));
+    nonce[sizeof(uint32_t)] = 1;
+    int len = decrypt_data_symmetric(d->shared_key, nonce, data, length, tox_id);
+
+    if (len != FRIEND_ADDRESS_SIZE)
+        return -1;
+
+    return 0;
+}