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