Wrap all sodium/nacl functions in crypto_core.c.

1 files changed, 60 insertions, 23 deletions

diff --git a/toxcore/crypto_core.api.h b/toxcore/crypto_core.api.h
index 0c72471c..78a17280 100644
--- a/toxcore/crypto_core.api.h
+++ b/toxcore/crypto_core.api.h
@@ -25,29 +25,59 @@
 #define CORE_CRYPTO_H
 
 #include "network.h"
+%}
 
-#ifndef VANILLA_NACL
-/* We use libsodium by default. */
-#include <sodium.h>
-#else
-#include <crypto_box.h>
-#include <crypto_hash_sha256.h>
-#include <crypto_hash_sha512.h>
-#include <crypto_scalarmult_curve25519.h>
-#include <crypto_verify_16.h>
-#include <crypto_verify_32.h>
-#include <randombytes.h>
-#define crypto_box_MACBYTES (crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES)
-/* I know */
-#define sodium_memcmp(a, b, c) memcmp(a, b, c)
-#define sodium_memzero(a, c) memset(a, 0, c)
-#endif
+/**
+ * The number of bytes in a Tox public key.
+ */
+const CRYPTO_PUBLIC_KEY_SIZE = 32;
 
-#define crypto_box_KEYBYTES (crypto_box_BEFORENMBYTES)
-%}
+/**
+ * The number of bytes in a Tox secret key.
+ */
+const CRYPTO_SECRET_KEY_SIZE = 32;
+
+/**
+ * The number of bytes in a shared key computed from public and secret key.
+ */
+const CRYPTO_SHARED_KEY_SIZE = 32;
+
+/**
+ * The number of bytes in a random symmetric key.
+ */
+const CRYPTO_SYMMETRIC_KEY_SIZE = CRYPTO_SHARED_KEY_SIZE;
+
+/**
+ * The number of bytes needed for the MAC (message authentication code) in an
+ * encrypted message.
+ */
+const CRYPTO_MAC_SIZE = 16;
 
 /**
- * compare 2 public keys of length crypto_box_PUBLICKEYBYTES, not vulnerable to timing attacks.
+ * The number of bytes in a nonce used for encryption/decryption.
+ */
+const CRYPTO_NONCE_SIZE = 24;
+
+/**
+ * The number of bytes in a SHA256 hash.
+ */
+const CRYPTO_SHA256_SIZE = 32;
+
+/**
+ * The number of bytes in a SHA512 hash.
+ */
+const CRYPTO_SHA512_SIZE = 64;
+
+static int32_t crypto_memcmp(const void *p1, const void *p2, size_t length);
+static void crypto_memzero(void *data, size_t length);
+
+static void crypto_sha256(uint8_t *hash, const uint8_t[length] data);
+static void crypto_sha512(uint8_t *hash, const uint8_t[length] data);
+
+static void crypto_derive_public_key(uint8_t *public_key, uint8_t *secret_key);
+
+/**
+ * compare 2 public keys of length CRYPTO_PUBLIC_KEY_SIZE, not vulnerable to timing attacks.
  * returns 0 if both mem locations of length are equal,
  * return -1 if they are not.
  */
@@ -64,7 +94,7 @@ static uint32_t random_int();
 static uint64_t random_64b();
 
 /**
- * Check if a Tox public key crypto_box_PUBLICKEYBYTES is valid or not.
+ * Check if a Tox public key CRYPTO_PUBLIC_KEY_SIZE is valid or not.
  * This should only be used for input validation.
  *
  * return 0 if it isn't.
@@ -72,6 +102,8 @@ static uint64_t random_64b();
  */
 static int32_t public_key_valid(const uint8_t *public_key);
 
+static int32_t crypto_new_keypair(uint8_t *public_key, uint8_t *secret_key);
+
 /**
  * Encrypts plain of length length to encrypted of length + 16 using the
  * public key(32 bytes) of the receiver and the secret key of the sender and a 24 byte nonce.
@@ -105,7 +137,7 @@ static int32_t encrypt_precompute(
 
 /**
  * Encrypts plain of length length to encrypted of length + 16 using a
- * secret key crypto_box_KEYBYTES big and a 24 byte nonce.
+ * secret key CRYPTO_SYMMETRIC_KEY_SIZE big and a 24 byte nonce.
  *
  *  return -1 if there was a problem.
  *  return length of encrypted data if everything was fine.
@@ -116,7 +148,7 @@ static int32_t encrypt_data_symmetric(
 
 /**
  * Decrypts encrypted of length length to plain of length length - 16 using a
- * secret key crypto_box_KEYBYTES big and a 24 byte nonce.
+ * secret key CRYPTO_SYMMETRIC_KEY_SIZE big and a 24 byte nonce.
  *
  *  return -1 if there was a problem (decryption failed).
  *  return length of plain data if everything was fine.
@@ -141,10 +173,15 @@ static void increment_nonce_number(uint8_t *nonce, uint32_t host_order_num);
 static void random_nonce(uint8_t *nonce);
 
 /**
- * Fill a key crypto_box_KEYBYTES big with random bytes.
+ * Fill a key CRYPTO_SYMMETRIC_KEY_SIZE big with random bytes.
  */
 static void new_symmetric_key(uint8_t *key);
 
+/**
+ * Fill an array of bytes with random values.
+ */
+static void random_bytes(uint8_t[length] bytes);
+
 %{
 #endif
 %}