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