diff options
author | aunsane <aunsane@gmail.com> | 2017-12-15 01:05:56 +0300 |
---|---|---|
committer | aunsane <aunsane@gmail.com> | 2017-12-15 01:05:56 +0300 |
commit | e124aa3611f38573898aa79c6eabe77bc874e58f (patch) | |
tree | 819464260f758bbc002b23c0c8a77f93751dcb42 /libs/libtox/src/toxcore/crypto_core.h | |
parent | bbd9647d47f20d10b39570def918a0ac68c305c9 (diff) |
preparing to build tox from sources
Diffstat (limited to 'libs/libtox/src/toxcore/crypto_core.h')
-rw-r--r-- | libs/libtox/src/toxcore/crypto_core.h | 234 |
1 files changed, 234 insertions, 0 deletions
diff --git a/libs/libtox/src/toxcore/crypto_core.h b/libs/libtox/src/toxcore/crypto_core.h new file mode 100644 index 0000000000..fc5756c1d2 --- /dev/null +++ b/libs/libtox/src/toxcore/crypto_core.h @@ -0,0 +1,234 @@ +/* + * Functions for the core crypto. + */ + +/* + * Copyright © 2016-2017 The TokTok team. + * Copyright © 2013 Tox project. + * + * This file is part of Tox, the free peer to peer instant messenger. + * + * 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 CRYPTO_CORE_H +#define CRYPTO_CORE_H + +#include <stdbool.h> +#include <stdint.h> +#include <stdlib.h> + +/** + * The number of bytes in a Tox public key. + */ +#define CRYPTO_PUBLIC_KEY_SIZE 32 + +uint32_t crypto_public_key_size(void); + +/** + * The number of bytes in a Tox secret key. + */ +#define CRYPTO_SECRET_KEY_SIZE 32 + +uint32_t crypto_secret_key_size(void); + +/** + * The number of bytes in a shared key computed from public and secret keys. + */ +#define CRYPTO_SHARED_KEY_SIZE 32 + +uint32_t crypto_shared_key_size(void); + +/** + * The number of bytes in a symmetric key. + */ +#define CRYPTO_SYMMETRIC_KEY_SIZE CRYPTO_SHARED_KEY_SIZE + +uint32_t crypto_symmetric_key_size(void); + +/** + * The number of bytes needed for the MAC (message authentication code) in an + * encrypted message. + */ +#define CRYPTO_MAC_SIZE 16 + +uint32_t crypto_mac_size(void); + +/** + * The number of bytes in a nonce used for encryption/decryption. + */ +#define CRYPTO_NONCE_SIZE 24 + +uint32_t crypto_nonce_size(void); + +/** + * The number of bytes in a SHA256 hash. + */ +#define CRYPTO_SHA256_SIZE 32 + +uint32_t crypto_sha256_size(void); + +/** + * The number of bytes in a SHA512 hash. + */ +#define CRYPTO_SHA512_SIZE 64 + +uint32_t crypto_sha512_size(void); + +/** + * A `memcmp`-like function whose running time does not depend on the input + * bytes, only on the input length. Useful to compare sensitive data where + * timing attacks could reveal that data. + * + * This means for instance that comparing "aaaa" and "aaaa" takes 4 time, and + * "aaaa" and "baaa" also takes 4 time. With a regular `memcmp`, the latter may + * take 1 time, because it immediately knows that the two strings are not equal. + */ +int32_t crypto_memcmp(const void *p1, const void *p2, size_t length); + +/** + * A `bzero`-like function which won't be optimised away by the compiler. Some + * compilers will inline `bzero` or `memset` if they can prove that there will + * be no reads to the written data. Use this function if you want to be sure the + * memory is indeed zeroed. + */ +void crypto_memzero(void *data, size_t length); + +/** + * Compute a SHA256 hash (32 bytes). + */ +void crypto_sha256(uint8_t *hash, const uint8_t *data, size_t length); + +/** + * Compute a SHA512 hash (64 bytes). + */ +void crypto_sha512(uint8_t *hash, const uint8_t *data, size_t length); + +/** + * Compare 2 public keys of length CRYPTO_PUBLIC_KEY_SIZE, not vulnerable to + * timing attacks. + * + * @return 0 if both mem locations of length are equal, -1 if they are not. + */ +int32_t public_key_cmp(const uint8_t *pk1, const uint8_t *pk2); + +/** + * Return a random 32 bit integer. + */ +uint32_t random_int(void); + +/** + * Return a random 64 bit integer. + */ +uint64_t random_64b(void); + +/** + * Check if a Tox public key CRYPTO_PUBLIC_KEY_SIZE is valid or not. This + * should only be used for input validation. + * + * @return false if it isn't, true if it is. + */ +bool public_key_valid(const uint8_t *public_key); + +/** + * Generate a new random keypair. Every call to this function is likely to + * generate a different keypair. + */ +int32_t crypto_new_keypair(uint8_t *public_key, uint8_t *secret_key); + +/** + * Derive the public key from a given secret key. + */ +void crypto_derive_public_key(uint8_t *public_key, const uint8_t *secret_key); + +/** + * Encrypt plain text of the given length to encrypted of length + + * CRYPTO_MAC_SIZE using the public key (CRYPTO_PUBLIC_KEY_SIZE bytes) of the + * receiver and the secret key of the sender and a CRYPTO_NONCE_SIZE byte + * nonce. + * + * @return -1 if there was a problem, length of encrypted data if everything + * was fine. + */ +int32_t encrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *nonce, const uint8_t *plain, + size_t length, uint8_t *encrypted); + +/** + * Decrypt encrypted text of the given length to plain text of the given length + * - CRYPTO_MAC_SIZE using the public key (CRYPTO_PUBLIC_KEY_SIZE bytes) of + * the sender, the secret key of the receiver and a CRYPTO_NONCE_SIZE byte + * nonce. + * + * @return -1 if there was a problem (decryption failed), length of plain text + * data if everything was fine. + */ +int32_t decrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *nonce, + const uint8_t *encrypted, size_t length, uint8_t *plain); + +/** + * Fast encrypt/decrypt operations. Use if this is not a one-time communication. + * encrypt_precompute does the shared-key generation once so it does not have + * to be preformed on every encrypt/decrypt. + */ +int32_t encrypt_precompute(const uint8_t *public_key, const uint8_t *secret_key, uint8_t *shared_key); + +/** + * Encrypts plain of length length to encrypted of length + CRYPTO_MAC_SIZE + * using a shared key CRYPTO_SYMMETRIC_KEY_SIZE big and a CRYPTO_NONCE_SIZE + * byte nonce. + * + * @return -1 if there was a problem, length of encrypted data if everything + * was fine. + */ +int32_t encrypt_data_symmetric(const uint8_t *shared_key, const uint8_t *nonce, const uint8_t *plain, size_t length, + uint8_t *encrypted); + +/** + * Decrypts encrypted of length length to plain of length length - + * CRYPTO_MAC_SIZE using a shared key CRYPTO_SHARED_KEY_SIZE big and a + * CRYPTO_NONCE_SIZE byte nonce. + * + * @return -1 if there was a problem (decryption failed), length of plain data + * if everything was fine. + */ +int32_t decrypt_data_symmetric(const uint8_t *shared_key, const uint8_t *nonce, const uint8_t *encrypted, size_t length, + uint8_t *plain); + +/** + * Increment the given nonce by 1 in big endian (rightmost byte incremented + * first). + */ +void increment_nonce(uint8_t *nonce); + +/** + * Increment the given nonce by a given number. The number should be in host + * byte order. + */ +void increment_nonce_number(uint8_t *nonce, uint32_t host_order_num); + +/** + * Fill the given nonce with random bytes. + */ +void random_nonce(uint8_t *nonce); + +/** + * Fill a key CRYPTO_SYMMETRIC_KEY_SIZE big with random bytes. + */ +void new_symmetric_key(uint8_t *key); + +/** + * Fill an array of bytes with random values. + */ +void random_bytes(uint8_t *bytes, size_t length); + +#endif /* CRYPTO_CORE_H */ |