From 8b580d6d151f00e27f4b64cede2c34ba6db55112 Mon Sep 17 00:00:00 2001 From: Dmytro Vorobiov Date: Wed, 4 Jan 2017 20:22:57 +0100 Subject: [PATCH] Updating toxcore to 0.1.0 --- toxcore-git | 2 +- toxcore.podspec | 2 +- toxcore/toxav/bwcontroller.m | 2 +- toxcore/toxav/rtp.m | 10 +- toxcore/toxcore/Messenger.h | 2 +- toxcore/toxcore/Messenger.m | 14 +- toxcore/toxcore/net_crypto.m | 6 +- toxcore/toxcore/tox.api.h | 27 +- toxcore/toxcore/tox.h | 29 +- toxcore/toxcore/tox.m | 8 +- toxcore/toxencryptsave/toxencryptsave.api.h | 322 +++++++++++++++++ toxcore/toxencryptsave/toxencryptsave.h | 368 ++++++++++++++------ toxcore/toxencryptsave/toxencryptsave.m | 80 ++++- 13 files changed, 699 insertions(+), 173 deletions(-) create mode 100644 toxcore/toxencryptsave/toxencryptsave.api.h diff --git a/toxcore-git b/toxcore-git index d6bad90..7d2f2e4 160000 --- a/toxcore-git +++ b/toxcore-git @@ -1 +1 @@ -Subproject commit d6bad9078b721597f4def2447656974d5fed80d6 +Subproject commit 7d2f2e4607080ebf5155b43050c62af4f14b9c88 diff --git a/toxcore.podspec b/toxcore.podspec index 516d4e3..2a2f543 100644 --- a/toxcore.podspec +++ b/toxcore.podspec @@ -9,7 +9,7 @@ Pod::Spec.new do |s| s.name = "toxcore" - s.version = "0.0.5" + s.version = "0.1.0" s.summary = "Cocoapods wrapper for toxcore" s.homepage = "https://github.com/Antidote-for-Tox/toxcore" s.license = 'GPLv3' diff --git a/toxcore/toxav/bwcontroller.m b/toxcore/toxav/bwcontroller.m index 48afba8..b7390e4 100644 --- a/toxcore/toxav/bwcontroller.m +++ b/toxcore/toxav/bwcontroller.m @@ -173,7 +173,7 @@ void send_update(BWController *bwc) b_msg->lost = htonl(bwc->cycle.lost); b_msg->recv = htonl(bwc->cycle.recv); - if (-1 == send_custom_lossy_packet(bwc->m, bwc->friend_number, p_msg, sizeof(p_msg))) { + if (-1 == m_send_custom_lossy_packet(bwc->m, bwc->friend_number, p_msg, sizeof(p_msg))) { LOGGER_WARNING(bwc->m->log, "BWC send failed (len: %d)! std error: %s", sizeof(p_msg), strerror(errno)); } } diff --git a/toxcore/toxav/rtp.m b/toxcore/toxav/rtp.m index f453ff5..1c6bed7 100644 --- a/toxcore/toxav/rtp.m +++ b/toxcore/toxav/rtp.m @@ -148,7 +148,7 @@ int rtp_send_data(RTPSession *session, const uint8_t *data, uint16_t length, Log memcpy(rdata + 1 + sizeof(struct RTPHeader), data, length); - if (-1 == send_custom_lossy_packet(session->m, session->friend_number, rdata, sizeof(rdata))) { + if (-1 == m_send_custom_lossy_packet(session->m, session->friend_number, rdata, sizeof(rdata))) { LOGGER_WARNING(session->m->log, "RTP send failed (len: %d)! std error: %s", sizeof(rdata), strerror(errno)); } } else { @@ -164,8 +164,8 @@ int rtp_send_data(RTPSession *session, const uint8_t *data, uint16_t length, Log while ((length - sent) + sizeof(struct RTPHeader) + 1 > MAX_CRYPTO_DATA_SIZE) { memcpy(rdata + 1 + sizeof(struct RTPHeader), data + sent, piece); - if (-1 == send_custom_lossy_packet(session->m, session->friend_number, - rdata, piece + sizeof(struct RTPHeader) + 1)) { + if (-1 == m_send_custom_lossy_packet(session->m, session->friend_number, + rdata, piece + sizeof(struct RTPHeader) + 1)) { LOGGER_WARNING(session->m->log, "RTP send failed (len: %d)! std error: %s", piece + sizeof(struct RTPHeader) + 1, strerror(errno)); } @@ -180,8 +180,8 @@ int rtp_send_data(RTPSession *session, const uint8_t *data, uint16_t length, Log if (piece) { memcpy(rdata + 1 + sizeof(struct RTPHeader), data + sent, piece); - if (-1 == send_custom_lossy_packet(session->m, session->friend_number, rdata, - piece + sizeof(struct RTPHeader) + 1)) { + if (-1 == m_send_custom_lossy_packet(session->m, session->friend_number, rdata, + piece + sizeof(struct RTPHeader) + 1)) { LOGGER_WARNING(session->m->log, "RTP send failed (len: %d)! std error: %s", piece + sizeof(struct RTPHeader) + 1, strerror(errno)); } diff --git a/toxcore/toxcore/Messenger.h b/toxcore/toxcore/Messenger.h index 8f9a83a..9bc4c45 100644 --- a/toxcore/toxcore/Messenger.h +++ b/toxcore/toxcore/Messenger.h @@ -697,7 +697,7 @@ void custom_lossy_packet_registerhandler(Messenger *m, void (*packet_handler_cal * return -5 if packet failed to send because of other error. * return 0 on success. */ -int send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length); +int m_send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length); /* Set handlers for custom lossless packets. diff --git a/toxcore/toxcore/Messenger.m b/toxcore/toxcore/Messenger.m index be311fa..79f2874 100644 --- a/toxcore/toxcore/Messenger.m +++ b/toxcore/toxcore/Messenger.m @@ -1782,7 +1782,7 @@ int m_callback_rtp_packet(Messenger *m, int32_t friendnumber, uint8_t byte, int } -int send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length) +int m_send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length) { if (friend_not_valid(m, friendnumber)) { return -1; @@ -2663,9 +2663,9 @@ static uint32_t friend_size() data++; // padding VALUE_MEMBER(info_size); ARRAY_MEMBER(name); - data++; // padding VALUE_MEMBER(name_length); ARRAY_MEMBER(statusmessage); + data++; // padding VALUE_MEMBER(statusmessage_length); VALUE_MEMBER(userstatus); data += 3; // padding @@ -2700,9 +2700,9 @@ static uint32_t saved_friendslist_size(const Messenger *m) data++; // padding VALUE_MEMBER(info_size); ARRAY_MEMBER(name); - data++; // padding VALUE_MEMBER(name_length); ARRAY_MEMBER(statusmessage); + data++; // padding VALUE_MEMBER(statusmessage_length); VALUE_MEMBER(userstatus); data += 3; // padding @@ -2752,7 +2752,9 @@ static uint32_t friends_list_save(const Messenger *m, uint8_t *data) uint8_t *next_data = friend_save(&temp, cur_data); #ifdef TOX_DEBUG assert(next_data - cur_data == friend_size()); +#ifdef __LP64__ assert(memcmp(cur_data, &temp, friend_size()) == 0); +#endif #endif cur_data = next_data; num++; @@ -2782,9 +2784,9 @@ static uint32_t friends_list_save(const Messenger *m, uint8_t *data) data++; // padding VALUE_MEMBER(info_size); ARRAY_MEMBER(name); - data++; // padding VALUE_MEMBER(name_length); ARRAY_MEMBER(statusmessage); + data++; // padding VALUE_MEMBER(statusmessage_length); VALUE_MEMBER(userstatus); data += 3; // padding @@ -2812,7 +2814,9 @@ static int friends_list_load(Messenger *m, const uint8_t *data, uint32_t length) const uint8_t *next_data = friend_load(&temp, cur_data); #ifdef TOX_DEBUG assert(next_data - cur_data == friend_size()); +#ifdef __LP64__ assert(memcmp(&temp, cur_data, friend_size()) == 0); +#endif #endif cur_data = next_data; @@ -2988,7 +2992,7 @@ static int messenger_load_state_callback(void *outer, const uint8_t *data, uint3 break; case MESSENGER_STATE_TYPE_STATUSMESSAGE: - if ((length > 0) && (length < MAX_STATUSMESSAGE_LENGTH)) { + if ((length > 0) && (length <= MAX_STATUSMESSAGE_LENGTH)) { m_set_statusmessage(m, data, length); } diff --git a/toxcore/toxcore/net_crypto.m b/toxcore/toxcore/net_crypto.m index 84276c6..269d03a 100644 --- a/toxcore/toxcore/net_crypto.m +++ b/toxcore/toxcore/net_crypto.m @@ -1321,8 +1321,8 @@ static void connection_kill(Net_Crypto *c, int crypt_connection_id, void *userda * return -1 on failure. * return 0 on success. */ -static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, const uint8_t *packet, uint16_t length, - bool udp, void *userdata) +static int handle_data_packet_core(Net_Crypto *c, int crypt_connection_id, const uint8_t *packet, uint16_t length, + bool udp, void *userdata) { if (length > MAX_CRYPTO_PACKET_SIZE || length <= CRYPTO_DATA_PACKET_MIN_SIZE) { return -1; @@ -1542,7 +1542,7 @@ static int handle_packet_connection(Net_Crypto *c, int crypt_connection_id, cons case NET_PACKET_CRYPTO_DATA: { if (conn->status == CRYPTO_CONN_NOT_CONFIRMED || conn->status == CRYPTO_CONN_ESTABLISHED) { - return handle_data_packet_helper(c, crypt_connection_id, packet, length, udp, userdata); + return handle_data_packet_core(c, crypt_connection_id, packet, length, udp, userdata); } return -1; diff --git a/toxcore/toxcore/tox.api.h b/toxcore/toxcore/tox.api.h index 723ce18..8cc35b8 100644 --- a/toxcore/toxcore/tox.api.h +++ b/toxcore/toxcore/tox.api.h @@ -173,23 +173,34 @@ const VERSION_MAJOR = 0; * breaking the API or ABI. Set to 0 when the major version number is * incremented. */ -const VERSION_MINOR = 0; +const VERSION_MINOR = 1; /** * The patch or revision number. Incremented when bugfixes are applied without * changing any functionality or API or ABI. */ -const VERSION_PATCH = 5; +const VERSION_PATCH = 0; /** * A macro to check at preprocessing time whether the client code is compatible - * with the installed version of Tox. + * with the installed version of Tox. Leading zeros in the version number are + * ignored. E.g. 0.1.5 is to 0.1.4 what 1.5 is to 1.4, that is: it can add new + * features, but can't break the API. */ -#define TOX_VERSION_IS_API_COMPATIBLE(MAJOR, MINOR, PATCH) \ - (TOX_VERSION_MAJOR == MAJOR && \ - (TOX_VERSION_MINOR > MINOR || \ - (TOX_VERSION_MINOR == MINOR && \ - TOX_VERSION_PATCH >= PATCH))) +#define TOX_VERSION_IS_API_COMPATIBLE(MAJOR, MINOR, PATCH) \ + (TOX_VERSION_MAJOR > 0 && TOX_VERSION_MAJOR == MAJOR) && ( \ + /* 1.x.x, 2.x.x, etc. with matching major version. */ \ + TOX_VERSION_MINOR > MINOR || \ + TOX_VERSION_MINOR == MINOR && TOX_VERSION_PATCH >= PATCH \ + ) || (TOX_VERSION_MAJOR == 0 && MAJOR == 0) && ( \ + /* 0.x.x makes minor behave like major above. */ \ + (TOX_VERSION_MINOR > 0 && TOX_VERSION_MINOR == MINOR) && ( \ + TOX_VERSION_PATCH >= PATCH \ + ) || (TOX_VERSION_MINOR == 0 && MINOR == 0) && ( \ + /* 0.0.x and 0.0.y are only compatible if x == y. */ \ + TOX_VERSION_PATCH == PATCH \ + ) \ + ) /** * A macro to make compilation fail if the client code is not compatible with diff --git a/toxcore/toxcore/tox.h b/toxcore/toxcore/tox.h index 4998609..5057e14 100644 --- a/toxcore/toxcore/tox.h +++ b/toxcore/toxcore/tox.h @@ -172,7 +172,7 @@ uint32_t tox_version_major(void); * breaking the API or ABI. Set to 0 when the major version number is * incremented. */ -#define TOX_VERSION_MINOR 0 +#define TOX_VERSION_MINOR 1 uint32_t tox_version_minor(void); @@ -180,19 +180,30 @@ uint32_t tox_version_minor(void); * The patch or revision number. Incremented when bugfixes are applied without * changing any functionality or API or ABI. */ -#define TOX_VERSION_PATCH 5 +#define TOX_VERSION_PATCH 0 uint32_t tox_version_patch(void); /** * A macro to check at preprocessing time whether the client code is compatible - * with the installed version of Tox. - */ -#define TOX_VERSION_IS_API_COMPATIBLE(MAJOR, MINOR, PATCH) \ - (TOX_VERSION_MAJOR == MAJOR && \ - (TOX_VERSION_MINOR > MINOR || \ - (TOX_VERSION_MINOR == MINOR && \ - TOX_VERSION_PATCH >= PATCH))) + * with the installed version of Tox. Leading zeros in the version number are + * ignored. E.g. 0.1.5 is to 0.1.4 what 1.5 is to 1.4, that is: it can add new + * features, but can't break the API. + */ +#define TOX_VERSION_IS_API_COMPATIBLE(MAJOR, MINOR, PATCH) \ + (TOX_VERSION_MAJOR > 0 && TOX_VERSION_MAJOR == MAJOR) && ( \ + /* 1.x.x, 2.x.x, etc. with matching major version. */ \ + TOX_VERSION_MINOR > MINOR || \ + TOX_VERSION_MINOR == MINOR && TOX_VERSION_PATCH >= PATCH \ + ) || (TOX_VERSION_MAJOR == 0 && MAJOR == 0) && ( \ + /* 0.x.x makes minor behave like major above. */ \ + (TOX_VERSION_MINOR > 0 && TOX_VERSION_MINOR == MINOR) && ( \ + TOX_VERSION_PATCH >= PATCH \ + ) || (TOX_VERSION_MINOR == 0 && MINOR == 0) && ( \ + /* 0.0.x and 0.0.y are only compatible if x == y. */ \ + TOX_VERSION_PATCH == PATCH \ + ) \ + ) /** * A macro to make compilation fail if the client code is not compatible with diff --git a/toxcore/toxcore/tox.m b/toxcore/toxcore/tox.m index 6317d12..5d239be 100644 --- a/toxcore/toxcore/tox.m +++ b/toxcore/toxcore/tox.m @@ -86,11 +86,7 @@ uint32_t tox_version_patch(void) bool tox_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch) { - return (TOX_VERSION_MAJOR == major && /* Force the major version */ - (TOX_VERSION_MINOR > minor || /* Current minor version must be newer than requested -- or -- */ - (TOX_VERSION_MINOR == minor && TOX_VERSION_PATCH >= patch) /* the patch must be the same or newer */ - ) - ); + return TOX_VERSION_IS_API_COMPATIBLE(major, minor, patch); } @@ -1593,7 +1589,7 @@ bool tox_friend_send_lossy_packet(Tox *tox, uint32_t friend_number, const uint8_ return 0; } - int ret = send_custom_lossy_packet(m, friend_number, data, length); + int ret = m_send_custom_lossy_packet(m, friend_number, data, length); set_custom_packet_error(ret, error); diff --git a/toxcore/toxencryptsave/toxencryptsave.api.h b/toxcore/toxencryptsave/toxencryptsave.api.h new file mode 100644 index 0000000..20b8da0 --- /dev/null +++ b/toxcore/toxencryptsave/toxencryptsave.api.h @@ -0,0 +1,322 @@ +%{ +/* toxencryptsave.h + * + * Batch encryption functions. + * + * Copyright (C) 2013-2016 Tox Developers. 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 . + * + */ + +#ifndef TOXENCRYPTSAVE_H +#define TOXENCRYPTSAVE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +%} + +/******************************************************************************* + * + * This module is organized into two parts. + * + * 1. A simple API operating on plain text/cipher text data and a password to + * encrypt or decrypt it. + * 2. A more advanced API that splits key derivation and encryption into two + * separate function calls. + * + * The first part is implemented in terms of the second part and simply calls + * the separate functions in sequence. Since key derivation is very expensive + * compared to the actual encryption, clients that do a lot of crypto should + * prefer the advanced API and reuse pass-key objects. + * + * To use the second part, first derive an encryption key from a password with + * ${pass_Key.derive}, then use the derived key to encrypt the data. + * + * The encrypted data is prepended with a magic number, to aid validity + * checking (no guarantees are made of course). Any data to be decrypted must + * start with the magic number. + * + * Clients should consider alerting their users that, unlike plain data, if + * even one bit becomes corrupted, the data will be entirely unrecoverable. + * Ditto if they forget their password, there is no way to recover the data. + * + *******************************************************************************/ + +class tox { + +/** + * The size of the salt part of a pass-key. + */ +const PASS_SALT_LENGTH = 32; +/** + * The size of the key part of a pass-key. + */ +const PASS_KEY_LENGTH = 32; +/** + * The amount of additional data required to store any encrypted byte array. + * Encrypting an array of N bytes requires N + $PASS_ENCRYPTION_EXTRA_LENGTH + * bytes in the encrypted byte array. + */ +const PASS_ENCRYPTION_EXTRA_LENGTH = 80; + +error for key_derivation { + NULL, + /** + * The crypto lib was unable to derive a key from the given passphrase, + * which is usually a lack of memory issue. The functions accepting keys + * do not produce this error. + */ + FAILED, +} + +error for encryption { + NULL, + /** + * The crypto lib was unable to derive a key from the given passphrase, + * which is usually a lack of memory issue. The functions accepting keys + * do not produce this error. + */ + KEY_DERIVATION_FAILED, + /** + * The encryption itself failed. + */ + FAILED, +} + +error for decryption { + NULL, + /** + * The input data was shorter than $PASS_ENCRYPTION_EXTRA_LENGTH bytes + */ + INVALID_LENGTH, + /** + * The input data is missing the magic number (i.e. wasn't created by this + * module, or is corrupted). + */ + BAD_FORMAT, + /** + * The crypto lib was unable to derive a key from the given passphrase, + * which is usually a lack of memory issue. The functions accepting keys + * do not produce this error. + */ + KEY_DERIVATION_FAILED, + /** + * The encrypted byte array could not be decrypted. Either the data was + * corrupted or the password/key was incorrect. + */ + FAILED, +} + + +/******************************************************************************* + * + * BEGIN PART 1 + * + * The simple API is presented first. If your code spends too much time using + * these functions, consider using the advanced functions instead and caching + * the generated pass-key. + * + *******************************************************************************/ + +/** + * Encrypts the given data with the given passphrase. + * + * The output array must be at least `plaintext_len + $PASS_ENCRYPTION_EXTRA_LENGTH` + * bytes long. This delegates to ${pass_Key.derive} and + * ${pass_Key.encrypt}. + * + * @param plaintext A byte array of length `plaintext_len`. + * @param plaintext_len The length of the plain text array. May be 0. + * @param passphrase The user-provided password. + * @param passphrase_len The length of the password. + * @param ciphertext The cipher text array to write the encrypted data to. + * + * @return true on success. + */ +static bool pass_encrypt(const uint8_t[plaintext_len] plaintext, const uint8_t[passphrase_len] passphrase, uint8_t *ciphertext) + with error for encryption; + + +/** + * Decrypts the given data with the given passphrase. + * + * The output array must be at least `ciphertext_len - $PASS_ENCRYPTION_EXTRA_LENGTH` + * bytes long. This delegates to ${pass_Key.decrypt}. + * + * @param ciphertext A byte array of length `ciphertext_len`. + * @param ciphertext_len The length of the cipher text array. May be 0. + * @param passphrase The user-provided password. + * @param passphrase_len The length of the password. + * @param plaintext The plain text array to write the decrypted data to. + * + * @return true on success. + */ +static bool pass_decrypt(const uint8_t[ciphertext_len] ciphertext, const uint8_t[passphrase_len] passphrase, uint8_t *plaintext) + with error for decryption; + + +/******************************************************************************* + * + * BEGIN PART 2 + * + * And now part 2, which does the actual encryption, and can be used to write + * less CPU intensive client code than part one. + * + *******************************************************************************/ + +class pass_Key { + /** + * This type represents a pass-key. + * + * A pass-key and a password are two different concepts: a password is given + * by the user in plain text. A pass-key is the generated symmetric key used + * for encryption and decryption. It is derived from a salt and the user- + * provided password. + * + * The $this structure is hidden in the implementation. It can be allocated + * using $new and must be deallocated using $free. + */ + struct this; + + /** + * Create a new $this. The initial value of it is indeterminate. To + * initialise it, use one of the derive_* functions below. + */ + static this new(); + + /** + * Deallocate a $this. This function behaves like free(), so NULL is an + * acceptable argument value. + */ + void free(); + + /** + * Generates a secret symmetric key from the given passphrase. + * + * Be sure to not compromise the key! Only keep it in memory, do not write + * it to disk. + * + * Note that this function is not deterministic; to derive the same key from + * a password, you also must know the random salt that was used. A + * deterministic version of this function is $derive_with_salt. + * + * @param passphrase The user-provided password. + * @param passphrase_len The length of the password. + * + * @return true on success. + */ + bool derive(const uint8_t[passphrase_len] passphrase) + with error for key_derivation; + + /** + * Same as above, except use the given salt for deterministic key derivation. + * + * @param passphrase The user-provided password. + * @param passphrase_len The length of the password. + * @param salt An array of at least $PASS_SALT_LENGTH bytes. + * + * @return true on success. + */ + bool derive_with_salt(const uint8_t[passphrase_len] passphrase, const uint8_t[PASS_SALT_LENGTH] salt) + with error for key_derivation; + + /** + * Encrypt a plain text with a key produced by $derive or $derive_with_salt. + * + * The output array must be at least `plaintext_len + $PASS_ENCRYPTION_EXTRA_LENGTH` + * bytes long. + * + * @param plaintext A byte array of length `plaintext_len`. + * @param plaintext_len The length of the plain text array. May be 0. + * @param ciphertext The cipher text array to write the encrypted data to. + * + * @return true on success. + */ + const bool encrypt(const uint8_t[plaintext_len] plaintext, uint8_t *ciphertext) + with error for encryption; + + /** + * This is the inverse of $encrypt, also using only keys produced by + * $derive or $derive_with_salt. + * + * @param ciphertext A byte array of length `ciphertext_len`. + * @param ciphertext_len The length of the cipher text array. May be 0. + * @param plaintext The plain text array to write the decrypted data to. + * + * @return true on success. + */ + const bool decrypt(const uint8_t[ciphertext_len] ciphertext, uint8_t *plaintext) + with error for decryption; +} + +/** + * Retrieves the salt used to encrypt the given data. + * + * The retrieved salt can then be passed to ${pass_Key.derive_with_salt} to + * produce the same key as was previously used. Any data encrypted with this + * module can be used as input. + * + * The cipher text must be at least $PASS_ENCRYPTION_EXTRA_LENGTH bytes in length. + * The salt must be $PASS_SALT_LENGTH bytes in length. + * If the passed byte arrays are smaller than required, the behaviour is + * undefined. + * + * Success does not say anything about the validity of the data, only that + * data of the appropriate size was copied. + * + * @return true on success. + */ +static bool get_salt(const uint8_t *ciphertext, uint8_t[PASS_SALT_LENGTH] salt) { + NULL, + /** + * The input data is missing the magic number (i.e. wasn't created by this + * module, or is corrupted). + */ + BAD_FORMAT, +} + +/** + * Determines whether or not the given data is encrypted by this module. + * + * It does this check by verifying that the magic number is the one put in + * place by the encryption functions. + * + * The data must be at least $PASS_ENCRYPTION_EXTRA_LENGTH bytes in length. + * If the passed byte array is smaller than required, the behaviour is + * undefined. + * + * If the cipher text pointer is NULL, this function returns false. + * + * @return true if the data is encrypted by this module. + */ +static bool is_data_encrypted(const uint8_t *data); + +} + +%{ + +#ifdef __cplusplus +} +#endif + +#endif +%} diff --git a/toxcore/toxencryptsave/toxencryptsave.h b/toxcore/toxencryptsave/toxencryptsave.h index a6537fa..584efae 100644 --- a/toxcore/toxencryptsave/toxencryptsave.h +++ b/toxcore/toxencryptsave/toxencryptsave.h @@ -1,8 +1,8 @@ /* toxencryptsave.h * - * The Tox encrypted save functions. + * Batch encryption functions. * - * Copyright (C) 2013 Tox project All Rights Reserved. + * Copyright (C) 2013-2016 Tox Developers. All Rights Reserved. * * This file is part of Tox. * @@ -32,210 +32,350 @@ extern "C" { #include #include -#ifndef TOX_DEFINED -#define TOX_DEFINED -typedef struct Tox Tox; -struct Tox_Options; -#endif -#define TOX_PASS_SALT_LENGTH 32 -#define TOX_PASS_KEY_LENGTH 32 -#define TOX_PASS_ENCRYPTION_EXTRA_LENGTH 80 +/******************************************************************************* + * + * This module is organized into two parts. + * + * 1. A simple API operating on plain text/cipher text data and a password to + * encrypt or decrypt it. + * 2. A more advanced API that splits key derivation and encryption into two + * separate function calls. + * + * The first part is implemented in terms of the second part and simply calls + * the separate functions in sequence. Since key derivation is very expensive + * compared to the actual encryption, clients that do a lot of crypto should + * prefer the advanced API and reuse pass-key objects. + * + * To use the second part, first derive an encryption key from a password with + * , then use the derived key to encrypt the data. + * + * The encrypted data is prepended with a magic number, to aid validity + * checking (no guarantees are made of course). Any data to be decrypted must + * start with the magic number. + * + * Clients should consider alerting their users that, unlike plain data, if + * even one bit becomes corrupted, the data will be entirely unrecoverable. + * Ditto if they forget their password, there is no way to recover the data. + * + ******************************************************************************/ + + /** - * ToxEncryptSave. + * The size of the salt part of a pass-key. */ -#ifndef TOXES_DEFINED -#define TOXES_DEFINED -#endif /* TOXES_DEFINED */ - -/* This module is conceptually organized into two parts. The first part are the functions - * with "key" in the name. To use these functions, first derive an encryption key - * from a password with tox_derive_key_from_pass, and use the returned key to - * encrypt the data. The second part takes the password itself instead of the key, - * and then delegates to the first part to derive the key before de/encryption, - * which can simplify client code; however, key derivation is very expensive - * compared to the actual encryption, so clients that do a lot of encryption should - * favor using the first part intead of the second part. - * - * The encrypted data is prepended with a magic number, to aid validity checking - * (no guarantees are made of course). Any data to be decrypted must start with - * the magic number. - * - * Clients should consider alerting their users that, unlike plain data, if even one bit - * becomes corrupted, the data will be entirely unrecoverable. - * Ditto if they forget their password, there is no way to recover the data. +#define TOX_PASS_SALT_LENGTH 32 + +uint32_t tox_pass_salt_length(void); + +/** + * The size of the key part of a pass-key. */ +#define TOX_PASS_KEY_LENGTH 32 -/* Since apparently no one actually bothered to learn about the module previously, - * the recently removed functions tox_encrypted_new and tox_get_encrypted_savedata - * may be trivially replaced by calls to tox_pass_decrypt -> tox_new or - * tox_get_savedata -> tox_pass_encrypt as appropriate. The removed functions - * were never more than 5 line wrappers of the other public API functions anyways. - * (As has always been, tox_pass_decrypt and tox_pass_encrypt are interchangeable - * with tox_pass_key_decrypt and tox_pass_key_encrypt, as the client program requires.) +uint32_t tox_pass_key_length(void); + +/** + * The amount of additional data required to store any encrypted byte array. + * Encrypting an array of N bytes requires N + TOX_PASS_ENCRYPTION_EXTRA_LENGTH + * bytes in the encrypted byte array. */ +#define TOX_PASS_ENCRYPTION_EXTRA_LENGTH 80 + +uint32_t tox_pass_encryption_extra_length(void); typedef enum TOX_ERR_KEY_DERIVATION { + + /** + * The function returned successfully. + */ TOX_ERR_KEY_DERIVATION_OK, + /** - * Some input data, or maybe the output pointer, was null. + * One of the arguments to the function was NULL when it was not expected. */ TOX_ERR_KEY_DERIVATION_NULL, + /** * The crypto lib was unable to derive a key from the given passphrase, * which is usually a lack of memory issue. The functions accepting keys * do not produce this error. */ - TOX_ERR_KEY_DERIVATION_FAILED + TOX_ERR_KEY_DERIVATION_FAILED, + } TOX_ERR_KEY_DERIVATION; + typedef enum TOX_ERR_ENCRYPTION { + + /** + * The function returned successfully. + */ TOX_ERR_ENCRYPTION_OK, + /** - * Some input data, or maybe the output pointer, was null. + * One of the arguments to the function was NULL when it was not expected. */ TOX_ERR_ENCRYPTION_NULL, + /** * The crypto lib was unable to derive a key from the given passphrase, * which is usually a lack of memory issue. The functions accepting keys * do not produce this error. */ TOX_ERR_ENCRYPTION_KEY_DERIVATION_FAILED, + /** * The encryption itself failed. */ - TOX_ERR_ENCRYPTION_FAILED + TOX_ERR_ENCRYPTION_FAILED, + } TOX_ERR_ENCRYPTION; + typedef enum TOX_ERR_DECRYPTION { + + /** + * The function returned successfully. + */ TOX_ERR_DECRYPTION_OK, + /** - * Some input data, or maybe the output pointer, was null. + * One of the arguments to the function was NULL when it was not expected. */ TOX_ERR_DECRYPTION_NULL, + /** * The input data was shorter than TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes */ TOX_ERR_DECRYPTION_INVALID_LENGTH, + /** * The input data is missing the magic number (i.e. wasn't created by this - * module, or is corrupted) + * module, or is corrupted). */ TOX_ERR_DECRYPTION_BAD_FORMAT, + /** * The crypto lib was unable to derive a key from the given passphrase, * which is usually a lack of memory issue. The functions accepting keys * do not produce this error. */ TOX_ERR_DECRYPTION_KEY_DERIVATION_FAILED, + /** * The encrypted byte array could not be decrypted. Either the data was - * corrupt or the password/key was incorrect. + * corrupted or the password/key was incorrect. */ - TOX_ERR_DECRYPTION_FAILED + TOX_ERR_DECRYPTION_FAILED, + } TOX_ERR_DECRYPTION; -/******************************* BEGIN PART 2 ******************************* - * For simplicty, the second part of the module is presented first. The API for - * the first part is analgous, with some extra functions for key handling. If - * your code spends too much time using these functions, consider using the part - * 1 functions instead. + +/******************************************************************************* + * + * BEGIN PART 1 + * + * The simple API is presented first. If your code spends too much time using + * these functions, consider using the advanced functions instead and caching + * the generated pass-key. + * + ******************************************************************************/ + + + +/** + * Encrypts the given data with the given passphrase. + * + * The output array must be at least `plaintext_len + TOX_PASS_ENCRYPTION_EXTRA_LENGTH` + * bytes long. This delegates to tox_pass_key_derive and + * tox_pass_key_encrypt. + * + * @param plaintext A byte array of length `plaintext_len`. + * @param plaintext_len The length of the plain text array. May be 0. + * @param passphrase The user-provided password. + * @param passphrase_len The length of the password. + * @param ciphertext The cipher text array to write the encrypted data to. + * + * @return true on success. */ +bool tox_pass_encrypt(const uint8_t *plaintext, size_t plaintext_len, const uint8_t *passphrase, size_t passphrase_len, + uint8_t *ciphertext, TOX_ERR_ENCRYPTION *error); -/* Encrypts the given data with the given passphrase. The output array must be - * at least data_len + TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes long. This delegates - * to tox_derive_key_from_pass and tox_pass_key_encrypt. +/** + * Decrypts the given data with the given passphrase. + * + * The output array must be at least `ciphertext_len - TOX_PASS_ENCRYPTION_EXTRA_LENGTH` + * bytes long. This delegates to tox_pass_key_decrypt. * - * returns true on success + * @param ciphertext A byte array of length `ciphertext_len`. + * @param ciphertext_len The length of the cipher text array. May be 0. + * @param passphrase The user-provided password. + * @param passphrase_len The length of the password. + * @param plaintext The plain text array to write the decrypted data to. + * + * @return true on success. */ -bool tox_pass_encrypt(const uint8_t *data, size_t data_len, const uint8_t *passphrase, size_t pplength, uint8_t *out, - TOX_ERR_ENCRYPTION *error); +bool tox_pass_decrypt(const uint8_t *ciphertext, size_t ciphertext_len, const uint8_t *passphrase, + size_t passphrase_len, uint8_t *plaintext, TOX_ERR_DECRYPTION *error); -/* Decrypts the given data with the given passphrase. The output array must be - * at least data_len - TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes long. This delegates - * to tox_pass_key_decrypt. +/******************************************************************************* * - * the output data has size data_length - TOX_PASS_ENCRYPTION_EXTRA_LENGTH + * BEGIN PART 2 * - * returns true on success - */ -bool tox_pass_decrypt(const uint8_t *data, size_t length, const uint8_t *passphrase, size_t pplength, uint8_t *out, - TOX_ERR_DECRYPTION *error); + * And now part 2, which does the actual encryption, and can be used to write + * less CPU intensive client code than part one. + * + ******************************************************************************/ -/******************************* BEGIN PART 1 ******************************* - * And now part "1", which does the actual encryption, and is rather less cpu - * intensive than part one. The first 3 functions are for key handling. + +/** + * This type represents a pass-key. + * + * A pass-key and a password are two different concepts: a password is given + * by the user in plain text. A pass-key is the generated symmetric key used + * for encryption and decryption. It is derived from a salt and the user- + * provided password. + * + * The Tox_Pass_Key structure is hidden in the implementation. It can be allocated + * using tox_pass_key_new and must be deallocated using tox_pass_key_free. */ +#ifndef TOX_PASS_KEY_DEFINED +#define TOX_PASS_KEY_DEFINED +typedef struct Tox_Pass_Key Tox_Pass_Key; +#endif /* TOX_PASS_KEY_DEFINED */ -/* This key structure's internals should not be used by any client program, even - * if they are straightforward here. +/** + * Create a new Tox_Pass_Key. The initial value of it is indeterminate. To + * initialise it, use one of the derive_* functions below. */ -typedef struct { - uint8_t salt[TOX_PASS_SALT_LENGTH]; - uint8_t key[TOX_PASS_KEY_LENGTH]; -} TOX_PASS_KEY; - -/* Generates a secret symmetric key from the given passphrase. out_key must be at least - * TOX_PASS_KEY_LENGTH bytes long. - * Be sure to not compromise the key! Only keep it in memory, do not write to disk. - * The password is zeroed after key derivation. - * The key should only be used with the other functions in this module, as it - * includes a salt. - * Note that this function is not deterministic; to derive the same key from a - * password, you also must know the random salt that was used. See below. - * - * returns true on success +struct Tox_Pass_Key *tox_pass_key_new(void); + +/** + * Deallocate a Tox_Pass_Key. This function behaves like free(), so NULL is an + * acceptable argument value. */ -bool tox_derive_key_from_pass(const uint8_t *passphrase, size_t pplength, TOX_PASS_KEY *out_key, - TOX_ERR_KEY_DERIVATION *error); +void tox_pass_key_free(struct Tox_Pass_Key *_key); -/* Same as above, except use the given salt for deterministic key derivation. - * The salt must be TOX_PASS_SALT_LENGTH bytes in length. +/** + * Generates a secret symmetric key from the given passphrase. + * + * Be sure to not compromise the key! Only keep it in memory, do not write + * it to disk. + * + * Note that this function is not deterministic; to derive the same key from + * a password, you also must know the random salt that was used. A + * deterministic version of this function is tox_pass_key_derive_with_salt. + * + * @param passphrase The user-provided password. + * @param passphrase_len The length of the password. + * + * @return true on success. */ -bool tox_derive_key_with_salt(const uint8_t *passphrase, size_t pplength, const uint8_t *salt, TOX_PASS_KEY *out_key, - TOX_ERR_KEY_DERIVATION *error); +bool tox_pass_key_derive(struct Tox_Pass_Key *_key, const uint8_t *passphrase, size_t passphrase_len, + TOX_ERR_KEY_DERIVATION *error); -/* This retrieves the salt used to encrypt the given data, which can then be passed to - * derive_key_with_salt to produce the same key as was previously used. Any encrpyted - * data with this module can be used as input. +/** + * Same as above, except use the given salt for deterministic key derivation. + * + * @param passphrase The user-provided password. + * @param passphrase_len The length of the password. + * @param salt An array of at least TOX_PASS_SALT_LENGTH bytes. * - * returns true if magic number matches - * success does not say anything about the validity of the data, only that data of - * the appropriate size was copied + * @return true on success. */ -bool tox_get_salt(const uint8_t *data, uint8_t *salt); +bool tox_pass_key_derive_with_salt(struct Tox_Pass_Key *_key, const uint8_t *passphrase, size_t passphrase_len, + const uint8_t *salt, TOX_ERR_KEY_DERIVATION *error); -/* Now come the functions that are analogous to the part 2 functions. */ +/** + * Encrypt a plain text with a key produced by tox_pass_key_derive or tox_pass_key_derive_with_salt. + * + * The output array must be at least `plaintext_len + TOX_PASS_ENCRYPTION_EXTRA_LENGTH` + * bytes long. + * + * @param plaintext A byte array of length `plaintext_len`. + * @param plaintext_len The length of the plain text array. May be 0. + * @param ciphertext The cipher text array to write the encrypted data to. + * + * @return true on success. + */ +bool tox_pass_key_encrypt(const struct Tox_Pass_Key *_key, const uint8_t *plaintext, size_t plaintext_len, + uint8_t *ciphertext, TOX_ERR_ENCRYPTION *error); -/* Encrypt arbitrary with a key produced by tox_derive_key_*. The output - * array must be at least data_len + TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes long. - * key must be TOX_PASS_KEY_LENGTH bytes. - * If you already have a symmetric key from somewhere besides this module, simply - * call encrypt_data_symmetric in toxcore/crypto_core directly. +/** + * This is the inverse of tox_pass_key_encrypt, also using only keys produced by + * tox_pass_key_derive or tox_pass_key_derive_with_salt. * - * returns true on success + * @param ciphertext A byte array of length `ciphertext_len`. + * @param ciphertext_len The length of the cipher text array. May be 0. + * @param plaintext The plain text array to write the decrypted data to. + * + * @return true on success. */ -bool tox_pass_key_encrypt(const uint8_t *data, size_t data_len, const TOX_PASS_KEY *key, uint8_t *out, - TOX_ERR_ENCRYPTION *error); +bool tox_pass_key_decrypt(const struct Tox_Pass_Key *_key, const uint8_t *ciphertext, size_t ciphertext_len, + uint8_t *plaintext, TOX_ERR_DECRYPTION *error); + +typedef enum TOX_ERR_GET_SALT { + + /** + * The function returned successfully. + */ + TOX_ERR_GET_SALT_OK, + + /** + * One of the arguments to the function was NULL when it was not expected. + */ + TOX_ERR_GET_SALT_NULL, + + /** + * The input data is missing the magic number (i.e. wasn't created by this + * module, or is corrupted). + */ + TOX_ERR_GET_SALT_BAD_FORMAT, + +} TOX_ERR_GET_SALT; -/* This is the inverse of tox_pass_key_encrypt, also using only keys produced by - * tox_derive_key_from_pass. + +/** + * Retrieves the salt used to encrypt the given data. + * + * The retrieved salt can then be passed to tox_pass_key_derive_with_salt to + * produce the same key as was previously used. Any data encrypted with this + * module can be used as input. + * + * The cipher text must be at least TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes in length. + * The salt must be TOX_PASS_SALT_LENGTH bytes in length. + * If the passed byte arrays are smaller than required, the behaviour is + * undefined. * - * the output data has size data_length - TOX_PASS_ENCRYPTION_EXTRA_LENGTH + * Success does not say anything about the validity of the data, only that + * data of the appropriate size was copied. * - * returns true on success + * @return true on success. */ -bool tox_pass_key_decrypt(const uint8_t *data, size_t length, const TOX_PASS_KEY *key, uint8_t *out, - TOX_ERR_DECRYPTION *error); +bool tox_get_salt(const uint8_t *ciphertext, uint8_t *salt, TOX_ERR_GET_SALT *error); -/* Determines whether or not the given data is encrypted (by checking the magic number) +/** + * Determines whether or not the given data is encrypted by this module. + * + * It does this check by verifying that the magic number is the one put in + * place by the encryption functions. + * + * The data must be at least TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes in length. + * If the passed byte array is smaller than required, the behaviour is + * undefined. + * + * If the cipher text pointer is NULL, this function returns false. + * + * @return true if the data is encrypted by this module. */ bool tox_is_data_encrypted(const uint8_t *data); + #ifdef __cplusplus } #endif diff --git a/toxcore/toxencryptsave/toxencryptsave.m b/toxcore/toxencryptsave/toxencryptsave.m index a6a75b0..19aa2a1 100644 --- a/toxcore/toxencryptsave/toxencryptsave.m +++ b/toxcore/toxencryptsave/toxencryptsave.m @@ -47,28 +47,70 @@ #error TOX_PASS_ENCRYPTION_EXTRA_LENGTH is assumed to be equal to (crypto_box_MACBYTES + crypto_box_NONCEBYTES + crypto_pwhash_scryptsalsa208sha256_SALTBYTES + TOX_ENC_SAVE_MAGIC_LENGTH) #endif +struct Tox_Pass_Key { + uint8_t salt[TOX_PASS_SALT_LENGTH]; + uint8_t key[TOX_PASS_KEY_LENGTH]; +}; + +Tox_Pass_Key *tox_pass_key_new(void) +{ + return (Tox_Pass_Key *)malloc(sizeof(Tox_Pass_Key)); +} + +void tox_pass_key_free(Tox_Pass_Key *pass_key) +{ + free(pass_key); +} + +void tox_pass_key_get_salt(const Tox_Pass_Key *pass_key, uint8_t *salt) +{ + memcpy(salt, pass_key->salt, TOX_PASS_SALT_LENGTH); +} + +void tox_pass_key_set_salt(Tox_Pass_Key *pass_key, const uint8_t *salt) +{ + memcpy(pass_key->salt, salt, TOX_PASS_SALT_LENGTH); +} + +void tox_pass_key_get_key(const Tox_Pass_Key *pass_key, uint8_t *key) +{ + memcpy(key, pass_key->key, TOX_PASS_KEY_LENGTH); +} + +void tox_pass_key_set_key(Tox_Pass_Key *pass_key, const uint8_t *key) +{ + memcpy(pass_key->key, key, TOX_PASS_KEY_LENGTH); +} + /* Clients should consider alerting their users that, unlike plain data, if even one bit * becomes corrupted, the data will be entirely unrecoverable. * Ditto if they forget their password, there is no way to recover the data. */ /* This retrieves the salt used to encrypt the given data, which can then be passed to - * derive_key_with_salt to produce the same key as was previously used. Any encrpyted + * tox_pass_key_derive_with_salt to produce the same key as was previously used. Any encrpyted * data with this module can be used as input. * * returns true if magic number matches * success does not say anything about the validity of the data, only that data of * the appropriate size was copied */ -bool tox_get_salt(const uint8_t *data, uint8_t *salt) +bool tox_get_salt(const uint8_t *data, uint8_t *salt, TOX_ERR_GET_SALT *error) { + if (!data || !salt) { + SET_ERROR_PARAMETER(error, TOX_ERR_GET_SALT_NULL); + return false; + } + if (memcmp(data, TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH) != 0) { - return 0; + SET_ERROR_PARAMETER(error, TOX_ERR_GET_SALT_BAD_FORMAT); + return false; } data += TOX_ENC_SAVE_MAGIC_LENGTH; memcpy(salt, data, crypto_pwhash_scryptsalsa208sha256_SALTBYTES); - return 1; + SET_ERROR_PARAMETER(error, TOX_ERR_GET_SALT_OK); + return true; } /* Generates a secret symmetric key from the given passphrase. out_key must be at least @@ -82,19 +124,19 @@ bool tox_get_salt(const uint8_t *data, uint8_t *salt) * * returns true on success */ -bool tox_derive_key_from_pass(const uint8_t *passphrase, size_t pplength, TOX_PASS_KEY *out_key, - TOX_ERR_KEY_DERIVATION *error) +bool tox_pass_key_derive(Tox_Pass_Key *out_key, const uint8_t *passphrase, size_t pplength, + TOX_ERR_KEY_DERIVATION *error) { uint8_t salt[crypto_pwhash_scryptsalsa208sha256_SALTBYTES]; randombytes(salt, sizeof salt); - return tox_derive_key_with_salt(passphrase, pplength, salt, out_key, error); + return tox_pass_key_derive_with_salt(out_key, passphrase, pplength, salt, error); } /* Same as above, except with use the given salt for deterministic key derivation. * The salt must be TOX_PASS_SALT_LENGTH bytes in length. */ -bool tox_derive_key_with_salt(const uint8_t *passphrase, size_t pplength, const uint8_t *salt, TOX_PASS_KEY *out_key, - TOX_ERR_KEY_DERIVATION *error) +bool tox_pass_key_derive_with_salt(Tox_Pass_Key *out_key, const uint8_t *passphrase, size_t pplength, + const uint8_t *salt, TOX_ERR_KEY_DERIVATION *error) { if (!salt || !out_key || (!passphrase && pplength != 0)) { SET_ERROR_PARAMETER(error, TOX_ERR_KEY_DERIVATION_NULL); @@ -134,7 +176,7 @@ bool tox_derive_key_with_salt(const uint8_t *passphrase, size_t pplength, const * * returns true on success */ -bool tox_pass_key_encrypt(const uint8_t *data, size_t data_len, const TOX_PASS_KEY *key, uint8_t *out, +bool tox_pass_key_encrypt(const Tox_Pass_Key *key, const uint8_t *data, size_t data_len, uint8_t *out, TOX_ERR_ENCRYPTION *error) { if (data_len == 0 || !data || !key || !out) { @@ -176,17 +218,17 @@ bool tox_pass_key_encrypt(const uint8_t *data, size_t data_len, const TOX_PASS_K /* Encrypts the given data with the given passphrase. The output array must be * at least data_len + TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes long. This delegates - * to tox_derive_key_from_pass and tox_pass_key_encrypt. + * to tox_derive_key and tox_pass_key_encrypt. * * returns true on success */ bool tox_pass_encrypt(const uint8_t *data, size_t data_len, const uint8_t *passphrase, size_t pplength, uint8_t *out, TOX_ERR_ENCRYPTION *error) { - TOX_PASS_KEY key; + Tox_Pass_Key key; TOX_ERR_KEY_DERIVATION _error; - if (!tox_derive_key_from_pass(passphrase, pplength, &key, &_error)) { + if (!tox_pass_key_derive(&key, passphrase, pplength, &_error)) { if (_error == TOX_ERR_KEY_DERIVATION_NULL) { SET_ERROR_PARAMETER(error, TOX_ERR_ENCRYPTION_NULL); } else if (_error == TOX_ERR_KEY_DERIVATION_FAILED) { @@ -196,17 +238,17 @@ bool tox_pass_encrypt(const uint8_t *data, size_t data_len, const uint8_t *passp return 0; } - return tox_pass_key_encrypt(data, data_len, &key, out, error); + return tox_pass_key_encrypt(&key, data, data_len, out, error); } /* This is the inverse of tox_pass_key_encrypt, also using only keys produced by - * tox_derive_key_from_pass. + * tox_derive_key. * * the output data has size data_length - TOX_PASS_ENCRYPTION_EXTRA_LENGTH * * returns true on success */ -bool tox_pass_key_decrypt(const uint8_t *data, size_t length, const TOX_PASS_KEY *key, uint8_t *out, +bool tox_pass_key_decrypt(const Tox_Pass_Key *key, const uint8_t *data, size_t length, uint8_t *out, TOX_ERR_DECRYPTION *error) { if (length <= TOX_PASS_ENCRYPTION_EXTRA_LENGTH) { @@ -274,15 +316,15 @@ bool tox_pass_decrypt(const uint8_t *data, size_t length, const uint8_t *passphr memcpy(salt, data + TOX_ENC_SAVE_MAGIC_LENGTH, crypto_pwhash_scryptsalsa208sha256_SALTBYTES); /* derive the key */ - TOX_PASS_KEY key; + Tox_Pass_Key key; - if (!tox_derive_key_with_salt(passphrase, pplength, salt, &key, NULL)) { + if (!tox_pass_key_derive_with_salt(&key, passphrase, pplength, salt, NULL)) { /* out of memory most likely */ SET_ERROR_PARAMETER(error, TOX_ERR_DECRYPTION_KEY_DERIVATION_FAILED); return 0; } - return tox_pass_key_decrypt(data, length, &key, out, error); + return tox_pass_key_decrypt(&key, data, length, out, error); } /* Determines whether or not the given data is encrypted (by checking the magic number)