1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2016-2018 The TokTok team.
* Copyright © 2013 Tox project.
*/
/*
* Functions for the core crypto.
*/
#ifndef C_TOXCORE_TOXCORE_CRYPTO_CORE_H
#define C_TOXCORE_TOXCORE_CRYPTO_CORE_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* 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 uint8_t *p1, const uint8_t *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 8 bit integer.
*/
uint8_t random_u08(void);
/**
* Return a random 16 bit integer.
*/
uint16_t random_u16(void);
/**
* Return a random 32 bit integer.
*/
uint32_t random_u32(void);
/**
* Return a random 64 bit integer.
*/
uint64_t random_u64(void);
/**
* Fill the given nonce with random bytes.
*/
void random_nonce(uint8_t *nonce);
/**
* Fill an array of bytes with random values.
*/
void random_bytes(uint8_t *bytes, size_t length);
/**
* 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 performed 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 a key CRYPTO_SYMMETRIC_KEY_SIZE big with random bytes.
*/
void new_symmetric_key(uint8_t *key);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // C_TOXCORE_TOXCORE_CRYPTO_CORE_H
|
