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 590 : 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 590 : 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 30499 : 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 30499 : EVP_MD_CTX_init(&ctx);
73 30499 : 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 107212 : for (i = 0; i < num_elem; i++) {
79 76713 : 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 30499 : 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 30499 : return 0;
93 : }
94 :
95 :
96 1129 : int md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
97 : {
98 1129 : return openssl_digest_vector(EVP_md4(), num_elem, addr, len, mac);
99 : }
100 :
101 :
102 909 : void des_encrypt(const u8 *clear, const u8 *key, u8 *cypher)
103 : {
104 : u8 pkey[8], next, tmp;
105 : int i;
106 : DES_key_schedule ks;
107 :
108 : /* Add parity bits to the key */
109 909 : next = 0;
110 7272 : for (i = 0; i < 7; i++) {
111 6363 : tmp = key[i];
112 6363 : pkey[i] = (tmp >> i) | next | 1;
113 6363 : next = tmp << (7 - i);
114 : }
115 909 : pkey[i] = next | 1;
116 :
117 909 : DES_set_key((DES_cblock *) &pkey, &ks);
118 909 : DES_ecb_encrypt((DES_cblock *) clear, (DES_cblock *) cypher, &ks,
119 : DES_ENCRYPT);
120 909 : }
121 :
122 :
123 68 : int rc4_skip(const u8 *key, size_t keylen, size_t skip,
124 : u8 *data, size_t data_len)
125 : {
126 : #ifdef OPENSSL_NO_RC4
127 : return -1;
128 : #else /* OPENSSL_NO_RC4 */
129 : EVP_CIPHER_CTX ctx;
130 : int outl;
131 68 : int res = -1;
132 : unsigned char skip_buf[16];
133 :
134 68 : EVP_CIPHER_CTX_init(&ctx);
135 136 : if (!EVP_CIPHER_CTX_set_padding(&ctx, 0) ||
136 136 : !EVP_CipherInit_ex(&ctx, EVP_rc4(), NULL, NULL, NULL, 1) ||
137 136 : !EVP_CIPHER_CTX_set_key_length(&ctx, keylen) ||
138 68 : !EVP_CipherInit_ex(&ctx, NULL, NULL, key, NULL, 1))
139 : goto out;
140 :
141 888 : while (skip >= sizeof(skip_buf)) {
142 752 : size_t len = skip;
143 752 : if (len > sizeof(skip_buf))
144 705 : len = sizeof(skip_buf);
145 752 : if (!EVP_CipherUpdate(&ctx, skip_buf, &outl, skip_buf, len))
146 0 : goto out;
147 752 : skip -= len;
148 : }
149 :
150 68 : if (EVP_CipherUpdate(&ctx, data, &outl, data, data_len))
151 68 : res = 0;
152 :
153 : out:
154 68 : EVP_CIPHER_CTX_cleanup(&ctx);
155 68 : return res;
156 : #endif /* OPENSSL_NO_RC4 */
157 : }
158 :
159 :
160 25190 : int md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
161 : {
162 25190 : return openssl_digest_vector(EVP_md5(), num_elem, addr, len, mac);
163 : }
164 :
165 :
166 1789 : int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
167 : {
168 1789 : return openssl_digest_vector(EVP_sha1(), num_elem, addr, len, mac);
169 : }
170 :
171 :
172 : #ifndef NO_SHA256_WRAPPER
173 2391 : int sha256_vector(size_t num_elem, const u8 *addr[], const size_t *len,
174 : u8 *mac)
175 : {
176 2391 : return openssl_digest_vector(EVP_sha256(), num_elem, addr, len, mac);
177 : }
178 : #endif /* NO_SHA256_WRAPPER */
179 :
180 :
181 15047 : static const EVP_CIPHER * aes_get_evp_cipher(size_t keylen)
182 : {
183 15047 : switch (keylen) {
184 : case 16:
185 15047 : return EVP_aes_128_ecb();
186 : #ifndef OPENSSL_IS_BORINGSSL
187 : case 24:
188 0 : return EVP_aes_192_ecb();
189 : #endif /* OPENSSL_IS_BORINGSSL */
190 : case 32:
191 0 : return EVP_aes_256_ecb();
192 : }
193 :
194 0 : return NULL;
195 : }
196 :
197 :
198 13763 : void * aes_encrypt_init(const u8 *key, size_t len)
199 : {
200 : EVP_CIPHER_CTX *ctx;
201 : const EVP_CIPHER *type;
202 :
203 13763 : type = aes_get_evp_cipher(len);
204 13763 : if (type == NULL)
205 0 : return NULL;
206 :
207 13763 : ctx = os_malloc(sizeof(*ctx));
208 13763 : if (ctx == NULL)
209 0 : return NULL;
210 13763 : EVP_CIPHER_CTX_init(ctx);
211 13763 : if (EVP_EncryptInit_ex(ctx, type, NULL, key, NULL) != 1) {
212 0 : os_free(ctx);
213 0 : return NULL;
214 : }
215 13763 : EVP_CIPHER_CTX_set_padding(ctx, 0);
216 13763 : return ctx;
217 : }
218 :
219 :
220 84235 : void aes_encrypt(void *ctx, const u8 *plain, u8 *crypt)
221 : {
222 84235 : EVP_CIPHER_CTX *c = ctx;
223 84235 : int clen = 16;
224 84235 : if (EVP_EncryptUpdate(c, crypt, &clen, plain, 16) != 1) {
225 0 : wpa_printf(MSG_ERROR, "OpenSSL: EVP_EncryptUpdate failed: %s",
226 : ERR_error_string(ERR_get_error(), NULL));
227 : }
228 84235 : }
229 :
230 :
231 13763 : void aes_encrypt_deinit(void *ctx)
232 : {
233 13763 : EVP_CIPHER_CTX *c = ctx;
234 : u8 buf[16];
235 13763 : int len = sizeof(buf);
236 13763 : if (EVP_EncryptFinal_ex(c, buf, &len) != 1) {
237 0 : wpa_printf(MSG_ERROR, "OpenSSL: EVP_EncryptFinal_ex failed: "
238 : "%s", ERR_error_string(ERR_get_error(), NULL));
239 : }
240 13763 : if (len != 0) {
241 0 : wpa_printf(MSG_ERROR, "OpenSSL: Unexpected padding length %d "
242 : "in AES encrypt", len);
243 : }
244 13763 : EVP_CIPHER_CTX_cleanup(c);
245 13763 : bin_clear_free(c, sizeof(*c));
246 13763 : }
247 :
248 :
249 1284 : void * aes_decrypt_init(const u8 *key, size_t len)
250 : {
251 : EVP_CIPHER_CTX *ctx;
252 : const EVP_CIPHER *type;
253 :
254 1284 : type = aes_get_evp_cipher(len);
255 1284 : if (type == NULL)
256 0 : return NULL;
257 :
258 1284 : ctx = os_malloc(sizeof(*ctx));
259 1284 : if (ctx == NULL)
260 0 : return NULL;
261 1284 : EVP_CIPHER_CTX_init(ctx);
262 1284 : if (EVP_DecryptInit_ex(ctx, type, NULL, key, NULL) != 1) {
263 0 : os_free(ctx);
264 0 : return NULL;
265 : }
266 1284 : EVP_CIPHER_CTX_set_padding(ctx, 0);
267 1284 : return ctx;
268 : }
269 :
270 :
271 5236 : void aes_decrypt(void *ctx, const u8 *crypt, u8 *plain)
272 : {
273 5236 : EVP_CIPHER_CTX *c = ctx;
274 5236 : int plen = 16;
275 5236 : if (EVP_DecryptUpdate(c, plain, &plen, crypt, 16) != 1) {
276 0 : wpa_printf(MSG_ERROR, "OpenSSL: EVP_DecryptUpdate failed: %s",
277 : ERR_error_string(ERR_get_error(), NULL));
278 : }
279 5236 : }
280 :
281 :
282 1284 : void aes_decrypt_deinit(void *ctx)
283 : {
284 1284 : EVP_CIPHER_CTX *c = ctx;
285 : u8 buf[16];
286 1284 : int len = sizeof(buf);
287 1284 : if (EVP_DecryptFinal_ex(c, buf, &len) != 1) {
288 0 : wpa_printf(MSG_ERROR, "OpenSSL: EVP_DecryptFinal_ex failed: "
289 : "%s", ERR_error_string(ERR_get_error(), NULL));
290 : }
291 1284 : if (len != 0) {
292 0 : wpa_printf(MSG_ERROR, "OpenSSL: Unexpected padding length %d "
293 : "in AES decrypt", len);
294 : }
295 1284 : EVP_CIPHER_CTX_cleanup(c);
296 1284 : bin_clear_free(c, sizeof(*c));
297 1284 : }
298 :
299 :
300 1558 : int aes_wrap(const u8 *kek, size_t kek_len, int n, const u8 *plain, u8 *cipher)
301 : {
302 : AES_KEY actx;
303 : int res;
304 :
305 1558 : if (AES_set_encrypt_key(kek, kek_len << 3, &actx))
306 0 : return -1;
307 1558 : res = AES_wrap_key(&actx, NULL, cipher, plain, n * 8);
308 1558 : OPENSSL_cleanse(&actx, sizeof(actx));
309 1558 : return res <= 0 ? -1 : 0;
310 : }
311 :
312 :
313 1540 : int aes_unwrap(const u8 *kek, size_t kek_len, int n, const u8 *cipher,
314 : u8 *plain)
315 : {
316 : AES_KEY actx;
317 : int res;
318 :
319 1540 : if (AES_set_decrypt_key(kek, kek_len << 3, &actx))
320 0 : return -1;
321 1540 : res = AES_unwrap_key(&actx, NULL, plain, cipher, (n + 1) * 8);
322 1540 : OPENSSL_cleanse(&actx, sizeof(actx));
323 1540 : return res <= 0 ? -1 : 0;
324 : }
325 :
326 :
327 68 : int crypto_mod_exp(const u8 *base, size_t base_len,
328 : const u8 *power, size_t power_len,
329 : const u8 *modulus, size_t modulus_len,
330 : u8 *result, size_t *result_len)
331 : {
332 : BIGNUM *bn_base, *bn_exp, *bn_modulus, *bn_result;
333 68 : int ret = -1;
334 : BN_CTX *ctx;
335 :
336 68 : ctx = BN_CTX_new();
337 68 : if (ctx == NULL)
338 0 : return -1;
339 :
340 68 : bn_base = BN_bin2bn(base, base_len, NULL);
341 68 : bn_exp = BN_bin2bn(power, power_len, NULL);
342 68 : bn_modulus = BN_bin2bn(modulus, modulus_len, NULL);
343 68 : bn_result = BN_new();
344 :
345 68 : if (bn_base == NULL || bn_exp == NULL || bn_modulus == NULL ||
346 : bn_result == NULL)
347 : goto error;
348 :
349 68 : if (BN_mod_exp(bn_result, bn_base, bn_exp, bn_modulus, ctx) != 1)
350 0 : goto error;
351 :
352 68 : *result_len = BN_bn2bin(bn_result, result);
353 68 : ret = 0;
354 :
355 : error:
356 68 : BN_clear_free(bn_base);
357 68 : BN_clear_free(bn_exp);
358 68 : BN_clear_free(bn_modulus);
359 68 : BN_clear_free(bn_result);
360 68 : BN_CTX_free(ctx);
361 68 : return ret;
362 : }
363 :
364 :
365 : struct crypto_cipher {
366 : EVP_CIPHER_CTX enc;
367 : EVP_CIPHER_CTX dec;
368 : };
369 :
370 :
371 46 : struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg,
372 : const u8 *iv, const u8 *key,
373 : size_t key_len)
374 : {
375 : struct crypto_cipher *ctx;
376 : const EVP_CIPHER *cipher;
377 :
378 46 : ctx = os_zalloc(sizeof(*ctx));
379 46 : if (ctx == NULL)
380 0 : return NULL;
381 :
382 46 : switch (alg) {
383 : #ifndef OPENSSL_NO_RC4
384 : case CRYPTO_CIPHER_ALG_RC4:
385 0 : cipher = EVP_rc4();
386 0 : break;
387 : #endif /* OPENSSL_NO_RC4 */
388 : #ifndef OPENSSL_NO_AES
389 : case CRYPTO_CIPHER_ALG_AES:
390 42 : switch (key_len) {
391 : case 16:
392 42 : cipher = EVP_aes_128_cbc();
393 42 : break;
394 : #ifndef OPENSSL_IS_BORINGSSL
395 : case 24:
396 0 : cipher = EVP_aes_192_cbc();
397 0 : break;
398 : #endif /* OPENSSL_IS_BORINGSSL */
399 : case 32:
400 0 : cipher = EVP_aes_256_cbc();
401 0 : break;
402 : default:
403 0 : os_free(ctx);
404 0 : return NULL;
405 : }
406 42 : break;
407 : #endif /* OPENSSL_NO_AES */
408 : #ifndef OPENSSL_NO_DES
409 : case CRYPTO_CIPHER_ALG_3DES:
410 4 : cipher = EVP_des_ede3_cbc();
411 4 : break;
412 : case CRYPTO_CIPHER_ALG_DES:
413 0 : cipher = EVP_des_cbc();
414 0 : break;
415 : #endif /* OPENSSL_NO_DES */
416 : #ifndef OPENSSL_NO_RC2
417 : case CRYPTO_CIPHER_ALG_RC2:
418 0 : cipher = EVP_rc2_ecb();
419 0 : break;
420 : #endif /* OPENSSL_NO_RC2 */
421 : default:
422 0 : os_free(ctx);
423 0 : return NULL;
424 : }
425 :
426 46 : EVP_CIPHER_CTX_init(&ctx->enc);
427 46 : EVP_CIPHER_CTX_set_padding(&ctx->enc, 0);
428 92 : if (!EVP_EncryptInit_ex(&ctx->enc, cipher, NULL, NULL, NULL) ||
429 92 : !EVP_CIPHER_CTX_set_key_length(&ctx->enc, key_len) ||
430 46 : !EVP_EncryptInit_ex(&ctx->enc, NULL, NULL, key, iv)) {
431 0 : EVP_CIPHER_CTX_cleanup(&ctx->enc);
432 0 : os_free(ctx);
433 0 : return NULL;
434 : }
435 :
436 46 : EVP_CIPHER_CTX_init(&ctx->dec);
437 46 : EVP_CIPHER_CTX_set_padding(&ctx->dec, 0);
438 92 : if (!EVP_DecryptInit_ex(&ctx->dec, cipher, NULL, NULL, NULL) ||
439 92 : !EVP_CIPHER_CTX_set_key_length(&ctx->dec, key_len) ||
440 46 : !EVP_DecryptInit_ex(&ctx->dec, NULL, NULL, key, iv)) {
441 0 : EVP_CIPHER_CTX_cleanup(&ctx->enc);
442 0 : EVP_CIPHER_CTX_cleanup(&ctx->dec);
443 0 : os_free(ctx);
444 0 : return NULL;
445 : }
446 :
447 46 : return ctx;
448 : }
449 :
450 :
451 25 : int crypto_cipher_encrypt(struct crypto_cipher *ctx, const u8 *plain,
452 : u8 *crypt, size_t len)
453 : {
454 : int outl;
455 25 : if (!EVP_EncryptUpdate(&ctx->enc, crypt, &outl, plain, len))
456 0 : return -1;
457 25 : return 0;
458 : }
459 :
460 :
461 21 : int crypto_cipher_decrypt(struct crypto_cipher *ctx, const u8 *crypt,
462 : u8 *plain, size_t len)
463 : {
464 : int outl;
465 21 : outl = len;
466 21 : if (!EVP_DecryptUpdate(&ctx->dec, plain, &outl, crypt, len))
467 0 : return -1;
468 21 : return 0;
469 : }
470 :
471 :
472 46 : void crypto_cipher_deinit(struct crypto_cipher *ctx)
473 : {
474 46 : EVP_CIPHER_CTX_cleanup(&ctx->enc);
475 46 : EVP_CIPHER_CTX_cleanup(&ctx->dec);
476 46 : os_free(ctx);
477 46 : }
478 :
479 :
480 536 : void * dh5_init(struct wpabuf **priv, struct wpabuf **publ)
481 : {
482 : DH *dh;
483 536 : struct wpabuf *pubkey = NULL, *privkey = NULL;
484 : size_t publen, privlen;
485 :
486 536 : *priv = NULL;
487 536 : *publ = NULL;
488 :
489 536 : dh = DH_new();
490 536 : if (dh == NULL)
491 0 : return NULL;
492 :
493 536 : dh->g = BN_new();
494 536 : if (dh->g == NULL || BN_set_word(dh->g, 2) != 1)
495 : goto err;
496 :
497 536 : dh->p = get_group5_prime();
498 536 : if (dh->p == NULL)
499 0 : goto err;
500 :
501 536 : if (DH_generate_key(dh) != 1)
502 0 : goto err;
503 :
504 536 : publen = BN_num_bytes(dh->pub_key);
505 536 : pubkey = wpabuf_alloc(publen);
506 536 : if (pubkey == NULL)
507 0 : goto err;
508 536 : privlen = BN_num_bytes(dh->priv_key);
509 536 : privkey = wpabuf_alloc(privlen);
510 536 : if (privkey == NULL)
511 0 : goto err;
512 :
513 536 : BN_bn2bin(dh->pub_key, wpabuf_put(pubkey, publen));
514 536 : BN_bn2bin(dh->priv_key, wpabuf_put(privkey, privlen));
515 :
516 536 : *priv = privkey;
517 536 : *publ = pubkey;
518 536 : return dh;
519 :
520 : err:
521 0 : wpabuf_clear_free(pubkey);
522 0 : wpabuf_clear_free(privkey);
523 0 : DH_free(dh);
524 0 : return NULL;
525 : }
526 :
527 :
528 54 : void * dh5_init_fixed(const struct wpabuf *priv, const struct wpabuf *publ)
529 : {
530 : DH *dh;
531 :
532 54 : dh = DH_new();
533 54 : if (dh == NULL)
534 0 : return NULL;
535 :
536 54 : dh->g = BN_new();
537 54 : if (dh->g == NULL || BN_set_word(dh->g, 2) != 1)
538 : goto err;
539 :
540 54 : dh->p = get_group5_prime();
541 54 : if (dh->p == NULL)
542 0 : goto err;
543 :
544 54 : dh->priv_key = BN_bin2bn(wpabuf_head(priv), wpabuf_len(priv), NULL);
545 54 : if (dh->priv_key == NULL)
546 0 : goto err;
547 :
548 54 : dh->pub_key = BN_bin2bn(wpabuf_head(publ), wpabuf_len(publ), NULL);
549 54 : if (dh->pub_key == NULL)
550 0 : goto err;
551 :
552 54 : if (DH_generate_key(dh) != 1)
553 0 : goto err;
554 :
555 54 : return dh;
556 :
557 : err:
558 0 : DH_free(dh);
559 0 : return NULL;
560 : }
561 :
562 :
563 521 : struct wpabuf * dh5_derive_shared(void *ctx, const struct wpabuf *peer_public,
564 : const struct wpabuf *own_private)
565 : {
566 : BIGNUM *pub_key;
567 521 : struct wpabuf *res = NULL;
568 : size_t rlen;
569 521 : DH *dh = ctx;
570 : int keylen;
571 :
572 521 : if (ctx == NULL)
573 0 : return NULL;
574 :
575 521 : pub_key = BN_bin2bn(wpabuf_head(peer_public), wpabuf_len(peer_public),
576 : NULL);
577 521 : if (pub_key == NULL)
578 0 : return NULL;
579 :
580 521 : rlen = DH_size(dh);
581 521 : res = wpabuf_alloc(rlen);
582 521 : if (res == NULL)
583 0 : goto err;
584 :
585 521 : keylen = DH_compute_key(wpabuf_mhead(res), pub_key, dh);
586 521 : if (keylen < 0)
587 0 : goto err;
588 521 : wpabuf_put(res, keylen);
589 521 : BN_clear_free(pub_key);
590 :
591 521 : return res;
592 :
593 : err:
594 0 : BN_clear_free(pub_key);
595 0 : wpabuf_clear_free(res);
596 0 : return NULL;
597 : }
598 :
599 :
600 1680 : void dh5_free(void *ctx)
601 : {
602 : DH *dh;
603 1680 : if (ctx == NULL)
604 2770 : return;
605 590 : dh = ctx;
606 590 : DH_free(dh);
607 : }
608 :
609 :
610 : struct crypto_hash {
611 : HMAC_CTX ctx;
612 : };
613 :
614 :
615 276 : struct crypto_hash * crypto_hash_init(enum crypto_hash_alg alg, const u8 *key,
616 : size_t key_len)
617 : {
618 : struct crypto_hash *ctx;
619 : const EVP_MD *md;
620 :
621 276 : switch (alg) {
622 : #ifndef OPENSSL_NO_MD5
623 : case CRYPTO_HASH_ALG_HMAC_MD5:
624 0 : md = EVP_md5();
625 0 : break;
626 : #endif /* OPENSSL_NO_MD5 */
627 : #ifndef OPENSSL_NO_SHA
628 : case CRYPTO_HASH_ALG_HMAC_SHA1:
629 0 : md = EVP_sha1();
630 0 : break;
631 : #endif /* OPENSSL_NO_SHA */
632 : #ifndef OPENSSL_NO_SHA256
633 : #ifdef CONFIG_SHA256
634 : case CRYPTO_HASH_ALG_HMAC_SHA256:
635 276 : md = EVP_sha256();
636 276 : break;
637 : #endif /* CONFIG_SHA256 */
638 : #endif /* OPENSSL_NO_SHA256 */
639 : default:
640 0 : return NULL;
641 : }
642 :
643 276 : ctx = os_zalloc(sizeof(*ctx));
644 276 : if (ctx == NULL)
645 0 : return NULL;
646 276 : HMAC_CTX_init(&ctx->ctx);
647 :
648 : #if OPENSSL_VERSION_NUMBER < 0x00909000
649 : HMAC_Init_ex(&ctx->ctx, key, key_len, md, NULL);
650 : #else /* openssl < 0.9.9 */
651 276 : if (HMAC_Init_ex(&ctx->ctx, key, key_len, md, NULL) != 1) {
652 0 : bin_clear_free(ctx, sizeof(*ctx));
653 0 : return NULL;
654 : }
655 : #endif /* openssl < 0.9.9 */
656 :
657 276 : return ctx;
658 : }
659 :
660 :
661 1222 : void crypto_hash_update(struct crypto_hash *ctx, const u8 *data, size_t len)
662 : {
663 1222 : if (ctx == NULL)
664 1222 : return;
665 1222 : HMAC_Update(&ctx->ctx, data, len);
666 : }
667 :
668 :
669 276 : int crypto_hash_finish(struct crypto_hash *ctx, u8 *mac, size_t *len)
670 : {
671 : unsigned int mdlen;
672 : int res;
673 :
674 276 : if (ctx == NULL)
675 0 : return -2;
676 :
677 276 : if (mac == NULL || len == NULL) {
678 0 : bin_clear_free(ctx, sizeof(*ctx));
679 0 : return 0;
680 : }
681 :
682 276 : mdlen = *len;
683 : #if OPENSSL_VERSION_NUMBER < 0x00909000
684 : HMAC_Final(&ctx->ctx, mac, &mdlen);
685 : res = 1;
686 : #else /* openssl < 0.9.9 */
687 276 : res = HMAC_Final(&ctx->ctx, mac, &mdlen);
688 : #endif /* openssl < 0.9.9 */
689 276 : HMAC_CTX_cleanup(&ctx->ctx);
690 276 : bin_clear_free(ctx, sizeof(*ctx));
691 :
692 276 : if (res == 1) {
693 276 : *len = mdlen;
694 276 : return 0;
695 : }
696 :
697 0 : return -1;
698 : }
699 :
700 :
701 52247 : static int openssl_hmac_vector(const EVP_MD *type, const u8 *key,
702 : size_t key_len, size_t num_elem,
703 : const u8 *addr[], const size_t *len, u8 *mac,
704 : unsigned int mdlen)
705 : {
706 : HMAC_CTX ctx;
707 : size_t i;
708 : int res;
709 :
710 52247 : HMAC_CTX_init(&ctx);
711 : #if OPENSSL_VERSION_NUMBER < 0x00909000
712 : HMAC_Init_ex(&ctx, key, key_len, type, NULL);
713 : #else /* openssl < 0.9.9 */
714 52247 : if (HMAC_Init_ex(&ctx, key, key_len, type, NULL) != 1)
715 0 : return -1;
716 : #endif /* openssl < 0.9.9 */
717 :
718 164833 : for (i = 0; i < num_elem; i++)
719 112586 : HMAC_Update(&ctx, addr[i], len[i]);
720 :
721 : #if OPENSSL_VERSION_NUMBER < 0x00909000
722 : HMAC_Final(&ctx, mac, &mdlen);
723 : res = 1;
724 : #else /* openssl < 0.9.9 */
725 52247 : res = HMAC_Final(&ctx, mac, &mdlen);
726 : #endif /* openssl < 0.9.9 */
727 52247 : HMAC_CTX_cleanup(&ctx);
728 :
729 52247 : return res == 1 ? 0 : -1;
730 : }
731 :
732 :
733 : #ifndef CONFIG_FIPS
734 :
735 13383 : int hmac_md5_vector(const u8 *key, size_t key_len, size_t num_elem,
736 : const u8 *addr[], const size_t *len, u8 *mac)
737 : {
738 13383 : return openssl_hmac_vector(EVP_md5(), key ,key_len, num_elem, addr, len,
739 : mac, 16);
740 : }
741 :
742 :
743 12903 : int hmac_md5(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
744 : u8 *mac)
745 : {
746 12903 : return hmac_md5_vector(key, key_len, 1, &data, &data_len, mac);
747 : }
748 :
749 : #endif /* CONFIG_FIPS */
750 :
751 :
752 865 : int pbkdf2_sha1(const char *passphrase, const u8 *ssid, size_t ssid_len,
753 : int iterations, u8 *buf, size_t buflen)
754 : {
755 865 : if (PKCS5_PBKDF2_HMAC_SHA1(passphrase, os_strlen(passphrase), ssid,
756 : ssid_len, iterations, buflen, buf) != 1)
757 0 : return -1;
758 865 : return 0;
759 : }
760 :
761 :
762 23021 : int hmac_sha1_vector(const u8 *key, size_t key_len, size_t num_elem,
763 : const u8 *addr[], const size_t *len, u8 *mac)
764 : {
765 23021 : return openssl_hmac_vector(EVP_sha1(), key, key_len, num_elem, addr,
766 : len, mac, 20);
767 : }
768 :
769 :
770 7944 : int hmac_sha1(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
771 : u8 *mac)
772 : {
773 7944 : return hmac_sha1_vector(key, key_len, 1, &data, &data_len, mac);
774 : }
775 :
776 :
777 : #ifdef CONFIG_SHA256
778 :
779 15828 : int hmac_sha256_vector(const u8 *key, size_t key_len, size_t num_elem,
780 : const u8 *addr[], const size_t *len, u8 *mac)
781 : {
782 15828 : return openssl_hmac_vector(EVP_sha256(), key, key_len, num_elem, addr,
783 : len, mac, 32);
784 : }
785 :
786 :
787 3516 : int hmac_sha256(const u8 *key, size_t key_len, const u8 *data,
788 : size_t data_len, u8 *mac)
789 : {
790 3516 : return hmac_sha256_vector(key, key_len, 1, &data, &data_len, mac);
791 : }
792 :
793 : #endif /* CONFIG_SHA256 */
794 :
795 :
796 : #ifdef CONFIG_SHA384
797 :
798 15 : int hmac_sha384_vector(const u8 *key, size_t key_len, size_t num_elem,
799 : const u8 *addr[], const size_t *len, u8 *mac)
800 : {
801 15 : return openssl_hmac_vector(EVP_sha384(), key, key_len, num_elem, addr,
802 : len, mac, 32);
803 : }
804 :
805 :
806 12 : int hmac_sha384(const u8 *key, size_t key_len, const u8 *data,
807 : size_t data_len, u8 *mac)
808 : {
809 12 : return hmac_sha384_vector(key, key_len, 1, &data, &data_len, mac);
810 : }
811 :
812 : #endif /* CONFIG_SHA384 */
813 :
814 :
815 0 : int crypto_get_random(void *buf, size_t len)
816 : {
817 0 : if (RAND_bytes(buf, len) != 1)
818 0 : return -1;
819 0 : return 0;
820 : }
821 :
822 :
823 : #ifdef CONFIG_OPENSSL_CMAC
824 : int omac1_aes_vector(const u8 *key, size_t key_len, size_t num_elem,
825 : const u8 *addr[], const size_t *len, u8 *mac)
826 : {
827 : CMAC_CTX *ctx;
828 : int ret = -1;
829 : size_t outlen, i;
830 :
831 : ctx = CMAC_CTX_new();
832 : if (ctx == NULL)
833 : return -1;
834 :
835 : if (key_len == 32) {
836 : if (!CMAC_Init(ctx, key, 32, EVP_aes_256_cbc(), NULL))
837 : goto fail;
838 : } else if (key_len == 16) {
839 : if (!CMAC_Init(ctx, key, 16, EVP_aes_128_cbc(), NULL))
840 : goto fail;
841 : } else {
842 : goto fail;
843 : }
844 : for (i = 0; i < num_elem; i++) {
845 : if (!CMAC_Update(ctx, addr[i], len[i]))
846 : goto fail;
847 : }
848 : if (!CMAC_Final(ctx, mac, &outlen) || outlen != 16)
849 : goto fail;
850 :
851 : ret = 0;
852 : fail:
853 : CMAC_CTX_free(ctx);
854 : return ret;
855 : }
856 :
857 :
858 : int omac1_aes_128_vector(const u8 *key, size_t num_elem,
859 : const u8 *addr[], const size_t *len, u8 *mac)
860 : {
861 : return omac1_aes_vector(key, 16, num_elem, addr, len, mac);
862 : }
863 :
864 :
865 : int omac1_aes_128(const u8 *key, const u8 *data, size_t data_len, u8 *mac)
866 : {
867 : return omac1_aes_128_vector(key, 1, &data, &data_len, mac);
868 : }
869 :
870 :
871 : int omac1_aes_256(const u8 *key, const u8 *data, size_t data_len, u8 *mac)
872 : {
873 : return omac1_aes_vector(key, 32, 1, &data, &data_len, mac);
874 : }
875 : #endif /* CONFIG_OPENSSL_CMAC */
876 :
877 :
878 188 : struct crypto_bignum * crypto_bignum_init(void)
879 : {
880 188 : return (struct crypto_bignum *) BN_new();
881 : }
882 :
883 :
884 561 : struct crypto_bignum * crypto_bignum_init_set(const u8 *buf, size_t len)
885 : {
886 561 : BIGNUM *bn = BN_bin2bn(buf, len, NULL);
887 561 : return (struct crypto_bignum *) bn;
888 : }
889 :
890 :
891 6197 : void crypto_bignum_deinit(struct crypto_bignum *n, int clear)
892 : {
893 6197 : if (clear)
894 340 : BN_clear_free((BIGNUM *) n);
895 : else
896 5857 : BN_free((BIGNUM *) n);
897 6197 : }
898 :
899 :
900 1655 : int crypto_bignum_to_bin(const struct crypto_bignum *a,
901 : u8 *buf, size_t buflen, size_t padlen)
902 : {
903 : int num_bytes, offset;
904 :
905 1655 : if (padlen > buflen)
906 0 : return -1;
907 :
908 1655 : num_bytes = BN_num_bytes((const BIGNUM *) a);
909 1655 : if ((size_t) num_bytes > buflen)
910 0 : return -1;
911 1655 : if (padlen > (size_t) num_bytes)
912 49 : offset = padlen - num_bytes;
913 : else
914 1606 : offset = 0;
915 :
916 1655 : os_memset(buf, 0, offset);
917 1655 : BN_bn2bin((const BIGNUM *) a, buf + offset);
918 :
919 1655 : return num_bytes + offset;
920 : }
921 :
922 :
923 164 : int crypto_bignum_add(const struct crypto_bignum *a,
924 : const struct crypto_bignum *b,
925 : struct crypto_bignum *c)
926 : {
927 328 : return BN_add((BIGNUM *) c, (const BIGNUM *) a, (const BIGNUM *) b) ?
928 164 : 0 : -1;
929 : }
930 :
931 :
932 164 : int crypto_bignum_mod(const struct crypto_bignum *a,
933 : const struct crypto_bignum *b,
934 : struct crypto_bignum *c)
935 : {
936 : int res;
937 : BN_CTX *bnctx;
938 :
939 164 : bnctx = BN_CTX_new();
940 164 : if (bnctx == NULL)
941 0 : return -1;
942 164 : res = BN_mod((BIGNUM *) c, (const BIGNUM *) a, (const BIGNUM *) b,
943 : bnctx);
944 164 : BN_CTX_free(bnctx);
945 :
946 164 : return res ? 0 : -1;
947 : }
948 :
949 :
950 50 : int crypto_bignum_exptmod(const struct crypto_bignum *a,
951 : const struct crypto_bignum *b,
952 : const struct crypto_bignum *c,
953 : struct crypto_bignum *d)
954 : {
955 : int res;
956 : BN_CTX *bnctx;
957 :
958 50 : bnctx = BN_CTX_new();
959 50 : if (bnctx == NULL)
960 0 : return -1;
961 50 : res = BN_mod_exp((BIGNUM *) d, (const BIGNUM *) a, (const BIGNUM *) b,
962 : (const BIGNUM *) c, bnctx);
963 50 : BN_CTX_free(bnctx);
964 :
965 50 : return res ? 0 : -1;
966 : }
967 :
968 :
969 10 : int crypto_bignum_inverse(const struct crypto_bignum *a,
970 : const struct crypto_bignum *b,
971 : struct crypto_bignum *c)
972 : {
973 : BIGNUM *res;
974 : BN_CTX *bnctx;
975 :
976 10 : bnctx = BN_CTX_new();
977 10 : if (bnctx == NULL)
978 0 : return -1;
979 10 : res = BN_mod_inverse((BIGNUM *) c, (const BIGNUM *) a,
980 : (const BIGNUM *) b, bnctx);
981 10 : BN_CTX_free(bnctx);
982 :
983 10 : return res ? 0 : -1;
984 : }
985 :
986 :
987 6 : int crypto_bignum_sub(const struct crypto_bignum *a,
988 : const struct crypto_bignum *b,
989 : struct crypto_bignum *c)
990 : {
991 12 : return BN_sub((BIGNUM *) c, (const BIGNUM *) a, (const BIGNUM *) b) ?
992 6 : 0 : -1;
993 : }
994 :
995 :
996 6 : int crypto_bignum_div(const struct crypto_bignum *a,
997 : const struct crypto_bignum *b,
998 : struct crypto_bignum *c)
999 : {
1000 : int res;
1001 :
1002 : BN_CTX *bnctx;
1003 :
1004 6 : bnctx = BN_CTX_new();
1005 6 : if (bnctx == NULL)
1006 0 : return -1;
1007 6 : res = BN_div((BIGNUM *) c, NULL, (const BIGNUM *) a,
1008 : (const BIGNUM *) b, bnctx);
1009 6 : BN_CTX_free(bnctx);
1010 :
1011 6 : return res ? 0 : -1;
1012 : }
1013 :
1014 :
1015 10 : int crypto_bignum_mulmod(const struct crypto_bignum *a,
1016 : const struct crypto_bignum *b,
1017 : const struct crypto_bignum *c,
1018 : struct crypto_bignum *d)
1019 : {
1020 : int res;
1021 :
1022 : BN_CTX *bnctx;
1023 :
1024 10 : bnctx = BN_CTX_new();
1025 10 : if (bnctx == NULL)
1026 0 : return -1;
1027 10 : res = BN_mod_mul((BIGNUM *) d, (const BIGNUM *) a, (const BIGNUM *) b,
1028 : (const BIGNUM *) c, bnctx);
1029 10 : BN_CTX_free(bnctx);
1030 :
1031 10 : return res ? 0 : -1;
1032 : }
1033 :
1034 :
1035 282 : int crypto_bignum_cmp(const struct crypto_bignum *a,
1036 : const struct crypto_bignum *b)
1037 : {
1038 282 : return BN_cmp((const BIGNUM *) a, (const BIGNUM *) b);
1039 : }
1040 :
1041 :
1042 178 : int crypto_bignum_bits(const struct crypto_bignum *a)
1043 : {
1044 178 : return BN_num_bits((const BIGNUM *) a);
1045 : }
1046 :
1047 :
1048 292 : int crypto_bignum_is_zero(const struct crypto_bignum *a)
1049 : {
1050 292 : return BN_is_zero((const BIGNUM *) a);
1051 : }
1052 :
1053 :
1054 231 : int crypto_bignum_is_one(const struct crypto_bignum *a)
1055 : {
1056 231 : return BN_is_one((const BIGNUM *) a);
1057 : }
1058 :
1059 :
1060 : #ifdef CONFIG_ECC
1061 :
1062 : struct crypto_ec {
1063 : EC_GROUP *group;
1064 : BN_CTX *bnctx;
1065 : BIGNUM *prime;
1066 : BIGNUM *order;
1067 : };
1068 :
1069 76 : struct crypto_ec * crypto_ec_init(int group)
1070 : {
1071 : struct crypto_ec *e;
1072 : int nid;
1073 :
1074 : /* Map from IANA registry for IKE D-H groups to OpenSSL NID */
1075 76 : switch (group) {
1076 : case 19:
1077 51 : nid = NID_X9_62_prime256v1;
1078 51 : break;
1079 : case 20:
1080 4 : nid = NID_secp384r1;
1081 4 : break;
1082 : case 21:
1083 2 : nid = NID_secp521r1;
1084 2 : break;
1085 : case 25:
1086 3 : nid = NID_X9_62_prime192v1;
1087 3 : break;
1088 : case 26:
1089 6 : nid = NID_secp224r1;
1090 6 : break;
1091 : default:
1092 10 : return NULL;
1093 : }
1094 :
1095 66 : e = os_zalloc(sizeof(*e));
1096 66 : if (e == NULL)
1097 0 : return NULL;
1098 :
1099 66 : e->bnctx = BN_CTX_new();
1100 66 : e->group = EC_GROUP_new_by_curve_name(nid);
1101 66 : e->prime = BN_new();
1102 66 : e->order = BN_new();
1103 132 : if (e->group == NULL || e->bnctx == NULL || e->prime == NULL ||
1104 132 : e->order == NULL ||
1105 132 : !EC_GROUP_get_curve_GFp(e->group, e->prime, NULL, NULL, e->bnctx) ||
1106 66 : !EC_GROUP_get_order(e->group, e->order, e->bnctx)) {
1107 0 : crypto_ec_deinit(e);
1108 0 : e = NULL;
1109 : }
1110 :
1111 66 : return e;
1112 : }
1113 :
1114 :
1115 76 : void crypto_ec_deinit(struct crypto_ec *e)
1116 : {
1117 76 : if (e == NULL)
1118 86 : return;
1119 66 : BN_clear_free(e->order);
1120 66 : BN_clear_free(e->prime);
1121 66 : EC_GROUP_free(e->group);
1122 66 : BN_CTX_free(e->bnctx);
1123 66 : os_free(e);
1124 : }
1125 :
1126 :
1127 270 : struct crypto_ec_point * crypto_ec_point_init(struct crypto_ec *e)
1128 : {
1129 270 : if (e == NULL)
1130 0 : return NULL;
1131 270 : return (struct crypto_ec_point *) EC_POINT_new(e->group);
1132 : }
1133 :
1134 :
1135 66 : size_t crypto_ec_prime_len(struct crypto_ec *e)
1136 : {
1137 66 : return BN_num_bytes(e->prime);
1138 : }
1139 :
1140 :
1141 239 : size_t crypto_ec_prime_len_bits(struct crypto_ec *e)
1142 : {
1143 239 : return BN_num_bits(e->prime);
1144 : }
1145 :
1146 :
1147 66 : const struct crypto_bignum * crypto_ec_get_prime(struct crypto_ec *e)
1148 : {
1149 66 : return (const struct crypto_bignum *) e->prime;
1150 : }
1151 :
1152 :
1153 66 : const struct crypto_bignum * crypto_ec_get_order(struct crypto_ec *e)
1154 : {
1155 66 : return (const struct crypto_bignum *) e->order;
1156 : }
1157 :
1158 :
1159 443 : void crypto_ec_point_deinit(struct crypto_ec_point *p, int clear)
1160 : {
1161 443 : if (clear)
1162 220 : EC_POINT_clear_free((EC_POINT *) p);
1163 : else
1164 223 : EC_POINT_free((EC_POINT *) p);
1165 443 : }
1166 :
1167 :
1168 430 : int crypto_ec_point_to_bin(struct crypto_ec *e,
1169 : const struct crypto_ec_point *point, u8 *x, u8 *y)
1170 : {
1171 : BIGNUM *x_bn, *y_bn;
1172 430 : int ret = -1;
1173 430 : int len = BN_num_bytes(e->prime);
1174 :
1175 430 : x_bn = BN_new();
1176 430 : y_bn = BN_new();
1177 :
1178 860 : if (x_bn && y_bn &&
1179 430 : EC_POINT_get_affine_coordinates_GFp(e->group, (EC_POINT *) point,
1180 : x_bn, y_bn, e->bnctx)) {
1181 430 : if (x) {
1182 430 : crypto_bignum_to_bin((struct crypto_bignum *) x_bn,
1183 : x, len, len);
1184 : }
1185 430 : if (y) {
1186 365 : crypto_bignum_to_bin((struct crypto_bignum *) y_bn,
1187 : y, len, len);
1188 : }
1189 430 : ret = 0;
1190 : }
1191 :
1192 430 : BN_clear_free(x_bn);
1193 430 : BN_clear_free(y_bn);
1194 430 : return ret;
1195 : }
1196 :
1197 :
1198 71 : struct crypto_ec_point * crypto_ec_point_from_bin(struct crypto_ec *e,
1199 : const u8 *val)
1200 : {
1201 : BIGNUM *x, *y;
1202 : EC_POINT *elem;
1203 71 : int len = BN_num_bytes(e->prime);
1204 :
1205 71 : x = BN_bin2bn(val, len, NULL);
1206 71 : y = BN_bin2bn(val + len, len, NULL);
1207 71 : elem = EC_POINT_new(e->group);
1208 71 : if (x == NULL || y == NULL || elem == NULL) {
1209 0 : BN_clear_free(x);
1210 0 : BN_clear_free(y);
1211 0 : EC_POINT_clear_free(elem);
1212 0 : return NULL;
1213 : }
1214 :
1215 71 : if (!EC_POINT_set_affine_coordinates_GFp(e->group, elem, x, y,
1216 : e->bnctx)) {
1217 0 : EC_POINT_clear_free(elem);
1218 0 : elem = NULL;
1219 : }
1220 :
1221 71 : BN_clear_free(x);
1222 71 : BN_clear_free(y);
1223 :
1224 71 : return (struct crypto_ec_point *) elem;
1225 : }
1226 :
1227 :
1228 65 : int crypto_ec_point_add(struct crypto_ec *e, const struct crypto_ec_point *a,
1229 : const struct crypto_ec_point *b,
1230 : struct crypto_ec_point *c)
1231 : {
1232 130 : return EC_POINT_add(e->group, (EC_POINT *) c, (const EC_POINT *) a,
1233 65 : (const EC_POINT *) b, e->bnctx) ? 0 : -1;
1234 : }
1235 :
1236 :
1237 209 : int crypto_ec_point_mul(struct crypto_ec *e, const struct crypto_ec_point *p,
1238 : const struct crypto_bignum *b,
1239 : struct crypto_ec_point *res)
1240 : {
1241 418 : return EC_POINT_mul(e->group, (EC_POINT *) res, NULL,
1242 : (const EC_POINT *) p, (const BIGNUM *) b, e->bnctx)
1243 209 : ? 0 : -1;
1244 : }
1245 :
1246 :
1247 79 : int crypto_ec_point_invert(struct crypto_ec *e, struct crypto_ec_point *p)
1248 : {
1249 79 : return EC_POINT_invert(e->group, (EC_POINT *) p, e->bnctx) ? 0 : -1;
1250 : }
1251 :
1252 :
1253 239 : int crypto_ec_point_solve_y_coord(struct crypto_ec *e,
1254 : struct crypto_ec_point *p,
1255 : const struct crypto_bignum *x, int y_bit)
1256 : {
1257 239 : if (!EC_POINT_set_compressed_coordinates_GFp(e->group, (EC_POINT *) p,
1258 : (const BIGNUM *) x, y_bit,
1259 128 : e->bnctx) ||
1260 128 : !EC_POINT_is_on_curve(e->group, (EC_POINT *) p, e->bnctx))
1261 111 : return -1;
1262 128 : return 0;
1263 : }
1264 :
1265 :
1266 65 : int crypto_ec_point_is_at_infinity(struct crypto_ec *e,
1267 : const struct crypto_ec_point *p)
1268 : {
1269 65 : return EC_POINT_is_at_infinity(e->group, (const EC_POINT *) p);
1270 : }
1271 :
1272 :
1273 71 : int crypto_ec_point_is_on_curve(struct crypto_ec *e,
1274 : const struct crypto_ec_point *p)
1275 : {
1276 71 : return EC_POINT_is_on_curve(e->group, (const EC_POINT *) p, e->bnctx);
1277 : }
1278 :
1279 : #endif /* CONFIG_ECC */
|
