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