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