-
Notifications
You must be signed in to change notification settings - Fork 1.2k
/
crypto-utils-polarssl.c
293 lines (224 loc) · 6.25 KB
/
crypto-utils-polarssl.c
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
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
/*
* This file Copyright (C) 2014-2016 Mnemosyne LLC
*
* It may be used under the GNU GPL versions 2 or 3
* or any future license endorsed by Mnemosyne LLC.
*
*/
#if defined(POLARSSL_IS_MBEDTLS)
#define API_HEADER(x) <mbedtls/x>
#define API(x) mbedtls_##x
#define API_VERSION_NUMBER MBEDTLS_VERSION_NUMBER
#else
#define API_HEADER(x) <polarssl/x>
#define API(x) x
#define API_VERSION_NUMBER POLARSSL_VERSION_NUMBER
#endif
#include API_HEADER(base64.h)
#include API_HEADER(ctr_drbg.h)
#include API_HEADER(dhm.h)
#include API_HEADER(error.h)
#include API_HEADER(sha1.h)
#include API_HEADER(version.h)
#include "transmission.h"
#include "crypto-utils.h"
#include "log.h"
#include "platform.h"
#include "tr-assert.h"
#include "utils.h"
#define TR_CRYPTO_DH_SECRET_FALLBACK
#define TR_CRYPTO_X509_FALLBACK
#include "crypto-utils-fallback.c"
/***
****
***/
#define MY_NAME "tr_crypto_utils"
typedef API(ctr_drbg_context) api_ctr_drbg_context;
typedef API(sha1_context) api_sha1_context;
typedef API(dhm_context) api_dhm_context;
static void log_polarssl_error(int error_code, char const* file, int line)
{
if (tr_logLevelIsActive(TR_LOG_ERROR))
{
char error_message[256];
#if defined(POLARSSL_IS_MBEDTLS)
mbedtls_strerror(error_code, error_message, sizeof(error_message));
#elif API_VERSION_NUMBER >= 0x01030000
polarssl_strerror(error_code, error_message, sizeof(error_message));
#else
error_strerror(error_code, error_message, sizeof(error_message));
#endif
tr_logAddMessage(file, line, TR_LOG_ERROR, MY_NAME, "PolarSSL error: %s", error_message);
}
}
#define log_error(error_code) log_polarssl_error((error_code), __FILE__, __LINE__)
static bool check_polarssl_result(int result, int expected_result, char const* file, int line)
{
bool const ret = result == expected_result;
if (!ret)
{
log_polarssl_error(result, file, line);
}
return ret;
}
#define check_result(result) check_polarssl_result((result), 0, __FILE__, __LINE__)
#define check_result_eq(result, x_result) check_polarssl_result((result), (x_result), __FILE__, __LINE__)
/***
****
***/
static int my_rand(void* context, unsigned char* buffer, size_t buffer_size)
{
TR_UNUSED(context);
for (size_t i = 0; i < buffer_size; ++i)
{
buffer[i] = tr_rand_int_weak(256);
}
return 0;
}
static api_ctr_drbg_context* get_rng(void)
{
static api_ctr_drbg_context rng;
static bool rng_initialized = false;
if (!rng_initialized)
{
#if API_VERSION_NUMBER >= 0x02000000
API(ctr_drbg_init)(&rng);
if (!check_result(API(ctr_drbg_seed)(&rng, &my_rand, NULL, NULL, 0)))
#else
if (!check_result(API(ctr_drbg_init)(&rng, &my_rand, NULL, NULL, 0)))
#endif
{
return NULL;
}
rng_initialized = true;
}
return &rng;
}
static tr_lock* get_rng_lock(void)
{
static tr_lock* lock = NULL;
if (lock == NULL)
{
lock = tr_lockNew();
}
return lock;
}
/***
****
***/
tr_sha1_ctx_t tr_sha1_init(void)
{
api_sha1_context* handle = tr_new0(api_sha1_context, 1);
#if API_VERSION_NUMBER >= 0x01030800
API(sha1_init)(handle);
#endif
API(sha1_starts)(handle);
return handle;
}
bool tr_sha1_update(tr_sha1_ctx_t handle, void const* data, size_t data_length)
{
TR_ASSERT(handle != NULL);
if (data_length == 0)
{
return true;
}
TR_ASSERT(data != NULL);
API(sha1_update)(handle, data, data_length);
return true;
}
bool tr_sha1_final(tr_sha1_ctx_t handle, uint8_t* hash)
{
if (hash != NULL)
{
TR_ASSERT(handle != NULL);
API(sha1_finish)(handle, hash);
}
#if API_VERSION_NUMBER >= 0x01030800
API(sha1_free)(handle);
#endif
tr_free(handle);
return true;
}
/***
****
***/
tr_dh_ctx_t tr_dh_new(
uint8_t const* prime_num,
size_t prime_num_length,
uint8_t const* generator_num,
size_t generator_num_length)
{
TR_ASSERT(prime_num != NULL);
TR_ASSERT(generator_num != NULL);
api_dhm_context* handle = tr_new0(api_dhm_context, 1);
#if API_VERSION_NUMBER >= 0x01030800
API(dhm_init)(handle);
#endif
if (!check_result(API(mpi_read_binary)(&handle->P, prime_num, prime_num_length)) ||
!check_result(API(mpi_read_binary)(&handle->G, generator_num, generator_num_length)))
{
API(dhm_free)(handle);
return NULL;
}
handle->len = prime_num_length;
return handle;
}
void tr_dh_free(tr_dh_ctx_t handle)
{
if (handle == NULL)
{
return;
}
API(dhm_free)(handle);
}
bool tr_dh_make_key(tr_dh_ctx_t raw_handle, size_t private_key_length, uint8_t* public_key, size_t* public_key_length)
{
TR_ASSERT(raw_handle != NULL);
TR_ASSERT(public_key != NULL);
api_dhm_context* handle = raw_handle;
if (public_key_length != NULL)
{
*public_key_length = handle->len;
}
return check_result(API(dhm_make_public)(handle, private_key_length, public_key, handle->len, my_rand, NULL));
}
tr_dh_secret_t tr_dh_agree(tr_dh_ctx_t raw_handle, uint8_t const* other_public_key, size_t other_public_key_length)
{
TR_ASSERT(raw_handle != NULL);
TR_ASSERT(other_public_key != NULL);
api_dhm_context* handle = raw_handle;
struct tr_dh_secret* ret;
size_t secret_key_length;
if (!check_result(API(dhm_read_public)(handle, other_public_key, other_public_key_length)))
{
return NULL;
}
ret = tr_dh_secret_new(handle->len);
secret_key_length = handle->len;
#if API_VERSION_NUMBER >= 0x02000000
if (!check_result(API(dhm_calc_secret)(handle, ret->key, secret_key_length, &secret_key_length, my_rand, NULL)))
#elif API_VERSION_NUMBER >= 0x01030000
if (!check_result(API(dhm_calc_secret)(handle, ret->key, &secret_key_length, my_rand, NULL)))
#else
if (!check_result(API(dhm_calc_secret)(handle, ret->key, &secret_key_length)))
#endif
{
tr_dh_secret_free(ret);
return NULL;
}
tr_dh_secret_align(ret, secret_key_length);
return ret;
}
/***
****
***/
bool tr_rand_buffer(void* buffer, size_t length)
{
TR_ASSERT(buffer != NULL);
bool ret;
tr_lock* rng_lock = get_rng_lock();
tr_lockLock(rng_lock);
ret = check_result(API(ctr_drbg_random)(get_rng(), buffer, length));
tr_lockUnlock(rng_lock);
return ret;
}