Line data Source code
1 : /*
2 : * Wrapper functions for OpenSSL libcrypto
3 : * Copyright (c) 2004-2015, Jouni Malinen <j@w1.fi>
4 : *
5 : * This software may be distributed under the terms of the BSD license.
6 : * See README for more details.
7 : */
8 :
9 : #include "includes.h"
10 : #include <openssl/opensslv.h>
11 : #include <openssl/err.h>
12 : #include <openssl/des.h>
13 : #include <openssl/aes.h>
14 : #include <openssl/bn.h>
15 : #include <openssl/evp.h>
16 : #include <openssl/dh.h>
17 : #include <openssl/hmac.h>
18 : #include <openssl/rand.h>
19 : #ifdef CONFIG_OPENSSL_CMAC
20 : #include <openssl/cmac.h>
21 : #endif /* CONFIG_OPENSSL_CMAC */
22 : #ifdef CONFIG_ECC
23 : #include <openssl/ec.h>
24 : #endif /* CONFIG_ECC */
25 :
26 : #include "common.h"
27 : #include "wpabuf.h"
28 : #include "dh_group5.h"
29 : #include "sha1.h"
30 : #include "sha256.h"
31 : #include "sha384.h"
32 : #include "md5.h"
33 : #include "aes_wrap.h"
34 : #include "crypto.h"
35 :
36 : #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
37 : /* Compatibility wrappers for older versions. */
38 :
39 137696 : static HMAC_CTX * HMAC_CTX_new(void)
40 : {
41 : HMAC_CTX *ctx;
42 :
43 137696 : ctx = os_zalloc(sizeof(*ctx));
44 137696 : if (ctx)
45 137656 : HMAC_CTX_init(ctx);
46 137696 : return ctx;
47 : }
48 :
49 :
50 137656 : static void HMAC_CTX_free(HMAC_CTX *ctx)
51 : {
52 137656 : if (!ctx)
53 137656 : return;
54 137656 : HMAC_CTX_cleanup(ctx);
55 137656 : bin_clear_free(ctx, sizeof(*ctx));
56 : }
57 :
58 :
59 54161 : static EVP_MD_CTX * EVP_MD_CTX_new(void)
60 : {
61 : EVP_MD_CTX *ctx;
62 :
63 54161 : ctx = os_zalloc(sizeof(*ctx));
64 54161 : if (ctx)
65 54152 : EVP_MD_CTX_init(ctx);
66 54161 : return ctx;
67 : }
68 :
69 :
70 54152 : static void EVP_MD_CTX_free(EVP_MD_CTX *ctx)
71 : {
72 54152 : if (!ctx)
73 54152 : return;
74 54152 : EVP_MD_CTX_cleanup(ctx);
75 54152 : bin_clear_free(ctx, sizeof(*ctx));
76 : }
77 :
78 : #endif /* OpenSSL version < 1.1.0 */
79 :
80 1042 : static BIGNUM * get_group5_prime(void)
81 : {
82 : #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
83 : return BN_get_rfc3526_prime_1536(NULL);
84 : #elif !defined(OPENSSL_IS_BORINGSSL)
85 1042 : return get_rfc3526_prime_1536(NULL);
86 : #else
87 : static const unsigned char RFC3526_PRIME_1536[] = {
88 : 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC9,0x0F,0xDA,0xA2,
89 : 0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,0x80,0xDC,0x1C,0xD1,
90 : 0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,0x02,0x0B,0xBE,0xA6,
91 : 0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,0x8E,0x34,0x04,0xDD,
92 : 0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,0x30,0x2B,0x0A,0x6D,
93 : 0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,0x6D,0x51,0xC2,0x45,
94 : 0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,0xF4,0x4C,0x42,0xE9,
95 : 0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,0xF4,0x06,0xB7,0xED,
96 : 0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,0xAE,0x9F,0x24,0x11,
97 : 0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,0xEC,0xE4,0x5B,0x3D,
98 : 0xC2,0x00,0x7C,0xB8,0xA1,0x63,0xBF,0x05,0x98,0xDA,0x48,0x36,
99 : 0x1C,0x55,0xD3,0x9A,0x69,0x16,0x3F,0xA8,0xFD,0x24,0xCF,0x5F,
100 : 0x83,0x65,0x5D,0x23,0xDC,0xA3,0xAD,0x96,0x1C,0x62,0xF3,0x56,
101 : 0x20,0x85,0x52,0xBB,0x9E,0xD5,0x29,0x07,0x70,0x96,0x96,0x6D,
102 : 0x67,0x0C,0x35,0x4E,0x4A,0xBC,0x98,0x04,0xF1,0x74,0x6C,0x08,
103 : 0xCA,0x23,0x73,0x27,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
104 : };
105 : return BN_bin2bn(RFC3526_PRIME_1536, sizeof(RFC3526_PRIME_1536), NULL);
106 : #endif
107 : }
108 :
109 : #ifdef OPENSSL_NO_SHA256
110 : #define NO_SHA256_WRAPPER
111 : #endif
112 :
113 54189 : static int openssl_digest_vector(const EVP_MD *type, size_t num_elem,
114 : const u8 *addr[], const size_t *len, u8 *mac)
115 : {
116 : EVP_MD_CTX *ctx;
117 : size_t i;
118 : unsigned int mac_len;
119 :
120 54189 : if (TEST_FAIL())
121 28 : return -1;
122 :
123 54161 : ctx = EVP_MD_CTX_new();
124 54161 : if (!ctx)
125 9 : return -1;
126 54152 : if (!EVP_DigestInit_ex(ctx, type, NULL)) {
127 0 : wpa_printf(MSG_ERROR, "OpenSSL: EVP_DigestInit_ex failed: %s",
128 : ERR_error_string(ERR_get_error(), NULL));
129 0 : EVP_MD_CTX_free(ctx);
130 0 : return -1;
131 : }
132 184216 : for (i = 0; i < num_elem; i++) {
133 130064 : if (!EVP_DigestUpdate(ctx, addr[i], len[i])) {
134 0 : wpa_printf(MSG_ERROR, "OpenSSL: EVP_DigestUpdate "
135 : "failed: %s",
136 : ERR_error_string(ERR_get_error(), NULL));
137 0 : EVP_MD_CTX_free(ctx);
138 0 : return -1;
139 : }
140 : }
141 54152 : if (!EVP_DigestFinal(ctx, mac, &mac_len)) {
142 0 : wpa_printf(MSG_ERROR, "OpenSSL: EVP_DigestFinal failed: %s",
143 : ERR_error_string(ERR_get_error(), NULL));
144 0 : EVP_MD_CTX_free(ctx);
145 0 : return -1;
146 : }
147 54152 : EVP_MD_CTX_free(ctx);
148 :
149 54152 : return 0;
150 : }
151 :
152 :
153 : #ifndef CONFIG_FIPS
154 2308 : int md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
155 : {
156 2308 : return openssl_digest_vector(EVP_md4(), num_elem, addr, len, mac);
157 : }
158 : #endif /* CONFIG_FIPS */
159 :
160 :
161 1778 : void des_encrypt(const u8 *clear, const u8 *key, u8 *cypher)
162 : {
163 : u8 pkey[8], next, tmp;
164 : int i;
165 : DES_key_schedule ks;
166 :
167 : /* Add parity bits to the key */
168 1778 : next = 0;
169 14224 : for (i = 0; i < 7; i++) {
170 12446 : tmp = key[i];
171 12446 : pkey[i] = (tmp >> i) | next | 1;
172 12446 : next = tmp << (7 - i);
173 : }
174 1778 : pkey[i] = next | 1;
175 :
176 1778 : DES_set_key((DES_cblock *) &pkey, &ks);
177 1778 : DES_ecb_encrypt((DES_cblock *) clear, (DES_cblock *) cypher, &ks,
178 : DES_ENCRYPT);
179 1778 : }
180 :
181 :
182 : #ifndef CONFIG_NO_RC4
183 115 : int rc4_skip(const u8 *key, size_t keylen, size_t skip,
184 : u8 *data, size_t data_len)
185 : {
186 : #ifdef OPENSSL_NO_RC4
187 : return -1;
188 : #else /* OPENSSL_NO_RC4 */
189 : EVP_CIPHER_CTX *ctx;
190 : int outl;
191 115 : int res = -1;
192 : unsigned char skip_buf[16];
193 :
194 115 : ctx = EVP_CIPHER_CTX_new();
195 230 : if (!ctx ||
196 230 : !EVP_CIPHER_CTX_set_padding(ctx, 0) ||
197 230 : !EVP_CipherInit_ex(ctx, EVP_rc4(), NULL, NULL, NULL, 1) ||
198 230 : !EVP_CIPHER_CTX_set_key_length(ctx, keylen) ||
199 115 : !EVP_CipherInit_ex(ctx, NULL, NULL, key, NULL, 1))
200 : goto out;
201 :
202 1174 : while (skip >= sizeof(skip_buf)) {
203 944 : size_t len = skip;
204 944 : if (len > sizeof(skip_buf))
205 885 : len = sizeof(skip_buf);
206 944 : if (!EVP_CipherUpdate(ctx, skip_buf, &outl, skip_buf, len))
207 0 : goto out;
208 944 : skip -= len;
209 : }
210 :
211 115 : if (EVP_CipherUpdate(ctx, data, &outl, data, data_len))
212 115 : res = 0;
213 :
214 : out:
215 115 : if (ctx)
216 115 : EVP_CIPHER_CTX_free(ctx);
217 115 : return res;
218 : #endif /* OPENSSL_NO_RC4 */
219 : }
220 : #endif /* CONFIG_NO_RC4 */
221 :
222 :
223 : #ifndef CONFIG_FIPS
224 29273 : int md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
225 : {
226 29273 : return openssl_digest_vector(EVP_md5(), num_elem, addr, len, mac);
227 : }
228 : #endif /* CONFIG_FIPS */
229 :
230 :
231 18824 : int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
232 : {
233 18824 : return openssl_digest_vector(EVP_sha1(), num_elem, addr, len, mac);
234 : }
235 :
236 :
237 : #ifndef NO_SHA256_WRAPPER
238 3784 : int sha256_vector(size_t num_elem, const u8 *addr[], const size_t *len,
239 : u8 *mac)
240 : {
241 3784 : return openssl_digest_vector(EVP_sha256(), num_elem, addr, len, mac);
242 : }
243 : #endif /* NO_SHA256_WRAPPER */
244 :
245 :
246 20891 : static const EVP_CIPHER * aes_get_evp_cipher(size_t keylen)
247 : {
248 20891 : switch (keylen) {
249 : case 16:
250 20891 : return EVP_aes_128_ecb();
251 : #ifndef OPENSSL_IS_BORINGSSL
252 : case 24:
253 0 : return EVP_aes_192_ecb();
254 : #endif /* OPENSSL_IS_BORINGSSL */
255 : case 32:
256 0 : return EVP_aes_256_ecb();
257 : }
258 :
259 0 : return NULL;
260 : }
261 :
262 :
263 20926 : void * aes_encrypt_init(const u8 *key, size_t len)
264 : {
265 : EVP_CIPHER_CTX *ctx;
266 : const EVP_CIPHER *type;
267 :
268 20926 : if (TEST_FAIL())
269 35 : return NULL;
270 :
271 20891 : type = aes_get_evp_cipher(len);
272 20891 : if (type == NULL)
273 0 : return NULL;
274 :
275 20891 : ctx = EVP_CIPHER_CTX_new();
276 20891 : if (ctx == NULL)
277 0 : return NULL;
278 20891 : if (EVP_EncryptInit_ex(ctx, type, NULL, key, NULL) != 1) {
279 0 : os_free(ctx);
280 0 : return NULL;
281 : }
282 20891 : EVP_CIPHER_CTX_set_padding(ctx, 0);
283 20891 : return ctx;
284 : }
285 :
286 :
287 111846 : void aes_encrypt(void *ctx, const u8 *plain, u8 *crypt)
288 : {
289 111846 : EVP_CIPHER_CTX *c = ctx;
290 111846 : int clen = 16;
291 111846 : if (EVP_EncryptUpdate(c, crypt, &clen, plain, 16) != 1) {
292 0 : wpa_printf(MSG_ERROR, "OpenSSL: EVP_EncryptUpdate failed: %s",
293 : ERR_error_string(ERR_get_error(), NULL));
294 : }
295 111846 : }
296 :
297 :
298 20891 : void aes_encrypt_deinit(void *ctx)
299 : {
300 20891 : EVP_CIPHER_CTX *c = ctx;
301 : u8 buf[16];
302 20891 : int len = sizeof(buf);
303 20891 : if (EVP_EncryptFinal_ex(c, buf, &len) != 1) {
304 0 : wpa_printf(MSG_ERROR, "OpenSSL: EVP_EncryptFinal_ex failed: "
305 : "%s", ERR_error_string(ERR_get_error(), NULL));
306 : }
307 20891 : if (len != 0) {
308 0 : wpa_printf(MSG_ERROR, "OpenSSL: Unexpected padding length %d "
309 : "in AES encrypt", len);
310 : }
311 20891 : EVP_CIPHER_CTX_free(c);
312 20891 : }
313 :
314 :
315 0 : void * aes_decrypt_init(const u8 *key, size_t len)
316 : {
317 : EVP_CIPHER_CTX *ctx;
318 : const EVP_CIPHER *type;
319 :
320 0 : if (TEST_FAIL())
321 0 : return NULL;
322 :
323 0 : type = aes_get_evp_cipher(len);
324 0 : if (type == NULL)
325 0 : return NULL;
326 :
327 0 : ctx = EVP_CIPHER_CTX_new();
328 0 : if (ctx == NULL)
329 0 : return NULL;
330 0 : if (EVP_DecryptInit_ex(ctx, type, NULL, key, NULL) != 1) {
331 0 : EVP_CIPHER_CTX_free(ctx);
332 0 : return NULL;
333 : }
334 0 : EVP_CIPHER_CTX_set_padding(ctx, 0);
335 0 : return ctx;
336 : }
337 :
338 :
339 0 : void aes_decrypt(void *ctx, const u8 *crypt, u8 *plain)
340 : {
341 0 : EVP_CIPHER_CTX *c = ctx;
342 0 : int plen = 16;
343 0 : if (EVP_DecryptUpdate(c, plain, &plen, crypt, 16) != 1) {
344 0 : wpa_printf(MSG_ERROR, "OpenSSL: EVP_DecryptUpdate failed: %s",
345 : ERR_error_string(ERR_get_error(), NULL));
346 : }
347 0 : }
348 :
349 :
350 0 : void aes_decrypt_deinit(void *ctx)
351 : {
352 0 : EVP_CIPHER_CTX *c = ctx;
353 : u8 buf[16];
354 0 : int len = sizeof(buf);
355 0 : if (EVP_DecryptFinal_ex(c, buf, &len) != 1) {
356 0 : wpa_printf(MSG_ERROR, "OpenSSL: EVP_DecryptFinal_ex failed: "
357 : "%s", ERR_error_string(ERR_get_error(), NULL));
358 : }
359 0 : if (len != 0) {
360 0 : wpa_printf(MSG_ERROR, "OpenSSL: Unexpected padding length %d "
361 : "in AES decrypt", len);
362 : }
363 0 : EVP_CIPHER_CTX_free(c);
364 0 : }
365 :
366 :
367 : #ifndef CONFIG_FIPS
368 : #ifndef CONFIG_OPENSSL_INTERNAL_AES_WRAP
369 :
370 2518 : int aes_wrap(const u8 *kek, size_t kek_len, int n, const u8 *plain, u8 *cipher)
371 : {
372 : AES_KEY actx;
373 : int res;
374 :
375 2518 : if (AES_set_encrypt_key(kek, kek_len << 3, &actx))
376 0 : return -1;
377 2518 : res = AES_wrap_key(&actx, NULL, cipher, plain, n * 8);
378 2518 : OPENSSL_cleanse(&actx, sizeof(actx));
379 2518 : return res <= 0 ? -1 : 0;
380 : }
381 :
382 :
383 2472 : int aes_unwrap(const u8 *kek, size_t kek_len, int n, const u8 *cipher,
384 : u8 *plain)
385 : {
386 : AES_KEY actx;
387 : int res;
388 :
389 2472 : if (AES_set_decrypt_key(kek, kek_len << 3, &actx))
390 0 : return -1;
391 2472 : res = AES_unwrap_key(&actx, NULL, plain, cipher, (n + 1) * 8);
392 2472 : OPENSSL_cleanse(&actx, sizeof(actx));
393 2472 : return res <= 0 ? -1 : 0;
394 : }
395 :
396 : #endif /* CONFIG_OPENSSL_INTERNAL_AES_WRAP */
397 : #endif /* CONFIG_FIPS */
398 :
399 :
400 3839 : int aes_128_cbc_encrypt(const u8 *key, const u8 *iv, u8 *data, size_t data_len)
401 : {
402 : EVP_CIPHER_CTX *ctx;
403 : int clen, len;
404 : u8 buf[16];
405 3839 : int res = -1;
406 :
407 3839 : if (TEST_FAIL())
408 5 : return -1;
409 :
410 3834 : ctx = EVP_CIPHER_CTX_new();
411 3834 : if (!ctx)
412 0 : return -1;
413 3834 : clen = data_len;
414 3834 : len = sizeof(buf);
415 7668 : if (EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv) == 1 &&
416 7668 : EVP_CIPHER_CTX_set_padding(ctx, 0) == 1 &&
417 7668 : EVP_EncryptUpdate(ctx, data, &clen, data, data_len) == 1 &&
418 7668 : clen == (int) data_len &&
419 7668 : EVP_EncryptFinal_ex(ctx, buf, &len) == 1 && len == 0)
420 3834 : res = 0;
421 3834 : EVP_CIPHER_CTX_free(ctx);
422 :
423 3834 : return res;
424 : }
425 :
426 :
427 3729 : int aes_128_cbc_decrypt(const u8 *key, const u8 *iv, u8 *data, size_t data_len)
428 : {
429 : EVP_CIPHER_CTX *ctx;
430 : int plen, len;
431 : u8 buf[16];
432 3729 : int res = -1;
433 :
434 3729 : if (TEST_FAIL())
435 4 : return -1;
436 :
437 3725 : ctx = EVP_CIPHER_CTX_new();
438 3725 : if (!ctx)
439 0 : return -1;
440 3725 : plen = data_len;
441 3725 : len = sizeof(buf);
442 7450 : if (EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv) == 1 &&
443 7450 : EVP_CIPHER_CTX_set_padding(ctx, 0) == 1 &&
444 7450 : EVP_DecryptUpdate(ctx, data, &plen, data, data_len) == 1 &&
445 7450 : plen == (int) data_len &&
446 7450 : EVP_DecryptFinal_ex(ctx, buf, &len) == 1 && len == 0)
447 3725 : res = 0;
448 3725 : EVP_CIPHER_CTX_free(ctx);
449 :
450 3725 : return res;
451 :
452 : }
453 :
454 :
455 1698 : int crypto_mod_exp(const u8 *base, size_t base_len,
456 : const u8 *power, size_t power_len,
457 : const u8 *modulus, size_t modulus_len,
458 : u8 *result, size_t *result_len)
459 : {
460 : BIGNUM *bn_base, *bn_exp, *bn_modulus, *bn_result;
461 1698 : int ret = -1;
462 : BN_CTX *ctx;
463 :
464 1698 : ctx = BN_CTX_new();
465 1698 : if (ctx == NULL)
466 0 : return -1;
467 :
468 1698 : bn_base = BN_bin2bn(base, base_len, NULL);
469 1698 : bn_exp = BN_bin2bn(power, power_len, NULL);
470 1698 : bn_modulus = BN_bin2bn(modulus, modulus_len, NULL);
471 1698 : bn_result = BN_new();
472 :
473 1698 : if (bn_base == NULL || bn_exp == NULL || bn_modulus == NULL ||
474 : bn_result == NULL)
475 : goto error;
476 :
477 1698 : if (BN_mod_exp(bn_result, bn_base, bn_exp, bn_modulus, ctx) != 1)
478 0 : goto error;
479 :
480 1698 : *result_len = BN_bn2bin(bn_result, result);
481 1698 : ret = 0;
482 :
483 : error:
484 1698 : BN_clear_free(bn_base);
485 1698 : BN_clear_free(bn_exp);
486 1698 : BN_clear_free(bn_modulus);
487 1698 : BN_clear_free(bn_result);
488 1698 : BN_CTX_free(ctx);
489 1698 : return ret;
490 : }
491 :
492 :
493 : struct crypto_cipher {
494 : EVP_CIPHER_CTX *enc;
495 : EVP_CIPHER_CTX *dec;
496 : };
497 :
498 :
499 159 : struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg,
500 : const u8 *iv, const u8 *key,
501 : size_t key_len)
502 : {
503 : struct crypto_cipher *ctx;
504 : const EVP_CIPHER *cipher;
505 :
506 159 : ctx = os_zalloc(sizeof(*ctx));
507 159 : if (ctx == NULL)
508 5 : return NULL;
509 :
510 154 : switch (alg) {
511 : #ifndef CONFIG_NO_RC4
512 : #ifndef OPENSSL_NO_RC4
513 : case CRYPTO_CIPHER_ALG_RC4:
514 0 : cipher = EVP_rc4();
515 0 : break;
516 : #endif /* OPENSSL_NO_RC4 */
517 : #endif /* CONFIG_NO_RC4 */
518 : #ifndef OPENSSL_NO_AES
519 : case CRYPTO_CIPHER_ALG_AES:
520 150 : switch (key_len) {
521 : case 16:
522 150 : cipher = EVP_aes_128_cbc();
523 150 : break;
524 : #ifndef OPENSSL_IS_BORINGSSL
525 : case 24:
526 0 : cipher = EVP_aes_192_cbc();
527 0 : break;
528 : #endif /* OPENSSL_IS_BORINGSSL */
529 : case 32:
530 0 : cipher = EVP_aes_256_cbc();
531 0 : break;
532 : default:
533 0 : os_free(ctx);
534 0 : return NULL;
535 : }
536 150 : break;
537 : #endif /* OPENSSL_NO_AES */
538 : #ifndef OPENSSL_NO_DES
539 : case CRYPTO_CIPHER_ALG_3DES:
540 4 : cipher = EVP_des_ede3_cbc();
541 4 : break;
542 : case CRYPTO_CIPHER_ALG_DES:
543 0 : cipher = EVP_des_cbc();
544 0 : break;
545 : #endif /* OPENSSL_NO_DES */
546 : #ifndef OPENSSL_NO_RC2
547 : case CRYPTO_CIPHER_ALG_RC2:
548 0 : cipher = EVP_rc2_ecb();
549 0 : break;
550 : #endif /* OPENSSL_NO_RC2 */
551 : default:
552 0 : os_free(ctx);
553 0 : return NULL;
554 : }
555 :
556 308 : if (!(ctx->enc = EVP_CIPHER_CTX_new()) ||
557 308 : !EVP_CIPHER_CTX_set_padding(ctx->enc, 0) ||
558 308 : !EVP_EncryptInit_ex(ctx->enc, cipher, NULL, NULL, NULL) ||
559 308 : !EVP_CIPHER_CTX_set_key_length(ctx->enc, key_len) ||
560 154 : !EVP_EncryptInit_ex(ctx->enc, NULL, NULL, key, iv)) {
561 0 : if (ctx->enc)
562 0 : EVP_CIPHER_CTX_free(ctx->enc);
563 0 : os_free(ctx);
564 0 : return NULL;
565 : }
566 :
567 308 : if (!(ctx->dec = EVP_CIPHER_CTX_new()) ||
568 308 : !EVP_CIPHER_CTX_set_padding(ctx->dec, 0) ||
569 308 : !EVP_DecryptInit_ex(ctx->dec, cipher, NULL, NULL, NULL) ||
570 308 : !EVP_CIPHER_CTX_set_key_length(ctx->dec, key_len) ||
571 154 : !EVP_DecryptInit_ex(ctx->dec, NULL, NULL, key, iv)) {
572 0 : EVP_CIPHER_CTX_free(ctx->enc);
573 0 : if (ctx->dec)
574 0 : EVP_CIPHER_CTX_free(ctx->dec);
575 0 : os_free(ctx);
576 0 : return NULL;
577 : }
578 :
579 154 : return ctx;
580 : }
581 :
582 :
583 83 : int crypto_cipher_encrypt(struct crypto_cipher *ctx, const u8 *plain,
584 : u8 *crypt, size_t len)
585 : {
586 : int outl;
587 83 : if (!EVP_EncryptUpdate(ctx->enc, crypt, &outl, plain, len))
588 0 : return -1;
589 83 : return 0;
590 : }
591 :
592 :
593 71 : int crypto_cipher_decrypt(struct crypto_cipher *ctx, const u8 *crypt,
594 : u8 *plain, size_t len)
595 : {
596 : int outl;
597 71 : outl = len;
598 71 : if (!EVP_DecryptUpdate(ctx->dec, plain, &outl, crypt, len))
599 0 : return -1;
600 71 : return 0;
601 : }
602 :
603 :
604 154 : void crypto_cipher_deinit(struct crypto_cipher *ctx)
605 : {
606 154 : EVP_CIPHER_CTX_free(ctx->enc);
607 154 : EVP_CIPHER_CTX_free(ctx->dec);
608 154 : os_free(ctx);
609 154 : }
610 :
611 :
612 984 : void * dh5_init(struct wpabuf **priv, struct wpabuf **publ)
613 : {
614 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
615 : DH *dh;
616 984 : struct wpabuf *pubkey = NULL, *privkey = NULL;
617 : size_t publen, privlen;
618 :
619 984 : *priv = NULL;
620 984 : wpabuf_free(*publ);
621 984 : *publ = NULL;
622 :
623 984 : dh = DH_new();
624 984 : if (dh == NULL)
625 0 : return NULL;
626 :
627 984 : dh->g = BN_new();
628 984 : if (dh->g == NULL || BN_set_word(dh->g, 2) != 1)
629 : goto err;
630 :
631 984 : dh->p = get_group5_prime();
632 984 : if (dh->p == NULL)
633 0 : goto err;
634 :
635 984 : if (DH_generate_key(dh) != 1)
636 0 : goto err;
637 :
638 984 : publen = BN_num_bytes(dh->pub_key);
639 984 : pubkey = wpabuf_alloc(publen);
640 984 : if (pubkey == NULL)
641 3 : goto err;
642 981 : privlen = BN_num_bytes(dh->priv_key);
643 981 : privkey = wpabuf_alloc(privlen);
644 981 : if (privkey == NULL)
645 1 : goto err;
646 :
647 980 : BN_bn2bin(dh->pub_key, wpabuf_put(pubkey, publen));
648 980 : BN_bn2bin(dh->priv_key, wpabuf_put(privkey, privlen));
649 :
650 980 : *priv = privkey;
651 980 : *publ = pubkey;
652 980 : return dh;
653 :
654 : err:
655 4 : wpabuf_clear_free(pubkey);
656 4 : wpabuf_clear_free(privkey);
657 4 : DH_free(dh);
658 4 : return NULL;
659 : #else
660 : DH *dh;
661 : struct wpabuf *pubkey = NULL, *privkey = NULL;
662 : size_t publen, privlen;
663 : BIGNUM *p = NULL, *g;
664 : const BIGNUM *priv_key = NULL, *pub_key = NULL;
665 :
666 : *priv = NULL;
667 : wpabuf_free(*publ);
668 : *publ = NULL;
669 :
670 : dh = DH_new();
671 : if (dh == NULL)
672 : return NULL;
673 :
674 : g = BN_new();
675 : p = get_group5_prime();
676 : if (!g || BN_set_word(g, 2) != 1 || !p ||
677 : DH_set0_pqg(dh, p, NULL, g) != 1)
678 : goto err;
679 : p = NULL;
680 : g = NULL;
681 :
682 : if (DH_generate_key(dh) != 1)
683 : goto err;
684 :
685 : DH_get0_key(dh, &pub_key, &priv_key);
686 : publen = BN_num_bytes(pub_key);
687 : pubkey = wpabuf_alloc(publen);
688 : if (!pubkey)
689 : goto err;
690 : privlen = BN_num_bytes(priv_key);
691 : privkey = wpabuf_alloc(privlen);
692 : if (!privkey)
693 : goto err;
694 :
695 : BN_bn2bin(pub_key, wpabuf_put(pubkey, publen));
696 : BN_bn2bin(priv_key, wpabuf_put(privkey, privlen));
697 :
698 : *priv = privkey;
699 : *publ = pubkey;
700 : return dh;
701 :
702 : err:
703 : BN_free(p);
704 : BN_free(g);
705 : wpabuf_clear_free(pubkey);
706 : wpabuf_clear_free(privkey);
707 : DH_free(dh);
708 : return NULL;
709 : #endif
710 : }
711 :
712 :
713 58 : void * dh5_init_fixed(const struct wpabuf *priv, const struct wpabuf *publ)
714 : {
715 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
716 : DH *dh;
717 :
718 58 : dh = DH_new();
719 58 : if (dh == NULL)
720 0 : return NULL;
721 :
722 58 : dh->g = BN_new();
723 58 : if (dh->g == NULL || BN_set_word(dh->g, 2) != 1)
724 : goto err;
725 :
726 58 : dh->p = get_group5_prime();
727 58 : if (dh->p == NULL)
728 0 : goto err;
729 :
730 58 : dh->priv_key = BN_bin2bn(wpabuf_head(priv), wpabuf_len(priv), NULL);
731 58 : if (dh->priv_key == NULL)
732 0 : goto err;
733 :
734 58 : dh->pub_key = BN_bin2bn(wpabuf_head(publ), wpabuf_len(publ), NULL);
735 58 : if (dh->pub_key == NULL)
736 0 : goto err;
737 :
738 58 : if (DH_generate_key(dh) != 1)
739 0 : goto err;
740 :
741 58 : return dh;
742 :
743 : err:
744 0 : DH_free(dh);
745 0 : return NULL;
746 : #else
747 : DH *dh;
748 : BIGNUM *p = NULL, *g, *priv_key = NULL, *pub_key = NULL;
749 :
750 : dh = DH_new();
751 : if (dh == NULL)
752 : return NULL;
753 :
754 : g = BN_new();
755 : p = get_group5_prime();
756 : if (!g || BN_set_word(g, 2) != 1 || !p ||
757 : DH_set0_pqg(dh, p, NULL, g) != 1)
758 : goto err;
759 : p = NULL;
760 : g = NULL;
761 :
762 : priv_key = BN_bin2bn(wpabuf_head(priv), wpabuf_len(priv), NULL);
763 : pub_key = BN_bin2bn(wpabuf_head(publ), wpabuf_len(publ), NULL);
764 : if (!priv_key || !pub_key || DH_set0_key(dh, pub_key, priv_key) != 1)
765 : goto err;
766 : pub_key = NULL;
767 : priv_key = NULL;
768 :
769 : if (DH_generate_key(dh) != 1)
770 : goto err;
771 :
772 : return dh;
773 :
774 : err:
775 : BN_free(p);
776 : BN_free(g);
777 : BN_free(pub_key);
778 : BN_clear_free(priv_key);
779 : DH_free(dh);
780 : return NULL;
781 : #endif
782 : }
783 :
784 :
785 907 : struct wpabuf * dh5_derive_shared(void *ctx, const struct wpabuf *peer_public,
786 : const struct wpabuf *own_private)
787 : {
788 : BIGNUM *pub_key;
789 907 : struct wpabuf *res = NULL;
790 : size_t rlen;
791 907 : DH *dh = ctx;
792 : int keylen;
793 :
794 907 : if (ctx == NULL)
795 0 : return NULL;
796 :
797 907 : pub_key = BN_bin2bn(wpabuf_head(peer_public), wpabuf_len(peer_public),
798 : NULL);
799 907 : if (pub_key == NULL)
800 0 : return NULL;
801 :
802 907 : rlen = DH_size(dh);
803 907 : res = wpabuf_alloc(rlen);
804 907 : if (res == NULL)
805 0 : goto err;
806 :
807 907 : keylen = DH_compute_key(wpabuf_mhead(res), pub_key, dh);
808 907 : if (keylen < 0)
809 1 : goto err;
810 906 : wpabuf_put(res, keylen);
811 906 : BN_clear_free(pub_key);
812 :
813 906 : return res;
814 :
815 : err:
816 1 : BN_clear_free(pub_key);
817 1 : wpabuf_clear_free(res);
818 1 : return NULL;
819 : }
820 :
821 :
822 3074 : void dh5_free(void *ctx)
823 : {
824 : DH *dh;
825 3074 : if (ctx == NULL)
826 5110 : return;
827 1038 : dh = ctx;
828 1038 : DH_free(dh);
829 : }
830 :
831 :
832 : struct crypto_hash {
833 : HMAC_CTX *ctx;
834 : };
835 :
836 :
837 734 : struct crypto_hash * crypto_hash_init(enum crypto_hash_alg alg, const u8 *key,
838 : size_t key_len)
839 : {
840 : struct crypto_hash *ctx;
841 : const EVP_MD *md;
842 :
843 734 : switch (alg) {
844 : #ifndef OPENSSL_NO_MD5
845 : case CRYPTO_HASH_ALG_HMAC_MD5:
846 0 : md = EVP_md5();
847 0 : break;
848 : #endif /* OPENSSL_NO_MD5 */
849 : #ifndef OPENSSL_NO_SHA
850 : case CRYPTO_HASH_ALG_HMAC_SHA1:
851 0 : md = EVP_sha1();
852 0 : break;
853 : #endif /* OPENSSL_NO_SHA */
854 : #ifndef OPENSSL_NO_SHA256
855 : #ifdef CONFIG_SHA256
856 : case CRYPTO_HASH_ALG_HMAC_SHA256:
857 734 : md = EVP_sha256();
858 734 : break;
859 : #endif /* CONFIG_SHA256 */
860 : #endif /* OPENSSL_NO_SHA256 */
861 : default:
862 0 : return NULL;
863 : }
864 :
865 734 : ctx = os_zalloc(sizeof(*ctx));
866 734 : if (ctx == NULL)
867 7 : return NULL;
868 727 : ctx->ctx = HMAC_CTX_new();
869 727 : if (!ctx->ctx) {
870 5 : os_free(ctx);
871 5 : return NULL;
872 : }
873 :
874 722 : if (HMAC_Init_ex(ctx->ctx, key, key_len, md, NULL) != 1) {
875 0 : HMAC_CTX_free(ctx->ctx);
876 0 : bin_clear_free(ctx, sizeof(*ctx));
877 0 : return NULL;
878 : }
879 :
880 722 : return ctx;
881 : }
882 :
883 :
884 3206 : void crypto_hash_update(struct crypto_hash *ctx, const u8 *data, size_t len)
885 : {
886 3206 : if (ctx == NULL)
887 3206 : return;
888 3206 : HMAC_Update(ctx->ctx, data, len);
889 : }
890 :
891 :
892 722 : int crypto_hash_finish(struct crypto_hash *ctx, u8 *mac, size_t *len)
893 : {
894 : unsigned int mdlen;
895 : int res;
896 :
897 722 : if (ctx == NULL)
898 0 : return -2;
899 :
900 722 : if (mac == NULL || len == NULL) {
901 0 : HMAC_CTX_free(ctx->ctx);
902 0 : bin_clear_free(ctx, sizeof(*ctx));
903 0 : return 0;
904 : }
905 :
906 722 : mdlen = *len;
907 722 : res = HMAC_Final(ctx->ctx, mac, &mdlen);
908 722 : HMAC_CTX_free(ctx->ctx);
909 722 : bin_clear_free(ctx, sizeof(*ctx));
910 :
911 722 : if (res == 1) {
912 722 : *len = mdlen;
913 722 : return 0;
914 : }
915 :
916 0 : return -1;
917 : }
918 :
919 :
920 137023 : static int openssl_hmac_vector(const EVP_MD *type, const u8 *key,
921 : size_t key_len, size_t num_elem,
922 : const u8 *addr[], const size_t *len, u8 *mac,
923 : unsigned int mdlen)
924 : {
925 : HMAC_CTX *ctx;
926 : size_t i;
927 : int res;
928 :
929 137023 : if (TEST_FAIL())
930 54 : return -1;
931 :
932 136969 : ctx = HMAC_CTX_new();
933 136969 : if (!ctx)
934 35 : return -1;
935 136934 : res = HMAC_Init_ex(ctx, key, key_len, type, NULL);
936 136934 : if (res != 1)
937 0 : goto done;
938 :
939 445108 : for (i = 0; i < num_elem; i++)
940 308174 : HMAC_Update(ctx, addr[i], len[i]);
941 :
942 136934 : res = HMAC_Final(ctx, mac, &mdlen);
943 : done:
944 136934 : HMAC_CTX_free(ctx);
945 :
946 136934 : return res == 1 ? 0 : -1;
947 : }
948 :
949 :
950 : #ifndef CONFIG_FIPS
951 :
952 32943 : int hmac_md5_vector(const u8 *key, size_t key_len, size_t num_elem,
953 : const u8 *addr[], const size_t *len, u8 *mac)
954 : {
955 32943 : return openssl_hmac_vector(EVP_md5(), key ,key_len, num_elem, addr, len,
956 : mac, 16);
957 : }
958 :
959 :
960 30155 : int hmac_md5(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
961 : u8 *mac)
962 : {
963 30155 : return hmac_md5_vector(key, key_len, 1, &data, &data_len, mac);
964 : }
965 :
966 : #endif /* CONFIG_FIPS */
967 :
968 :
969 1554 : int pbkdf2_sha1(const char *passphrase, const u8 *ssid, size_t ssid_len,
970 : int iterations, u8 *buf, size_t buflen)
971 : {
972 1554 : if (PKCS5_PBKDF2_HMAC_SHA1(passphrase, os_strlen(passphrase), ssid,
973 : ssid_len, iterations, buflen, buf) != 1)
974 0 : return -1;
975 1554 : return 0;
976 : }
977 :
978 :
979 55604 : int hmac_sha1_vector(const u8 *key, size_t key_len, size_t num_elem,
980 : const u8 *addr[], const size_t *len, u8 *mac)
981 : {
982 55604 : return openssl_hmac_vector(EVP_sha1(), key, key_len, num_elem, addr,
983 : len, mac, 20);
984 : }
985 :
986 :
987 16959 : int hmac_sha1(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
988 : u8 *mac)
989 : {
990 16959 : return hmac_sha1_vector(key, key_len, 1, &data, &data_len, mac);
991 : }
992 :
993 :
994 : #ifdef CONFIG_SHA256
995 :
996 48426 : int hmac_sha256_vector(const u8 *key, size_t key_len, size_t num_elem,
997 : const u8 *addr[], const size_t *len, u8 *mac)
998 : {
999 48426 : return openssl_hmac_vector(EVP_sha256(), key, key_len, num_elem, addr,
1000 : len, mac, 32);
1001 : }
1002 :
1003 :
1004 5964 : int hmac_sha256(const u8 *key, size_t key_len, const u8 *data,
1005 : size_t data_len, u8 *mac)
1006 : {
1007 5964 : return hmac_sha256_vector(key, key_len, 1, &data, &data_len, mac);
1008 : }
1009 :
1010 : #endif /* CONFIG_SHA256 */
1011 :
1012 :
1013 : #ifdef CONFIG_SHA384
1014 :
1015 50 : int hmac_sha384_vector(const u8 *key, size_t key_len, size_t num_elem,
1016 : const u8 *addr[], const size_t *len, u8 *mac)
1017 : {
1018 50 : return openssl_hmac_vector(EVP_sha384(), key, key_len, num_elem, addr,
1019 : len, mac, 32);
1020 : }
1021 :
1022 :
1023 25 : int hmac_sha384(const u8 *key, size_t key_len, const u8 *data,
1024 : size_t data_len, u8 *mac)
1025 : {
1026 25 : return hmac_sha384_vector(key, key_len, 1, &data, &data_len, mac);
1027 : }
1028 :
1029 : #endif /* CONFIG_SHA384 */
1030 :
1031 :
1032 0 : int crypto_get_random(void *buf, size_t len)
1033 : {
1034 0 : if (RAND_bytes(buf, len) != 1)
1035 0 : return -1;
1036 0 : return 0;
1037 : }
1038 :
1039 :
1040 : #ifdef CONFIG_OPENSSL_CMAC
1041 : int omac1_aes_vector(const u8 *key, size_t key_len, size_t num_elem,
1042 : const u8 *addr[], const size_t *len, u8 *mac)
1043 : {
1044 : CMAC_CTX *ctx;
1045 : int ret = -1;
1046 : size_t outlen, i;
1047 :
1048 : if (TEST_FAIL())
1049 : return -1;
1050 :
1051 : ctx = CMAC_CTX_new();
1052 : if (ctx == NULL)
1053 : return -1;
1054 :
1055 : if (key_len == 32) {
1056 : if (!CMAC_Init(ctx, key, 32, EVP_aes_256_cbc(), NULL))
1057 : goto fail;
1058 : } else if (key_len == 16) {
1059 : if (!CMAC_Init(ctx, key, 16, EVP_aes_128_cbc(), NULL))
1060 : goto fail;
1061 : } else {
1062 : goto fail;
1063 : }
1064 : for (i = 0; i < num_elem; i++) {
1065 : if (!CMAC_Update(ctx, addr[i], len[i]))
1066 : goto fail;
1067 : }
1068 : if (!CMAC_Final(ctx, mac, &outlen) || outlen != 16)
1069 : goto fail;
1070 :
1071 : ret = 0;
1072 : fail:
1073 : CMAC_CTX_free(ctx);
1074 : return ret;
1075 : }
1076 :
1077 :
1078 : int omac1_aes_128_vector(const u8 *key, size_t num_elem,
1079 : const u8 *addr[], const size_t *len, u8 *mac)
1080 : {
1081 : return omac1_aes_vector(key, 16, num_elem, addr, len, mac);
1082 : }
1083 :
1084 :
1085 : int omac1_aes_128(const u8 *key, const u8 *data, size_t data_len, u8 *mac)
1086 : {
1087 : return omac1_aes_128_vector(key, 1, &data, &data_len, mac);
1088 : }
1089 :
1090 :
1091 : int omac1_aes_256(const u8 *key, const u8 *data, size_t data_len, u8 *mac)
1092 : {
1093 : return omac1_aes_vector(key, 32, 1, &data, &data_len, mac);
1094 : }
1095 : #endif /* CONFIG_OPENSSL_CMAC */
1096 :
1097 :
1098 10794 : struct crypto_bignum * crypto_bignum_init(void)
1099 : {
1100 10794 : if (TEST_FAIL())
1101 5 : return NULL;
1102 10789 : return (struct crypto_bignum *) BN_new();
1103 : }
1104 :
1105 :
1106 22173 : struct crypto_bignum * crypto_bignum_init_set(const u8 *buf, size_t len)
1107 : {
1108 : BIGNUM *bn;
1109 :
1110 22173 : if (TEST_FAIL())
1111 13 : return NULL;
1112 :
1113 22160 : bn = BN_bin2bn(buf, len, NULL);
1114 22160 : return (struct crypto_bignum *) bn;
1115 : }
1116 :
1117 :
1118 56226 : void crypto_bignum_deinit(struct crypto_bignum *n, int clear)
1119 : {
1120 56226 : if (clear)
1121 41320 : BN_clear_free((BIGNUM *) n);
1122 : else
1123 14906 : BN_free((BIGNUM *) n);
1124 56226 : }
1125 :
1126 :
1127 5562 : int crypto_bignum_to_bin(const struct crypto_bignum *a,
1128 : u8 *buf, size_t buflen, size_t padlen)
1129 : {
1130 : int num_bytes, offset;
1131 :
1132 5562 : if (TEST_FAIL())
1133 3 : return -1;
1134 :
1135 5559 : if (padlen > buflen)
1136 0 : return -1;
1137 :
1138 5559 : num_bytes = BN_num_bytes((const BIGNUM *) a);
1139 5559 : if ((size_t) num_bytes > buflen)
1140 0 : return -1;
1141 5559 : if (padlen > (size_t) num_bytes)
1142 212 : offset = padlen - num_bytes;
1143 : else
1144 5347 : offset = 0;
1145 :
1146 5559 : os_memset(buf, 0, offset);
1147 5559 : BN_bn2bin((const BIGNUM *) a, buf + offset);
1148 :
1149 5559 : return num_bytes + offset;
1150 : }
1151 :
1152 :
1153 576 : int crypto_bignum_add(const struct crypto_bignum *a,
1154 : const struct crypto_bignum *b,
1155 : struct crypto_bignum *c)
1156 : {
1157 1152 : return BN_add((BIGNUM *) c, (const BIGNUM *) a, (const BIGNUM *) b) ?
1158 576 : 0 : -1;
1159 : }
1160 :
1161 :
1162 576 : int crypto_bignum_mod(const struct crypto_bignum *a,
1163 : const struct crypto_bignum *b,
1164 : struct crypto_bignum *c)
1165 : {
1166 : int res;
1167 : BN_CTX *bnctx;
1168 :
1169 576 : bnctx = BN_CTX_new();
1170 576 : if (bnctx == NULL)
1171 0 : return -1;
1172 576 : res = BN_mod((BIGNUM *) c, (const BIGNUM *) a, (const BIGNUM *) b,
1173 : bnctx);
1174 576 : BN_CTX_free(bnctx);
1175 :
1176 576 : return res ? 0 : -1;
1177 : }
1178 :
1179 :
1180 319 : int crypto_bignum_exptmod(const struct crypto_bignum *a,
1181 : const struct crypto_bignum *b,
1182 : const struct crypto_bignum *c,
1183 : struct crypto_bignum *d)
1184 : {
1185 : int res;
1186 : BN_CTX *bnctx;
1187 :
1188 319 : if (TEST_FAIL())
1189 5 : return -1;
1190 :
1191 314 : bnctx = BN_CTX_new();
1192 314 : if (bnctx == NULL)
1193 0 : return -1;
1194 314 : res = BN_mod_exp((BIGNUM *) d, (const BIGNUM *) a, (const BIGNUM *) b,
1195 : (const BIGNUM *) c, bnctx);
1196 314 : BN_CTX_free(bnctx);
1197 :
1198 314 : return res ? 0 : -1;
1199 : }
1200 :
1201 :
1202 69 : int crypto_bignum_inverse(const struct crypto_bignum *a,
1203 : const struct crypto_bignum *b,
1204 : struct crypto_bignum *c)
1205 : {
1206 : BIGNUM *res;
1207 : BN_CTX *bnctx;
1208 :
1209 69 : if (TEST_FAIL())
1210 1 : return -1;
1211 68 : bnctx = BN_CTX_new();
1212 68 : if (bnctx == NULL)
1213 0 : return -1;
1214 68 : res = BN_mod_inverse((BIGNUM *) c, (const BIGNUM *) a,
1215 : (const BIGNUM *) b, bnctx);
1216 68 : BN_CTX_free(bnctx);
1217 :
1218 68 : return res ? 0 : -1;
1219 : }
1220 :
1221 :
1222 94 : int crypto_bignum_sub(const struct crypto_bignum *a,
1223 : const struct crypto_bignum *b,
1224 : struct crypto_bignum *c)
1225 : {
1226 94 : if (TEST_FAIL())
1227 1 : return -1;
1228 186 : return BN_sub((BIGNUM *) c, (const BIGNUM *) a, (const BIGNUM *) b) ?
1229 93 : 0 : -1;
1230 : }
1231 :
1232 :
1233 28 : int crypto_bignum_div(const struct crypto_bignum *a,
1234 : const struct crypto_bignum *b,
1235 : struct crypto_bignum *c)
1236 : {
1237 : int res;
1238 :
1239 : BN_CTX *bnctx;
1240 :
1241 28 : if (TEST_FAIL())
1242 1 : return -1;
1243 :
1244 27 : bnctx = BN_CTX_new();
1245 27 : if (bnctx == NULL)
1246 0 : return -1;
1247 27 : res = BN_div((BIGNUM *) c, NULL, (const BIGNUM *) a,
1248 : (const BIGNUM *) b, bnctx);
1249 27 : BN_CTX_free(bnctx);
1250 :
1251 27 : return res ? 0 : -1;
1252 : }
1253 :
1254 :
1255 30018 : int crypto_bignum_mulmod(const struct crypto_bignum *a,
1256 : const struct crypto_bignum *b,
1257 : const struct crypto_bignum *c,
1258 : struct crypto_bignum *d)
1259 : {
1260 : int res;
1261 :
1262 : BN_CTX *bnctx;
1263 :
1264 30018 : if (TEST_FAIL())
1265 4 : return -1;
1266 :
1267 30014 : bnctx = BN_CTX_new();
1268 30014 : if (bnctx == NULL)
1269 0 : return -1;
1270 30014 : res = BN_mod_mul((BIGNUM *) d, (const BIGNUM *) a, (const BIGNUM *) b,
1271 : (const BIGNUM *) c, bnctx);
1272 30014 : BN_CTX_free(bnctx);
1273 :
1274 30014 : return res ? 0 : -1;
1275 : }
1276 :
1277 :
1278 1211 : int crypto_bignum_cmp(const struct crypto_bignum *a,
1279 : const struct crypto_bignum *b)
1280 : {
1281 1211 : return BN_cmp((const BIGNUM *) a, (const BIGNUM *) b);
1282 : }
1283 :
1284 :
1285 642 : int crypto_bignum_bits(const struct crypto_bignum *a)
1286 : {
1287 642 : return BN_num_bits((const BIGNUM *) a);
1288 : }
1289 :
1290 :
1291 11395 : int crypto_bignum_is_zero(const struct crypto_bignum *a)
1292 : {
1293 11395 : return BN_is_zero((const BIGNUM *) a);
1294 : }
1295 :
1296 :
1297 1521 : int crypto_bignum_is_one(const struct crypto_bignum *a)
1298 : {
1299 1521 : return BN_is_one((const BIGNUM *) a);
1300 : }
1301 :
1302 :
1303 10782 : int crypto_bignum_legendre(const struct crypto_bignum *a,
1304 : const struct crypto_bignum *p)
1305 : {
1306 : BN_CTX *bnctx;
1307 10782 : BIGNUM *exp = NULL, *tmp = NULL;
1308 10782 : int res = -2;
1309 :
1310 10782 : if (TEST_FAIL())
1311 2 : return -2;
1312 :
1313 10780 : bnctx = BN_CTX_new();
1314 10780 : if (bnctx == NULL)
1315 0 : return -2;
1316 :
1317 10780 : exp = BN_new();
1318 10780 : tmp = BN_new();
1319 21560 : if (!exp || !tmp ||
1320 : /* exp = (p-1) / 2 */
1321 21560 : !BN_sub(exp, (const BIGNUM *) p, BN_value_one()) ||
1322 21560 : !BN_rshift1(exp, exp) ||
1323 10780 : !BN_mod_exp(tmp, (const BIGNUM *) a, exp, (const BIGNUM *) p,
1324 : bnctx))
1325 : goto fail;
1326 :
1327 10780 : if (BN_is_word(tmp, 1))
1328 5340 : res = 1;
1329 5440 : else if (BN_is_zero(tmp))
1330 0 : res = 0;
1331 : else
1332 5440 : res = -1;
1333 :
1334 : fail:
1335 10780 : BN_clear_free(tmp);
1336 10780 : BN_clear_free(exp);
1337 10780 : BN_CTX_free(bnctx);
1338 10780 : return res;
1339 : }
1340 :
1341 :
1342 : #ifdef CONFIG_ECC
1343 :
1344 : struct crypto_ec {
1345 : EC_GROUP *group;
1346 : BN_CTX *bnctx;
1347 : BIGNUM *prime;
1348 : BIGNUM *order;
1349 : BIGNUM *a;
1350 : BIGNUM *b;
1351 : };
1352 :
1353 330 : struct crypto_ec * crypto_ec_init(int group)
1354 : {
1355 : struct crypto_ec *e;
1356 : int nid;
1357 :
1358 : /* Map from IANA registry for IKE D-H groups to OpenSSL NID */
1359 330 : switch (group) {
1360 : case 19:
1361 213 : nid = NID_X9_62_prime256v1;
1362 213 : break;
1363 : case 20:
1364 10 : nid = NID_secp384r1;
1365 10 : break;
1366 : case 21:
1367 3 : nid = NID_secp521r1;
1368 3 : break;
1369 : case 25:
1370 11 : nid = NID_X9_62_prime192v1;
1371 11 : break;
1372 : case 26:
1373 6 : nid = NID_secp224r1;
1374 6 : break;
1375 : #ifdef NID_brainpoolP224r1
1376 : case 27:
1377 2 : nid = NID_brainpoolP224r1;
1378 2 : break;
1379 : #endif /* NID_brainpoolP224r1 */
1380 : #ifdef NID_brainpoolP256r1
1381 : case 28:
1382 2 : nid = NID_brainpoolP256r1;
1383 2 : break;
1384 : #endif /* NID_brainpoolP256r1 */
1385 : #ifdef NID_brainpoolP384r1
1386 : case 29:
1387 2 : nid = NID_brainpoolP384r1;
1388 2 : break;
1389 : #endif /* NID_brainpoolP384r1 */
1390 : #ifdef NID_brainpoolP512r1
1391 : case 30:
1392 2 : nid = NID_brainpoolP512r1;
1393 2 : break;
1394 : #endif /* NID_brainpoolP512r1 */
1395 : default:
1396 79 : return NULL;
1397 : }
1398 :
1399 251 : e = os_zalloc(sizeof(*e));
1400 251 : if (e == NULL)
1401 1 : return NULL;
1402 :
1403 250 : e->bnctx = BN_CTX_new();
1404 250 : e->group = EC_GROUP_new_by_curve_name(nid);
1405 250 : e->prime = BN_new();
1406 250 : e->order = BN_new();
1407 250 : e->a = BN_new();
1408 250 : e->b = BN_new();
1409 500 : if (e->group == NULL || e->bnctx == NULL || e->prime == NULL ||
1410 750 : e->order == NULL || e->a == NULL || e->b == NULL ||
1411 500 : !EC_GROUP_get_curve_GFp(e->group, e->prime, e->a, e->b, e->bnctx) ||
1412 250 : !EC_GROUP_get_order(e->group, e->order, e->bnctx)) {
1413 0 : crypto_ec_deinit(e);
1414 0 : e = NULL;
1415 : }
1416 :
1417 250 : return e;
1418 : }
1419 :
1420 :
1421 330 : void crypto_ec_deinit(struct crypto_ec *e)
1422 : {
1423 330 : if (e == NULL)
1424 410 : return;
1425 250 : BN_clear_free(e->b);
1426 250 : BN_clear_free(e->a);
1427 250 : BN_clear_free(e->order);
1428 250 : BN_clear_free(e->prime);
1429 250 : EC_GROUP_free(e->group);
1430 250 : BN_CTX_free(e->bnctx);
1431 250 : os_free(e);
1432 : }
1433 :
1434 :
1435 659 : struct crypto_ec_point * crypto_ec_point_init(struct crypto_ec *e)
1436 : {
1437 659 : if (TEST_FAIL())
1438 3 : return NULL;
1439 656 : if (e == NULL)
1440 0 : return NULL;
1441 656 : return (struct crypto_ec_point *) EC_POINT_new(e->group);
1442 : }
1443 :
1444 :
1445 250 : size_t crypto_ec_prime_len(struct crypto_ec *e)
1446 : {
1447 250 : return BN_num_bytes(e->prime);
1448 : }
1449 :
1450 :
1451 10355 : size_t crypto_ec_prime_len_bits(struct crypto_ec *e)
1452 : {
1453 10355 : return BN_num_bits(e->prime);
1454 : }
1455 :
1456 :
1457 250 : const struct crypto_bignum * crypto_ec_get_prime(struct crypto_ec *e)
1458 : {
1459 250 : return (const struct crypto_bignum *) e->prime;
1460 : }
1461 :
1462 :
1463 250 : const struct crypto_bignum * crypto_ec_get_order(struct crypto_ec *e)
1464 : {
1465 250 : return (const struct crypto_bignum *) e->order;
1466 : }
1467 :
1468 :
1469 1419 : void crypto_ec_point_deinit(struct crypto_ec_point *p, int clear)
1470 : {
1471 1419 : if (clear)
1472 539 : EC_POINT_clear_free((EC_POINT *) p);
1473 : else
1474 880 : EC_POINT_free((EC_POINT *) p);
1475 1419 : }
1476 :
1477 :
1478 1552 : int crypto_ec_point_to_bin(struct crypto_ec *e,
1479 : const struct crypto_ec_point *point, u8 *x, u8 *y)
1480 : {
1481 : BIGNUM *x_bn, *y_bn;
1482 1552 : int ret = -1;
1483 1552 : int len = BN_num_bytes(e->prime);
1484 :
1485 1552 : if (TEST_FAIL())
1486 1 : return -1;
1487 :
1488 1551 : x_bn = BN_new();
1489 1551 : y_bn = BN_new();
1490 :
1491 3102 : if (x_bn && y_bn &&
1492 1551 : EC_POINT_get_affine_coordinates_GFp(e->group, (EC_POINT *) point,
1493 : x_bn, y_bn, e->bnctx)) {
1494 1551 : if (x) {
1495 1551 : crypto_bignum_to_bin((struct crypto_bignum *) x_bn,
1496 : x, len, len);
1497 : }
1498 1551 : if (y) {
1499 1347 : crypto_bignum_to_bin((struct crypto_bignum *) y_bn,
1500 : y, len, len);
1501 : }
1502 1551 : ret = 0;
1503 : }
1504 :
1505 1551 : BN_clear_free(x_bn);
1506 1551 : BN_clear_free(y_bn);
1507 1551 : return ret;
1508 : }
1509 :
1510 :
1511 220 : struct crypto_ec_point * crypto_ec_point_from_bin(struct crypto_ec *e,
1512 : const u8 *val)
1513 : {
1514 : BIGNUM *x, *y;
1515 : EC_POINT *elem;
1516 220 : int len = BN_num_bytes(e->prime);
1517 :
1518 220 : if (TEST_FAIL())
1519 1 : return NULL;
1520 :
1521 219 : x = BN_bin2bn(val, len, NULL);
1522 219 : y = BN_bin2bn(val + len, len, NULL);
1523 219 : elem = EC_POINT_new(e->group);
1524 219 : if (x == NULL || y == NULL || elem == NULL) {
1525 0 : BN_clear_free(x);
1526 0 : BN_clear_free(y);
1527 0 : EC_POINT_clear_free(elem);
1528 0 : return NULL;
1529 : }
1530 :
1531 219 : if (!EC_POINT_set_affine_coordinates_GFp(e->group, elem, x, y,
1532 : e->bnctx)) {
1533 0 : EC_POINT_clear_free(elem);
1534 0 : elem = NULL;
1535 : }
1536 :
1537 219 : BN_clear_free(x);
1538 219 : BN_clear_free(y);
1539 :
1540 219 : return (struct crypto_ec_point *) elem;
1541 : }
1542 :
1543 :
1544 207 : int crypto_ec_point_add(struct crypto_ec *e, const struct crypto_ec_point *a,
1545 : const struct crypto_ec_point *b,
1546 : struct crypto_ec_point *c)
1547 : {
1548 207 : if (TEST_FAIL())
1549 1 : return -1;
1550 412 : return EC_POINT_add(e->group, (EC_POINT *) c, (const EC_POINT *) a,
1551 206 : (const EC_POINT *) b, e->bnctx) ? 0 : -1;
1552 : }
1553 :
1554 :
1555 661 : int crypto_ec_point_mul(struct crypto_ec *e, const struct crypto_ec_point *p,
1556 : const struct crypto_bignum *b,
1557 : struct crypto_ec_point *res)
1558 : {
1559 661 : if (TEST_FAIL())
1560 3 : return -1;
1561 1316 : return EC_POINT_mul(e->group, (EC_POINT *) res, NULL,
1562 : (const EC_POINT *) p, (const BIGNUM *) b, e->bnctx)
1563 658 : ? 0 : -1;
1564 : }
1565 :
1566 :
1567 246 : int crypto_ec_point_invert(struct crypto_ec *e, struct crypto_ec_point *p)
1568 : {
1569 246 : if (TEST_FAIL())
1570 1 : return -1;
1571 245 : return EC_POINT_invert(e->group, (EC_POINT *) p, e->bnctx) ? 0 : -1;
1572 : }
1573 :
1574 :
1575 251 : int crypto_ec_point_solve_y_coord(struct crypto_ec *e,
1576 : struct crypto_ec_point *p,
1577 : const struct crypto_bignum *x, int y_bit)
1578 : {
1579 251 : if (TEST_FAIL())
1580 1 : return -1;
1581 250 : if (!EC_POINT_set_compressed_coordinates_GFp(e->group, (EC_POINT *) p,
1582 : (const BIGNUM *) x, y_bit,
1583 250 : e->bnctx) ||
1584 250 : !EC_POINT_is_on_curve(e->group, (EC_POINT *) p, e->bnctx))
1585 0 : return -1;
1586 250 : return 0;
1587 : }
1588 :
1589 :
1590 : struct crypto_bignum *
1591 9992 : crypto_ec_point_compute_y_sqr(struct crypto_ec *e,
1592 : const struct crypto_bignum *x)
1593 : {
1594 9992 : BIGNUM *tmp, *tmp2, *y_sqr = NULL;
1595 :
1596 9992 : if (TEST_FAIL())
1597 1 : return NULL;
1598 :
1599 9991 : tmp = BN_new();
1600 9991 : tmp2 = BN_new();
1601 :
1602 : /* y^2 = x^3 + ax + b */
1603 19982 : if (tmp && tmp2 &&
1604 19982 : BN_mod_sqr(tmp, (const BIGNUM *) x, e->prime, e->bnctx) &&
1605 19982 : BN_mod_mul(tmp, tmp, (const BIGNUM *) x, e->prime, e->bnctx) &&
1606 19982 : BN_mod_mul(tmp2, e->a, (const BIGNUM *) x, e->prime, e->bnctx) &&
1607 19982 : BN_mod_add_quick(tmp2, tmp2, tmp, e->prime) &&
1608 9991 : BN_mod_add_quick(tmp2, tmp2, e->b, e->prime)) {
1609 9991 : y_sqr = tmp2;
1610 9991 : tmp2 = NULL;
1611 : }
1612 :
1613 9991 : BN_clear_free(tmp);
1614 9991 : BN_clear_free(tmp2);
1615 :
1616 9991 : return (struct crypto_bignum *) y_sqr;
1617 : }
1618 :
1619 :
1620 205 : int crypto_ec_point_is_at_infinity(struct crypto_ec *e,
1621 : const struct crypto_ec_point *p)
1622 : {
1623 205 : return EC_POINT_is_at_infinity(e->group, (const EC_POINT *) p);
1624 : }
1625 :
1626 :
1627 219 : int crypto_ec_point_is_on_curve(struct crypto_ec *e,
1628 : const struct crypto_ec_point *p)
1629 : {
1630 438 : return EC_POINT_is_on_curve(e->group, (const EC_POINT *) p,
1631 219 : e->bnctx) == 1;
1632 : }
1633 :
1634 :
1635 1 : int crypto_ec_point_cmp(const struct crypto_ec *e,
1636 : const struct crypto_ec_point *a,
1637 : const struct crypto_ec_point *b)
1638 : {
1639 1 : return EC_POINT_cmp(e->group, (const EC_POINT *) a,
1640 : (const EC_POINT *) b, e->bnctx);
1641 : }
1642 :
1643 : #endif /* CONFIG_ECC */
|
