src/crypto/crypto_openssl.c

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