contrib/wpa_supplicant/src/crypto/crypto_openssl.c

   1 /*
   2  * Wrapper functions for OpenSSL libcrypto
   3  * Copyright (c) 2004-2017, 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 "utils/const_time.h"
  28 #include "wpabuf.h"
  29 #include "dh_group5.h"
  30 #include "sha1.h"
  31 #include "sha256.h"
  32 #include "sha384.h"
  33 #include "sha512.h"
  34 #include "md5.h"
  35 #include "aes_wrap.h"
  36 #include "crypto.h"
  37
  38 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \
  39         (defined(LIBRESSL_VERSION_NUMBER) && \
  40          LIBRESSL_VERSION_NUMBER < 0x20700000L)
  41 /* Compatibility wrappers for older versions. */
  42
  43 static HMAC_CTX * HMAC_CTX_new(void)
  44 {
  45         HMAC_CTX *ctx;
  46
  47         ctx = os_zalloc(sizeof(*ctx));
  48         if (ctx)
  49                 HMAC_CTX_init(ctx);
  50         return ctx;
  51 }
  52
  53
  54 static void HMAC_CTX_free(HMAC_CTX *ctx)
  55 {
  56         if (!ctx)
  57                 return;
  58         HMAC_CTX_cleanup(ctx);
  59         bin_clear_free(ctx, sizeof(*ctx));
  60 }
  61
  62
  63 static EVP_MD_CTX * EVP_MD_CTX_new(void)
  64 {
  65         EVP_MD_CTX *ctx;
  66
  67         ctx = os_zalloc(sizeof(*ctx));
  68         if (ctx)
  69                 EVP_MD_CTX_init(ctx);
  70         return ctx;
  71 }
  72
  73
  74 static void EVP_MD_CTX_free(EVP_MD_CTX *ctx)
  75 {
  76         if (!ctx)
  77                 return;
  78         EVP_MD_CTX_cleanup(ctx);
  79         bin_clear_free(ctx, sizeof(*ctx));
  80 }
  81
  82 #endif /* OpenSSL version < 1.1.0 */
  83
  84 static BIGNUM * get_group5_prime(void)
  85 {
  86 #if OPENSSL_VERSION_NUMBER >= 0x10100000L && \
  87         !(defined(LIBRESSL_VERSION_NUMBER) && \
  88           LIBRESSL_VERSION_NUMBER < 0x20700000L)
  89         return BN_get_rfc3526_prime_1536(NULL);
  90 #elif !defined(OPENSSL_IS_BORINGSSL)
  91         return get_rfc3526_prime_1536(NULL);
  92 #else
  93         static const unsigned char RFC3526_PRIME_1536[] = {
  94                 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC9,0x0F,0xDA,0xA2,
  95                 0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,0x80,0xDC,0x1C,0xD1,
  96                 0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,0x02,0x0B,0xBE,0xA6,
  97                 0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,0x8E,0x34,0x04,0xDD,
  98                 0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,0x30,0x2B,0x0A,0x6D,
  99                 0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,0x6D,0x51,0xC2,0x45,
 100                 0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,0xF4,0x4C,0x42,0xE9,
 101                 0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,0xF4,0x06,0xB7,0xED,
 102                 0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,0xAE,0x9F,0x24,0x11,
 103                 0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,0xEC,0xE4,0x5B,0x3D,
 104                 0xC2,0x00,0x7C,0xB8,0xA1,0x63,0xBF,0x05,0x98,0xDA,0x48,0x36,
 105                 0x1C,0x55,0xD3,0x9A,0x69,0x16,0x3F,0xA8,0xFD,0x24,0xCF,0x5F,
 106                 0x83,0x65,0x5D,0x23,0xDC,0xA3,0xAD,0x96,0x1C,0x62,0xF3,0x56,
 107                 0x20,0x85,0x52,0xBB,0x9E,0xD5,0x29,0x07,0x70,0x96,0x96,0x6D,
 108                 0x67,0x0C,0x35,0x4E,0x4A,0xBC,0x98,0x04,0xF1,0x74,0x6C,0x08,
 109                 0xCA,0x23,0x73,0x27,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
 110         };
 111         return BN_bin2bn(RFC3526_PRIME_1536, sizeof(RFC3526_PRIME_1536), NULL);
 112 #endif
 113 }
 114
 115
 116 static BIGNUM * get_group5_order(void)
 117 {
 118         static const unsigned char RFC3526_ORDER_1536[] = {
 119                 0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xE4,0x87,0xED,0x51,
 120                 0x10,0xB4,0x61,0x1A,0x62,0x63,0x31,0x45,0xC0,0x6E,0x0E,0x68,
 121                 0x94,0x81,0x27,0x04,0x45,0x33,0xE6,0x3A,0x01,0x05,0xDF,0x53,
 122                 0x1D,0x89,0xCD,0x91,0x28,0xA5,0x04,0x3C,0xC7,0x1A,0x02,0x6E,
 123                 0xF7,0xCA,0x8C,0xD9,0xE6,0x9D,0x21,0x8D,0x98,0x15,0x85,0x36,
 124                 0xF9,0x2F,0x8A,0x1B,0xA7,0xF0,0x9A,0xB6,0xB6,0xA8,0xE1,0x22,
 125                 0xF2,0x42,0xDA,0xBB,0x31,0x2F,0x3F,0x63,0x7A,0x26,0x21,0x74,
 126                 0xD3,0x1B,0xF6,0xB5,0x85,0xFF,0xAE,0x5B,0x7A,0x03,0x5B,0xF6,
 127                 0xF7,0x1C,0x35,0xFD,0xAD,0x44,0xCF,0xD2,0xD7,0x4F,0x92,0x08,
 128                 0xBE,0x25,0x8F,0xF3,0x24,0x94,0x33,0x28,0xF6,0x72,0x2D,0x9E,
 129                 0xE1,0x00,0x3E,0x5C,0x50,0xB1,0xDF,0x82,0xCC,0x6D,0x24,0x1B,
 130                 0x0E,0x2A,0xE9,0xCD,0x34,0x8B,0x1F,0xD4,0x7E,0x92,0x67,0xAF,
 131                 0xC1,0xB2,0xAE,0x91,0xEE,0x51,0xD6,0xCB,0x0E,0x31,0x79,0xAB,
 132                 0x10,0x42,0xA9,0x5D,0xCF,0x6A,0x94,0x83,0xB8,0x4B,0x4B,0x36,
 133                 0xB3,0x86,0x1A,0xA7,0x25,0x5E,0x4C,0x02,0x78,0xBA,0x36,0x04,
 134                 0x65,0x11,0xB9,0x93,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
 135         };
 136         return BN_bin2bn(RFC3526_ORDER_1536, sizeof(RFC3526_ORDER_1536), NULL);
 137 }
 138
 139
 140 #ifdef OPENSSL_NO_SHA256
 141 #define NO_SHA256_WRAPPER
 142 #endif
 143 #ifdef OPENSSL_NO_SHA512
 144 #define NO_SHA384_WRAPPER
 145 #endif
 146
 147 static int openssl_digest_vector(const EVP_MD *type, size_t num_elem,
 148                                  const u8 *addr[], const size_t *len, u8 *mac)
 149 {
 150         EVP_MD_CTX *ctx;
 151         size_t i;
 152         unsigned int mac_len;
 153
 154         if (TEST_FAIL())
 155                 return -1;
 156
 157         ctx = EVP_MD_CTX_new();
 158         if (!ctx)
 159                 return -1;
 160         if (!EVP_DigestInit_ex(ctx, type, NULL)) {
 161                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_DigestInit_ex failed: %s",
 162                            ERR_error_string(ERR_get_error(), NULL));
 163                 EVP_MD_CTX_free(ctx);
 164                 return -1;
 165         }
 166         for (i = 0; i < num_elem; i++) {
 167                 if (!EVP_DigestUpdate(ctx, addr[i], len[i])) {
 168                         wpa_printf(MSG_ERROR, "OpenSSL: EVP_DigestUpdate "
 169                                    "failed: %s",
 170                                    ERR_error_string(ERR_get_error(), NULL));
 171                         EVP_MD_CTX_free(ctx);
 172                         return -1;
 173                 }
 174         }
 175         if (!EVP_DigestFinal(ctx, mac, &mac_len)) {
 176                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_DigestFinal failed: %s",
 177                            ERR_error_string(ERR_get_error(), NULL));
 178                 EVP_MD_CTX_free(ctx);
 179                 return -1;
 180         }
 181         EVP_MD_CTX_free(ctx);
 182
 183         return 0;
 184 }
 185
 186
 187 #ifndef CONFIG_FIPS
 188 int md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 189 {
 190         return openssl_digest_vector(EVP_md4(), num_elem, addr, len, mac);
 191 }
 192 #endif /* CONFIG_FIPS */
 193
 194
 195 int des_encrypt(const u8 *clear, const u8 *key, u8 *cypher)
 196 {
 197         u8 pkey[8], next, tmp;
 198         int i;
 199         DES_key_schedule ks;
 200
 201         /* Add parity bits to the key */
 202         next = 0;
 203         for (i = 0; i < 7; i++) {
 204                 tmp = key[i];
 205                 pkey[i] = (tmp >> i) | next | 1;
 206                 next = tmp << (7 - i);
 207         }
 208         pkey[i] = next | 1;
 209
 210         DES_set_key((DES_cblock *) &pkey, &ks);
 211         DES_ecb_encrypt((DES_cblock *) clear, (DES_cblock *) cypher, &ks,
 212                         DES_ENCRYPT);
 213         return 0;
 214 }
 215
 216
 217 #ifndef CONFIG_NO_RC4
 218 int rc4_skip(const u8 *key, size_t keylen, size_t skip,
 219              u8 *data, size_t data_len)
 220 {
 221 #ifdef OPENSSL_NO_RC4
 222         return -1;
 223 #else /* OPENSSL_NO_RC4 */
 224         EVP_CIPHER_CTX *ctx;
 225         int outl;
 226         int res = -1;
 227         unsigned char skip_buf[16];
 228
 229         ctx = EVP_CIPHER_CTX_new();
 230         if (!ctx ||
 231             !EVP_CIPHER_CTX_set_padding(ctx, 0) ||
 232             !EVP_CipherInit_ex(ctx, EVP_rc4(), NULL, NULL, NULL, 1) ||
 233             !EVP_CIPHER_CTX_set_key_length(ctx, keylen) ||
 234             !EVP_CipherInit_ex(ctx, NULL, NULL, key, NULL, 1))
 235                 goto out;
 236
 237         while (skip >= sizeof(skip_buf)) {
 238                 size_t len = skip;
 239                 if (len > sizeof(skip_buf))
 240                         len = sizeof(skip_buf);
 241                 if (!EVP_CipherUpdate(ctx, skip_buf, &outl, skip_buf, len))
 242                         goto out;
 243                 skip -= len;
 244         }
 245
 246         if (EVP_CipherUpdate(ctx, data, &outl, data, data_len))
 247                 res = 0;
 248
 249 out:
 250         if (ctx)
 251                 EVP_CIPHER_CTX_free(ctx);
 252         return res;
 253 #endif /* OPENSSL_NO_RC4 */
 254 }
 255 #endif /* CONFIG_NO_RC4 */
 256
 257
 258 #ifndef CONFIG_FIPS
 259 int md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 260 {
 261         return openssl_digest_vector(EVP_md5(), num_elem, addr, len, mac);
 262 }
 263 #endif /* CONFIG_FIPS */
 264
 265
 266 int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 267 {
 268         return openssl_digest_vector(EVP_sha1(), num_elem, addr, len, mac);
 269 }
 270
 271
 272 #ifndef NO_SHA256_WRAPPER
 273 int sha256_vector(size_t num_elem, const u8 *addr[], const size_t *len,
 274                   u8 *mac)
 275 {
 276         return openssl_digest_vector(EVP_sha256(), num_elem, addr, len, mac);
 277 }
 278 #endif /* NO_SHA256_WRAPPER */
 279
 280
 281 #ifndef NO_SHA384_WRAPPER
 282 int sha384_vector(size_t num_elem, const u8 *addr[], const size_t *len,
 283                   u8 *mac)
 284 {
 285         return openssl_digest_vector(EVP_sha384(), num_elem, addr, len, mac);
 286 }
 287 #endif /* NO_SHA384_WRAPPER */
 288
 289
 290 #ifndef NO_SHA512_WRAPPER
 291 int sha512_vector(size_t num_elem, const u8 *addr[], const size_t *len,
 292                   u8 *mac)
 293 {
 294         return openssl_digest_vector(EVP_sha512(), num_elem, addr, len, mac);
 295 }
 296 #endif /* NO_SHA512_WRAPPER */
 297
 298
 299 static const EVP_CIPHER * aes_get_evp_cipher(size_t keylen)
 300 {
 301         switch (keylen) {
 302         case 16:
 303                 return EVP_aes_128_ecb();
 304         case 24:
 305                 return EVP_aes_192_ecb();
 306         case 32:
 307                 return EVP_aes_256_ecb();
 308         }
 309
 310         return NULL;
 311 }
 312
 313
 314 void * aes_encrypt_init(const u8 *key, size_t len)
 315 {
 316         EVP_CIPHER_CTX *ctx;
 317         const EVP_CIPHER *type;
 318
 319         if (TEST_FAIL())
 320                 return NULL;
 321
 322         type = aes_get_evp_cipher(len);
 323         if (!type) {
 324                 wpa_printf(MSG_INFO, "%s: Unsupported len=%u",
 325                            __func__, (unsigned int) len);
 326                 return NULL;
 327         }
 328
 329         ctx = EVP_CIPHER_CTX_new();
 330         if (ctx == NULL)
 331                 return NULL;
 332         if (EVP_EncryptInit_ex(ctx, type, NULL, key, NULL) != 1) {
 333                 os_free(ctx);
 334                 return NULL;
 335         }
 336         EVP_CIPHER_CTX_set_padding(ctx, 0);
 337         return ctx;
 338 }
 339
 340
 341 int aes_encrypt(void *ctx, const u8 *plain, u8 *crypt)
 342 {
 343         EVP_CIPHER_CTX *c = ctx;
 344         int clen = 16;
 345         if (EVP_EncryptUpdate(c, crypt, &clen, plain, 16) != 1) {
 346                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_EncryptUpdate failed: %s",
 347                            ERR_error_string(ERR_get_error(), NULL));
 348                 return -1;
 349         }
 350         return 0;
 351 }
 352
 353
 354 void aes_encrypt_deinit(void *ctx)
 355 {
 356         EVP_CIPHER_CTX *c = ctx;
 357         u8 buf[16];
 358         int len = sizeof(buf);
 359         if (EVP_EncryptFinal_ex(c, buf, &len) != 1) {
 360                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_EncryptFinal_ex failed: "
 361                            "%s", ERR_error_string(ERR_get_error(), NULL));
 362         }
 363         if (len != 0) {
 364                 wpa_printf(MSG_ERROR, "OpenSSL: Unexpected padding length %d "
 365                            "in AES encrypt", len);
 366         }
 367         EVP_CIPHER_CTX_free(c);
 368 }
 369
 370
 371 void * aes_decrypt_init(const u8 *key, size_t len)
 372 {
 373         EVP_CIPHER_CTX *ctx;
 374         const EVP_CIPHER *type;
 375
 376         if (TEST_FAIL())
 377                 return NULL;
 378
 379         type = aes_get_evp_cipher(len);
 380         if (!type) {
 381                 wpa_printf(MSG_INFO, "%s: Unsupported len=%u",
 382                            __func__, (unsigned int) len);
 383                 return NULL;
 384         }
 385
 386         ctx = EVP_CIPHER_CTX_new();
 387         if (ctx == NULL)
 388                 return NULL;
 389         if (EVP_DecryptInit_ex(ctx, type, NULL, key, NULL) != 1) {
 390                 EVP_CIPHER_CTX_free(ctx);
 391                 return NULL;
 392         }
 393         EVP_CIPHER_CTX_set_padding(ctx, 0);
 394         return ctx;
 395 }
 396
 397
 398 int aes_decrypt(void *ctx, const u8 *crypt, u8 *plain)
 399 {
 400         EVP_CIPHER_CTX *c = ctx;
 401         int plen = 16;
 402         if (EVP_DecryptUpdate(c, plain, &plen, crypt, 16) != 1) {
 403                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_DecryptUpdate failed: %s",
 404                            ERR_error_string(ERR_get_error(), NULL));
 405                 return -1;
 406         }
 407         return 0;
 408 }
 409
 410
 411 void aes_decrypt_deinit(void *ctx)
 412 {
 413         EVP_CIPHER_CTX *c = ctx;
 414         u8 buf[16];
 415         int len = sizeof(buf);
 416         if (EVP_DecryptFinal_ex(c, buf, &len) != 1) {
 417                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_DecryptFinal_ex failed: "
 418                            "%s", ERR_error_string(ERR_get_error(), NULL));
 419         }
 420         if (len != 0) {
 421                 wpa_printf(MSG_ERROR, "OpenSSL: Unexpected padding length %d "
 422                            "in AES decrypt", len);
 423         }
 424         EVP_CIPHER_CTX_free(c);
 425 }
 426
 427
 428 #ifndef CONFIG_FIPS
 429 #ifndef CONFIG_OPENSSL_INTERNAL_AES_WRAP
 430
 431 int aes_wrap(const u8 *kek, size_t kek_len, int n, const u8 *plain, u8 *cipher)
 432 {
 433         AES_KEY actx;
 434         int res;
 435
 436         if (TEST_FAIL())
 437                 return -1;
 438         if (AES_set_encrypt_key(kek, kek_len << 3, &actx))
 439                 return -1;
 440         res = AES_wrap_key(&actx, NULL, cipher, plain, n * 8);
 441         OPENSSL_cleanse(&actx, sizeof(actx));
 442         return res <= 0 ? -1 : 0;
 443 }
 444
 445
 446 int aes_unwrap(const u8 *kek, size_t kek_len, int n, const u8 *cipher,
 447                u8 *plain)
 448 {
 449         AES_KEY actx;
 450         int res;
 451
 452         if (TEST_FAIL())
 453                 return -1;
 454         if (AES_set_decrypt_key(kek, kek_len << 3, &actx))
 455                 return -1;
 456         res = AES_unwrap_key(&actx, NULL, plain, cipher, (n + 1) * 8);
 457         OPENSSL_cleanse(&actx, sizeof(actx));
 458         return res <= 0 ? -1 : 0;
 459 }
 460
 461 #endif /* CONFIG_OPENSSL_INTERNAL_AES_WRAP */
 462 #endif /* CONFIG_FIPS */
 463
 464
 465 int aes_128_cbc_encrypt(const u8 *key, const u8 *iv, u8 *data, size_t data_len)
 466 {
 467         EVP_CIPHER_CTX *ctx;
 468         int clen, len;
 469         u8 buf[16];
 470         int res = -1;
 471
 472         if (TEST_FAIL())
 473                 return -1;
 474
 475         ctx = EVP_CIPHER_CTX_new();
 476         if (!ctx)
 477                 return -1;
 478         clen = data_len;
 479         len = sizeof(buf);
 480         if (EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv) == 1 &&
 481             EVP_CIPHER_CTX_set_padding(ctx, 0) == 1 &&
 482             EVP_EncryptUpdate(ctx, data, &clen, data, data_len) == 1 &&
 483             clen == (int) data_len &&
 484             EVP_EncryptFinal_ex(ctx, buf, &len) == 1 && len == 0)
 485                 res = 0;
 486         EVP_CIPHER_CTX_free(ctx);
 487
 488         return res;
 489 }
 490
 491
 492 int aes_128_cbc_decrypt(const u8 *key, const u8 *iv, u8 *data, size_t data_len)
 493 {
 494         EVP_CIPHER_CTX *ctx;
 495         int plen, len;
 496         u8 buf[16];
 497         int res = -1;
 498
 499         if (TEST_FAIL())
 500                 return -1;
 501
 502         ctx = EVP_CIPHER_CTX_new();
 503         if (!ctx)
 504                 return -1;
 505         plen = data_len;
 506         len = sizeof(buf);
 507         if (EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv) == 1 &&
 508             EVP_CIPHER_CTX_set_padding(ctx, 0) == 1 &&
 509             EVP_DecryptUpdate(ctx, data, &plen, data, data_len) == 1 &&
 510             plen == (int) data_len &&
 511             EVP_DecryptFinal_ex(ctx, buf, &len) == 1 && len == 0)
 512                 res = 0;
 513         EVP_CIPHER_CTX_free(ctx);
 514
 515         return res;
 516
 517 }
 518
 519
 520 int crypto_dh_init(u8 generator, const u8 *prime, size_t prime_len, u8 *privkey,
 521                    u8 *pubkey)
 522 {
 523         size_t pubkey_len, pad;
 524
 525         if (os_get_random(privkey, prime_len) < 0)
 526                 return -1;
 527         if (os_memcmp(privkey, prime, prime_len) > 0) {
 528                 /* Make sure private value is smaller than prime */
 529                 privkey[0] = 0;
 530         }
 531
 532         pubkey_len = prime_len;
 533         if (crypto_mod_exp(&generator, 1, privkey, prime_len, prime, prime_len,
 534                            pubkey, &pubkey_len) < 0)
 535                 return -1;
 536         if (pubkey_len < prime_len) {
 537                 pad = prime_len - pubkey_len;
 538                 os_memmove(pubkey + pad, pubkey, pubkey_len);
 539                 os_memset(pubkey, 0, pad);
 540         }
 541
 542         return 0;
 543 }
 544
 545
 546 int crypto_dh_derive_secret(u8 generator, const u8 *prime, size_t prime_len,
 547                             const u8 *order, size_t order_len,
 548                             const u8 *privkey, size_t privkey_len,
 549                             const u8 *pubkey, size_t pubkey_len,
 550                             u8 *secret, size_t *len)
 551 {
 552         BIGNUM *pub, *p;
 553         int res = -1;
 554
 555         pub = BN_bin2bn(pubkey, pubkey_len, NULL);
 556         p = BN_bin2bn(prime, prime_len, NULL);
 557         if (!pub || !p || BN_is_zero(pub) || BN_is_one(pub) ||
 558             BN_cmp(pub, p) >= 0)
 559                 goto fail;
 560
 561         if (order) {
 562                 BN_CTX *ctx;
 563                 BIGNUM *q, *tmp;
 564                 int failed;
 565
 566                 /* verify: pubkey^q == 1 mod p */
 567                 q = BN_bin2bn(order, order_len, NULL);
 568                 ctx = BN_CTX_new();
 569                 tmp = BN_new();
 570                 failed = !q || !ctx || !tmp ||
 571                         !BN_mod_exp(tmp, pub, q, p, ctx) ||
 572                         !BN_is_one(tmp);
 573                 BN_clear_free(q);
 574                 BN_clear_free(tmp);
 575                 BN_CTX_free(ctx);
 576                 if (failed)
 577                         goto fail;
 578         }
 579
 580         res = crypto_mod_exp(pubkey, pubkey_len, privkey, privkey_len,
 581                              prime, prime_len, secret, len);
 582 fail:
 583         BN_clear_free(pub);
 584         BN_clear_free(p);
 585         return res;
 586 }
 587
 588
 589 int crypto_mod_exp(const u8 *base, size_t base_len,
 590                    const u8 *power, size_t power_len,
 591                    const u8 *modulus, size_t modulus_len,
 592                    u8 *result, size_t *result_len)
 593 {
 594         BIGNUM *bn_base, *bn_exp, *bn_modulus, *bn_result;
 595         int ret = -1;
 596         BN_CTX *ctx;
 597
 598         ctx = BN_CTX_new();
 599         if (ctx == NULL)
 600                 return -1;
 601
 602         bn_base = BN_bin2bn(base, base_len, NULL);
 603         bn_exp = BN_bin2bn(power, power_len, NULL);
 604         bn_modulus = BN_bin2bn(modulus, modulus_len, NULL);
 605         bn_result = BN_new();
 606
 607         if (bn_base == NULL || bn_exp == NULL || bn_modulus == NULL ||
 608             bn_result == NULL)
 609                 goto error;
 610
 611         if (BN_mod_exp_mont_consttime(bn_result, bn_base, bn_exp, bn_modulus,
 612                                       ctx, NULL) != 1)
 613                 goto error;
 614
 615         *result_len = BN_bn2bin(bn_result, result);
 616         ret = 0;
 617
 618 error:
 619         BN_clear_free(bn_base);
 620         BN_clear_free(bn_exp);
 621         BN_clear_free(bn_modulus);
 622         BN_clear_free(bn_result);
 623         BN_CTX_free(ctx);
 624         return ret;
 625 }
 626
 627
 628 struct crypto_cipher {
 629         EVP_CIPHER_CTX *enc;
 630         EVP_CIPHER_CTX *dec;
 631 };
 632
 633
 634 struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg,
 635                                           const u8 *iv, const u8 *key,
 636                                           size_t key_len)
 637 {
 638         struct crypto_cipher *ctx;
 639         const EVP_CIPHER *cipher;
 640
 641         ctx = os_zalloc(sizeof(*ctx));
 642         if (ctx == NULL)
 643                 return NULL;
 644
 645         switch (alg) {
 646 #ifndef CONFIG_NO_RC4
 647 #ifndef OPENSSL_NO_RC4
 648         case CRYPTO_CIPHER_ALG_RC4:
 649                 cipher = EVP_rc4();
 650                 break;
 651 #endif /* OPENSSL_NO_RC4 */
 652 #endif /* CONFIG_NO_RC4 */
 653 #ifndef OPENSSL_NO_AES
 654         case CRYPTO_CIPHER_ALG_AES:
 655                 switch (key_len) {
 656                 case 16:
 657                         cipher = EVP_aes_128_cbc();
 658                         break;
 659 #ifndef OPENSSL_IS_BORINGSSL
 660                 case 24:
 661                         cipher = EVP_aes_192_cbc();
 662                         break;
 663 #endif /* OPENSSL_IS_BORINGSSL */
 664                 case 32:
 665                         cipher = EVP_aes_256_cbc();
 666                         break;
 667                 default:
 668                         os_free(ctx);
 669                         return NULL;
 670                 }
 671                 break;
 672 #endif /* OPENSSL_NO_AES */
 673 #ifndef OPENSSL_NO_DES
 674         case CRYPTO_CIPHER_ALG_3DES:
 675                 cipher = EVP_des_ede3_cbc();
 676                 break;
 677         case CRYPTO_CIPHER_ALG_DES:
 678                 cipher = EVP_des_cbc();
 679                 break;
 680 #endif /* OPENSSL_NO_DES */
 681 #ifndef OPENSSL_NO_RC2
 682         case CRYPTO_CIPHER_ALG_RC2:
 683                 cipher = EVP_rc2_ecb();
 684                 break;
 685 #endif /* OPENSSL_NO_RC2 */
 686         default:
 687                 os_free(ctx);
 688                 return NULL;
 689         }
 690
 691         if (!(ctx->enc = EVP_CIPHER_CTX_new()) ||
 692             !EVP_CIPHER_CTX_set_padding(ctx->enc, 0) ||
 693             !EVP_EncryptInit_ex(ctx->enc, cipher, NULL, NULL, NULL) ||
 694             !EVP_CIPHER_CTX_set_key_length(ctx->enc, key_len) ||
 695             !EVP_EncryptInit_ex(ctx->enc, NULL, NULL, key, iv)) {
 696                 if (ctx->enc)
 697                         EVP_CIPHER_CTX_free(ctx->enc);
 698                 os_free(ctx);
 699                 return NULL;
 700         }
 701
 702         if (!(ctx->dec = EVP_CIPHER_CTX_new()) ||
 703             !EVP_CIPHER_CTX_set_padding(ctx->dec, 0) ||
 704             !EVP_DecryptInit_ex(ctx->dec, cipher, NULL, NULL, NULL) ||
 705             !EVP_CIPHER_CTX_set_key_length(ctx->dec, key_len) ||
 706             !EVP_DecryptInit_ex(ctx->dec, NULL, NULL, key, iv)) {
 707                 EVP_CIPHER_CTX_free(ctx->enc);
 708                 if (ctx->dec)
 709                         EVP_CIPHER_CTX_free(ctx->dec);
 710                 os_free(ctx);
 711                 return NULL;
 712         }
 713
 714         return ctx;
 715 }
 716
 717
 718 int crypto_cipher_encrypt(struct crypto_cipher *ctx, const u8 *plain,
 719                           u8 *crypt, size_t len)
 720 {
 721         int outl;
 722         if (!EVP_EncryptUpdate(ctx->enc, crypt, &outl, plain, len))
 723                 return -1;
 724         return 0;
 725 }
 726
 727
 728 int crypto_cipher_decrypt(struct crypto_cipher *ctx, const u8 *crypt,
 729                           u8 *plain, size_t len)
 730 {
 731         int outl;
 732         outl = len;
 733         if (!EVP_DecryptUpdate(ctx->dec, plain, &outl, crypt, len))
 734                 return -1;
 735         return 0;
 736 }
 737
 738
 739 void crypto_cipher_deinit(struct crypto_cipher *ctx)
 740 {
 741         EVP_CIPHER_CTX_free(ctx->enc);
 742         EVP_CIPHER_CTX_free(ctx->dec);
 743         os_free(ctx);
 744 }
 745
 746
 747 void * dh5_init(struct wpabuf **priv, struct wpabuf **publ)
 748 {
 749 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \
 750         (defined(LIBRESSL_VERSION_NUMBER) && \
 751          LIBRESSL_VERSION_NUMBER < 0x20700000L)
 752         DH *dh;
 753         struct wpabuf *pubkey = NULL, *privkey = NULL;
 754         size_t publen, privlen;
 755
 756         *priv = NULL;
 757         wpabuf_free(*publ);
 758         *publ = NULL;
 759
 760         dh = DH_new();
 761         if (dh == NULL)
 762                 return NULL;
 763
 764         dh->g = BN_new();
 765         if (dh->g == NULL || BN_set_word(dh->g, 2) != 1)
 766                 goto err;
 767
 768         dh->p = get_group5_prime();
 769         if (dh->p == NULL)
 770                 goto err;
 771
 772         dh->q = get_group5_order();
 773         if (!dh->q)
 774                 goto err;
 775
 776         if (DH_generate_key(dh) != 1)
 777                 goto err;
 778
 779         publen = BN_num_bytes(dh->pub_key);
 780         pubkey = wpabuf_alloc(publen);
 781         if (pubkey == NULL)
 782                 goto err;
 783         privlen = BN_num_bytes(dh->priv_key);
 784         privkey = wpabuf_alloc(privlen);
 785         if (privkey == NULL)
 786                 goto err;
 787
 788         BN_bn2bin(dh->pub_key, wpabuf_put(pubkey, publen));
 789         BN_bn2bin(dh->priv_key, wpabuf_put(privkey, privlen));
 790
 791         *priv = privkey;
 792         *publ = pubkey;
 793         return dh;
 794
 795 err:
 796         wpabuf_clear_free(pubkey);
 797         wpabuf_clear_free(privkey);
 798         DH_free(dh);
 799         return NULL;
 800 #else
 801         DH *dh;
 802         struct wpabuf *pubkey = NULL, *privkey = NULL;
 803         size_t publen, privlen;
 804         BIGNUM *p, *g, *q;
 805         const BIGNUM *priv_key = NULL, *pub_key = NULL;
 806
 807         *priv = NULL;
 808         wpabuf_free(*publ);
 809         *publ = NULL;
 810
 811         dh = DH_new();
 812         if (dh == NULL)
 813                 return NULL;
 814
 815         g = BN_new();
 816         p = get_group5_prime();
 817         q = get_group5_order();
 818         if (!g || BN_set_word(g, 2) != 1 || !p || !q ||
 819             DH_set0_pqg(dh, p, q, g) != 1)
 820                 goto err;
 821         p = NULL;
 822         q = NULL;
 823         g = NULL;
 824
 825         if (DH_generate_key(dh) != 1)
 826                 goto err;
 827
 828         DH_get0_key(dh, &pub_key, &priv_key);
 829         publen = BN_num_bytes(pub_key);
 830         pubkey = wpabuf_alloc(publen);
 831         if (!pubkey)
 832                 goto err;
 833         privlen = BN_num_bytes(priv_key);
 834         privkey = wpabuf_alloc(privlen);
 835         if (!privkey)
 836                 goto err;
 837
 838         BN_bn2bin(pub_key, wpabuf_put(pubkey, publen));
 839         BN_bn2bin(priv_key, wpabuf_put(privkey, privlen));
 840
 841         *priv = privkey;
 842         *publ = pubkey;
 843         return dh;
 844
 845 err:
 846         BN_free(p);
 847         BN_free(q);
 848         BN_free(g);
 849         wpabuf_clear_free(pubkey);
 850         wpabuf_clear_free(privkey);
 851         DH_free(dh);
 852         return NULL;
 853 #endif
 854 }
 855
 856
 857 void * dh5_init_fixed(const struct wpabuf *priv, const struct wpabuf *publ)
 858 {
 859 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \
 860         (defined(LIBRESSL_VERSION_NUMBER) && \
 861          LIBRESSL_VERSION_NUMBER < 0x20700000L)
 862         DH *dh;
 863
 864         dh = DH_new();
 865         if (dh == NULL)
 866                 return NULL;
 867
 868         dh->g = BN_new();
 869         if (dh->g == NULL || BN_set_word(dh->g, 2) != 1)
 870                 goto err;
 871
 872         dh->p = get_group5_prime();
 873         if (dh->p == NULL)
 874                 goto err;
 875
 876         dh->priv_key = BN_bin2bn(wpabuf_head(priv), wpabuf_len(priv), NULL);
 877         if (dh->priv_key == NULL)
 878                 goto err;
 879
 880         dh->pub_key = BN_bin2bn(wpabuf_head(publ), wpabuf_len(publ), NULL);
 881         if (dh->pub_key == NULL)
 882                 goto err;
 883
 884         if (DH_generate_key(dh) != 1)
 885                 goto err;
 886
 887         return dh;
 888
 889 err:
 890         DH_free(dh);
 891         return NULL;
 892 #else
 893         DH *dh;
 894         BIGNUM *p = NULL, *g, *priv_key = NULL, *pub_key = NULL;
 895
 896         dh = DH_new();
 897         if (dh == NULL)
 898                 return NULL;
 899
 900         g = BN_new();
 901         p = get_group5_prime();
 902         if (!g || BN_set_word(g, 2) != 1 || !p ||
 903             DH_set0_pqg(dh, p, NULL, g) != 1)
 904                 goto err;
 905         p = NULL;
 906         g = NULL;
 907
 908         priv_key = BN_bin2bn(wpabuf_head(priv), wpabuf_len(priv), NULL);
 909         pub_key = BN_bin2bn(wpabuf_head(publ), wpabuf_len(publ), NULL);
 910         if (!priv_key || !pub_key || DH_set0_key(dh, pub_key, priv_key) != 1)
 911                 goto err;
 912         pub_key = NULL;
 913         priv_key = NULL;
 914
 915         if (DH_generate_key(dh) != 1)
 916                 goto err;
 917
 918         return dh;
 919
 920 err:
 921         BN_free(p);
 922         BN_free(g);
 923         BN_free(pub_key);
 924         BN_clear_free(priv_key);
 925         DH_free(dh);
 926         return NULL;
 927 #endif
 928 }
 929
 930
 931 struct wpabuf * dh5_derive_shared(void *ctx, const struct wpabuf *peer_public,
 932                                   const struct wpabuf *own_private)
 933 {
 934         BIGNUM *pub_key;
 935         struct wpabuf *res = NULL;
 936         size_t rlen;
 937         DH *dh = ctx;
 938         int keylen;
 939
 940         if (ctx == NULL)
 941                 return NULL;
 942
 943         pub_key = BN_bin2bn(wpabuf_head(peer_public), wpabuf_len(peer_public),
 944                             NULL);
 945         if (pub_key == NULL)
 946                 return NULL;
 947
 948         rlen = DH_size(dh);
 949         res = wpabuf_alloc(rlen);
 950         if (res == NULL)
 951                 goto err;
 952
 953         keylen = DH_compute_key(wpabuf_mhead(res), pub_key, dh);
 954         if (keylen < 0)
 955                 goto err;
 956         wpabuf_put(res, keylen);
 957         BN_clear_free(pub_key);
 958
 959         return res;
 960
 961 err:
 962         BN_clear_free(pub_key);
 963         wpabuf_clear_free(res);
 964         return NULL;
 965 }
 966
 967
 968 void dh5_free(void *ctx)
 969 {
 970         DH *dh;
 971         if (ctx == NULL)
 972                 return;
 973         dh = ctx;
 974         DH_free(dh);
 975 }
 976
 977
 978 struct crypto_hash {
 979         HMAC_CTX *ctx;
 980 };
 981
 982
 983 struct crypto_hash * crypto_hash_init(enum crypto_hash_alg alg, const u8 *key,
 984                                       size_t key_len)
 985 {
 986         struct crypto_hash *ctx;
 987         const EVP_MD *md;
 988
 989         switch (alg) {
 990 #ifndef OPENSSL_NO_MD5
 991         case CRYPTO_HASH_ALG_HMAC_MD5:
 992                 md = EVP_md5();
 993                 break;
 994 #endif /* OPENSSL_NO_MD5 */
 995 #ifndef OPENSSL_NO_SHA
 996         case CRYPTO_HASH_ALG_HMAC_SHA1:
 997                 md = EVP_sha1();
 998                 break;
 999 #endif /* OPENSSL_NO_SHA */
1000 #ifndef OPENSSL_NO_SHA256
1001 #ifdef CONFIG_SHA256
1002         case CRYPTO_HASH_ALG_HMAC_SHA256:
1003                 md = EVP_sha256();
1004                 break;
1005 #endif /* CONFIG_SHA256 */
1006 #endif /* OPENSSL_NO_SHA256 */
1007         default:
1008                 return NULL;
1009         }
1010
1011         ctx = os_zalloc(sizeof(*ctx));
1012         if (ctx == NULL)
1013                 return NULL;
1014         ctx->ctx = HMAC_CTX_new();
1015         if (!ctx->ctx) {
1016                 os_free(ctx);
1017                 return NULL;
1018         }
1019
1020         if (HMAC_Init_ex(ctx->ctx, key, key_len, md, NULL) != 1) {
1021                 HMAC_CTX_free(ctx->ctx);
1022                 bin_clear_free(ctx, sizeof(*ctx));
1023                 return NULL;
1024         }
1025
1026         return ctx;
1027 }
1028
1029
1030 void crypto_hash_update(struct crypto_hash *ctx, const u8 *data, size_t len)
1031 {
1032         if (ctx == NULL)
1033                 return;
1034         HMAC_Update(ctx->ctx, data, len);
1035 }
1036
1037
1038 int crypto_hash_finish(struct crypto_hash *ctx, u8 *mac, size_t *len)
1039 {
1040         unsigned int mdlen;
1041         int res;
1042
1043         if (ctx == NULL)
1044                 return -2;
1045
1046         if (mac == NULL || len == NULL) {
1047                 HMAC_CTX_free(ctx->ctx);
1048                 bin_clear_free(ctx, sizeof(*ctx));
1049                 return 0;
1050         }
1051
1052         mdlen = *len;
1053         res = HMAC_Final(ctx->ctx, mac, &mdlen);
1054         HMAC_CTX_free(ctx->ctx);
1055         bin_clear_free(ctx, sizeof(*ctx));
1056
1057         if (TEST_FAIL())
1058                 return -1;
1059
1060         if (res == 1) {
1061                 *len = mdlen;
1062                 return 0;
1063         }
1064
1065         return -1;
1066 }
1067
1068
1069 static int openssl_hmac_vector(const EVP_MD *type, const u8 *key,
1070                                size_t key_len, size_t num_elem,
1071                                const u8 *addr[], const size_t *len, u8 *mac,
1072                                unsigned int mdlen)
1073 {
1074         HMAC_CTX *ctx;
1075         size_t i;
1076         int res;
1077
1078         if (TEST_FAIL())
1079                 return -1;
1080
1081         ctx = HMAC_CTX_new();
1082         if (!ctx)
1083                 return -1;
1084         res = HMAC_Init_ex(ctx, key, key_len, type, NULL);
1085         if (res != 1)
1086                 goto done;
1087
1088         for (i = 0; i < num_elem; i++)
1089                 HMAC_Update(ctx, addr[i], len[i]);
1090
1091         res = HMAC_Final(ctx, mac, &mdlen);
1092 done:
1093         HMAC_CTX_free(ctx);
1094
1095         return res == 1 ? 0 : -1;
1096 }
1097
1098
1099 #ifndef CONFIG_FIPS
1100
1101 int hmac_md5_vector(const u8 *key, size_t key_len, size_t num_elem,
1102                     const u8 *addr[], const size_t *len, u8 *mac)
1103 {
1104         return openssl_hmac_vector(EVP_md5(), key ,key_len, num_elem, addr, len,
1105                                    mac, 16);
1106 }
1107
1108
1109 int hmac_md5(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
1110              u8 *mac)
1111 {
1112         return hmac_md5_vector(key, key_len, 1, &data, &data_len, mac);
1113 }
1114
1115 #endif /* CONFIG_FIPS */
1116
1117
1118 int pbkdf2_sha1(const char *passphrase, const u8 *ssid, size_t ssid_len,
1119                 int iterations, u8 *buf, size_t buflen)
1120 {
1121         if (PKCS5_PBKDF2_HMAC_SHA1(passphrase, os_strlen(passphrase), ssid,
1122                                    ssid_len, iterations, buflen, buf) != 1)
1123                 return -1;
1124         return 0;
1125 }
1126
1127
1128 int hmac_sha1_vector(const u8 *key, size_t key_len, size_t num_elem,
1129                      const u8 *addr[], const size_t *len, u8 *mac)
1130 {
1131         return openssl_hmac_vector(EVP_sha1(), key, key_len, num_elem, addr,
1132                                    len, mac, 20);
1133 }
1134
1135
1136 int hmac_sha1(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
1137                u8 *mac)
1138 {
1139         return hmac_sha1_vector(key, key_len, 1, &data, &data_len, mac);
1140 }
1141
1142
1143 #ifdef CONFIG_SHA256
1144
1145 int hmac_sha256_vector(const u8 *key, size_t key_len, size_t num_elem,
1146                        const u8 *addr[], const size_t *len, u8 *mac)
1147 {
1148         return openssl_hmac_vector(EVP_sha256(), key, key_len, num_elem, addr,
1149                                    len, mac, 32);
1150 }
1151
1152
1153 int hmac_sha256(const u8 *key, size_t key_len, const u8 *data,
1154                 size_t data_len, u8 *mac)
1155 {
1156         return hmac_sha256_vector(key, key_len, 1, &data, &data_len, mac);
1157 }
1158
1159 #endif /* CONFIG_SHA256 */
1160
1161
1162 #ifdef CONFIG_SHA384
1163
1164 int hmac_sha384_vector(const u8 *key, size_t key_len, size_t num_elem,
1165                        const u8 *addr[], const size_t *len, u8 *mac)
1166 {
1167         return openssl_hmac_vector(EVP_sha384(), key, key_len, num_elem, addr,
1168                                    len, mac, 48);
1169 }
1170
1171
1172 int hmac_sha384(const u8 *key, size_t key_len, const u8 *data,
1173                 size_t data_len, u8 *mac)
1174 {
1175         return hmac_sha384_vector(key, key_len, 1, &data, &data_len, mac);
1176 }
1177
1178 #endif /* CONFIG_SHA384 */
1179
1180
1181 #ifdef CONFIG_SHA512
1182
1183 int hmac_sha512_vector(const u8 *key, size_t key_len, size_t num_elem,
1184                        const u8 *addr[], const size_t *len, u8 *mac)
1185 {
1186         return openssl_hmac_vector(EVP_sha512(), key, key_len, num_elem, addr,
1187                                    len, mac, 64);
1188 }
1189
1190
1191 int hmac_sha512(const u8 *key, size_t key_len, const u8 *data,
1192                 size_t data_len, u8 *mac)
1193 {
1194         return hmac_sha512_vector(key, key_len, 1, &data, &data_len, mac);
1195 }
1196
1197 #endif /* CONFIG_SHA512 */
1198
1199
1200 int crypto_get_random(void *buf, size_t len)
1201 {
1202         if (RAND_bytes(buf, len) != 1)
1203                 return -1;
1204         return 0;
1205 }
1206
1207
1208 #ifdef CONFIG_OPENSSL_CMAC
1209 int omac1_aes_vector(const u8 *key, size_t key_len, size_t num_elem,
1210                      const u8 *addr[], const size_t *len, u8 *mac)
1211 {
1212         CMAC_CTX *ctx;
1213         int ret = -1;
1214         size_t outlen, i;
1215
1216         if (TEST_FAIL())
1217                 return -1;
1218
1219         ctx = CMAC_CTX_new();
1220         if (ctx == NULL)
1221                 return -1;
1222
1223         if (key_len == 32) {
1224                 if (!CMAC_Init(ctx, key, 32, EVP_aes_256_cbc(), NULL))
1225                         goto fail;
1226         } else if (key_len == 16) {
1227                 if (!CMAC_Init(ctx, key, 16, EVP_aes_128_cbc(), NULL))
1228                         goto fail;
1229         } else {
1230                 goto fail;
1231         }
1232         for (i = 0; i < num_elem; i++) {
1233                 if (!CMAC_Update(ctx, addr[i], len[i]))
1234                         goto fail;
1235         }
1236         if (!CMAC_Final(ctx, mac, &outlen) || outlen != 16)
1237                 goto fail;
1238
1239         ret = 0;
1240 fail:
1241         CMAC_CTX_free(ctx);
1242         return ret;
1243 }
1244
1245
1246 int omac1_aes_128_vector(const u8 *key, size_t num_elem,
1247                          const u8 *addr[], const size_t *len, u8 *mac)
1248 {
1249         return omac1_aes_vector(key, 16, num_elem, addr, len, mac);
1250 }
1251
1252
1253 int omac1_aes_128(const u8 *key, const u8 *data, size_t data_len, u8 *mac)
1254 {
1255         return omac1_aes_128_vector(key, 1, &data, &data_len, mac);
1256 }
1257
1258
1259 int omac1_aes_256(const u8 *key, const u8 *data, size_t data_len, u8 *mac)
1260 {
1261         return omac1_aes_vector(key, 32, 1, &data, &data_len, mac);
1262 }
1263 #endif /* CONFIG_OPENSSL_CMAC */
1264
1265
1266 struct crypto_bignum * crypto_bignum_init(void)
1267 {
1268         if (TEST_FAIL())
1269                 return NULL;
1270         return (struct crypto_bignum *) BN_new();
1271 }
1272
1273
1274 struct crypto_bignum * crypto_bignum_init_set(const u8 *buf, size_t len)
1275 {
1276         BIGNUM *bn;
1277
1278         if (TEST_FAIL())
1279                 return NULL;
1280
1281         bn = BN_bin2bn(buf, len, NULL);
1282         return (struct crypto_bignum *) bn;
1283 }
1284
1285
1286 void crypto_bignum_deinit(struct crypto_bignum *n, int clear)
1287 {
1288         if (clear)
1289                 BN_clear_free((BIGNUM *) n);
1290         else
1291                 BN_free((BIGNUM *) n);
1292 }
1293
1294
1295 int crypto_bignum_to_bin(const struct crypto_bignum *a,
1296                          u8 *buf, size_t buflen, size_t padlen)
1297 {
1298         int num_bytes, offset;
1299
1300         if (TEST_FAIL())
1301                 return -1;
1302
1303         if (padlen > buflen)
1304                 return -1;
1305
1306         if (padlen) {
1307 #ifdef OPENSSL_IS_BORINGSSL
1308                 if (BN_bn2bin_padded(buf, padlen, (const BIGNUM *) a) == 0)
1309                         return -1;
1310                 return padlen;
1311 #else /* OPENSSL_IS_BORINGSSL */
1312 #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
1313                 return BN_bn2binpad((const BIGNUM *) a, buf, padlen);
1314 #endif
1315 #endif
1316         }
1317
1318         num_bytes = BN_num_bytes((const BIGNUM *) a);
1319         if ((size_t) num_bytes > buflen)
1320                 return -1;
1321         if (padlen > (size_t) num_bytes)
1322                 offset = padlen - num_bytes;
1323         else
1324                 offset = 0;
1325
1326         os_memset(buf, 0, offset);
1327         BN_bn2bin((const BIGNUM *) a, buf + offset);
1328
1329         return num_bytes + offset;
1330 }
1331
1332
1333 int crypto_bignum_rand(struct crypto_bignum *r, const struct crypto_bignum *m)
1334 {
1335         if (TEST_FAIL())
1336                 return -1;
1337         return BN_rand_range((BIGNUM *) r, (const BIGNUM *) m) == 1 ? 0 : -1;
1338 }
1339
1340
1341 int crypto_bignum_add(const struct crypto_bignum *a,
1342                       const struct crypto_bignum *b,
1343                       struct crypto_bignum *c)
1344 {
1345         return BN_add((BIGNUM *) c, (const BIGNUM *) a, (const BIGNUM *) b) ?
1346                 0 : -1;
1347 }
1348
1349
1350 int crypto_bignum_mod(const struct crypto_bignum *a,
1351                       const struct crypto_bignum *b,
1352                       struct crypto_bignum *c)
1353 {
1354         int res;
1355         BN_CTX *bnctx;
1356
1357         bnctx = BN_CTX_new();
1358         if (bnctx == NULL)
1359                 return -1;
1360         res = BN_mod((BIGNUM *) c, (const BIGNUM *) a, (const BIGNUM *) b,
1361                      bnctx);
1362         BN_CTX_free(bnctx);
1363
1364         return res ? 0 : -1;
1365 }
1366
1367
1368 int crypto_bignum_exptmod(const struct crypto_bignum *a,
1369                           const struct crypto_bignum *b,
1370                           const struct crypto_bignum *c,
1371                           struct crypto_bignum *d)
1372 {
1373         int res;
1374         BN_CTX *bnctx;
1375
1376         if (TEST_FAIL())
1377                 return -1;
1378
1379         bnctx = BN_CTX_new();
1380         if (bnctx == NULL)
1381                 return -1;
1382         res = BN_mod_exp_mont_consttime((BIGNUM *) d, (const BIGNUM *) a,
1383                                         (const BIGNUM *) b, (const BIGNUM *) c,
1384                                         bnctx, NULL);
1385         BN_CTX_free(bnctx);
1386
1387         return res ? 0 : -1;
1388 }
1389
1390
1391 int crypto_bignum_inverse(const struct crypto_bignum *a,
1392                           const struct crypto_bignum *b,
1393                           struct crypto_bignum *c)
1394 {
1395         BIGNUM *res;
1396         BN_CTX *bnctx;
1397
1398         if (TEST_FAIL())
1399                 return -1;
1400         bnctx = BN_CTX_new();
1401         if (bnctx == NULL)
1402                 return -1;
1403 #ifdef OPENSSL_IS_BORINGSSL
1404         /* TODO: use BN_mod_inverse_blinded() ? */
1405 #else /* OPENSSL_IS_BORINGSSL */
1406         BN_set_flags((BIGNUM *) a, BN_FLG_CONSTTIME);
1407 #endif /* OPENSSL_IS_BORINGSSL */
1408         res = BN_mod_inverse((BIGNUM *) c, (const BIGNUM *) a,
1409                              (const BIGNUM *) b, bnctx);
1410         BN_CTX_free(bnctx);
1411
1412         return res ? 0 : -1;
1413 }
1414
1415
1416 int crypto_bignum_sub(const struct crypto_bignum *a,
1417                       const struct crypto_bignum *b,
1418                       struct crypto_bignum *c)
1419 {
1420         if (TEST_FAIL())
1421                 return -1;
1422         return BN_sub((BIGNUM *) c, (const BIGNUM *) a, (const BIGNUM *) b) ?
1423                 0 : -1;
1424 }
1425
1426
1427 int crypto_bignum_div(const struct crypto_bignum *a,
1428                       const struct crypto_bignum *b,
1429                       struct crypto_bignum *c)
1430 {
1431         int res;
1432
1433         BN_CTX *bnctx;
1434
1435         if (TEST_FAIL())
1436                 return -1;
1437
1438         bnctx = BN_CTX_new();
1439         if (bnctx == NULL)
1440                 return -1;
1441 #ifndef OPENSSL_IS_BORINGSSL
1442         BN_set_flags((BIGNUM *) a, BN_FLG_CONSTTIME);
1443 #endif /* OPENSSL_IS_BORINGSSL */
1444         res = BN_div((BIGNUM *) c, NULL, (const BIGNUM *) a,
1445                      (const BIGNUM *) b, bnctx);
1446         BN_CTX_free(bnctx);
1447
1448         return res ? 0 : -1;
1449 }
1450
1451
1452 int crypto_bignum_mulmod(const struct crypto_bignum *a,
1453                          const struct crypto_bignum *b,
1454                          const struct crypto_bignum *c,
1455                          struct crypto_bignum *d)
1456 {
1457         int res;
1458
1459         BN_CTX *bnctx;
1460
1461         if (TEST_FAIL())
1462                 return -1;
1463
1464         bnctx = BN_CTX_new();
1465         if (bnctx == NULL)
1466                 return -1;
1467         res = BN_mod_mul((BIGNUM *) d, (const BIGNUM *) a, (const BIGNUM *) b,
1468                          (const BIGNUM *) c, bnctx);
1469         BN_CTX_free(bnctx);
1470
1471         return res ? 0 : -1;
1472 }
1473
1474
1475 int crypto_bignum_rshift(const struct crypto_bignum *a, int n,
1476                          struct crypto_bignum *r)
1477 {
1478         /* Note: BN_rshift() does not modify the first argument even though it
1479          * has not been marked const. */
1480         return BN_rshift((BIGNUM *) a, (BIGNUM *) r, n) == 1 ? 0 : -1;
1481 }
1482
1483
1484 int crypto_bignum_cmp(const struct crypto_bignum *a,
1485                       const struct crypto_bignum *b)
1486 {
1487         return BN_cmp((const BIGNUM *) a, (const BIGNUM *) b);
1488 }
1489
1490
1491 int crypto_bignum_is_zero(const struct crypto_bignum *a)
1492 {
1493         return BN_is_zero((const BIGNUM *) a);
1494 }
1495
1496
1497 int crypto_bignum_is_one(const struct crypto_bignum *a)
1498 {
1499         return BN_is_one((const BIGNUM *) a);
1500 }
1501
1502
1503 int crypto_bignum_is_odd(const struct crypto_bignum *a)
1504 {
1505         return BN_is_odd((const BIGNUM *) a);
1506 }
1507
1508
1509 int crypto_bignum_legendre(const struct crypto_bignum *a,
1510                            const struct crypto_bignum *p)
1511 {
1512         BN_CTX *bnctx;
1513         BIGNUM *exp = NULL, *tmp = NULL;
1514         int res = -2;
1515         unsigned int mask;
1516
1517         if (TEST_FAIL())
1518                 return -2;
1519
1520         bnctx = BN_CTX_new();
1521         if (bnctx == NULL)
1522                 return -2;
1523
1524         exp = BN_new();
1525         tmp = BN_new();
1526         if (!exp || !tmp ||
1527             /* exp = (p-1) / 2 */
1528             !BN_sub(exp, (const BIGNUM *) p, BN_value_one()) ||
1529             !BN_rshift1(exp, exp) ||
1530             !BN_mod_exp_mont_consttime(tmp, (const BIGNUM *) a, exp,
1531                                        (const BIGNUM *) p, bnctx, NULL))
1532                 goto fail;
1533
1534         /* Return 1 if tmp == 1, 0 if tmp == 0, or -1 otherwise. Need to use
1535          * constant time selection to avoid branches here. */
1536         res = -1;
1537         mask = const_time_eq(BN_is_word(tmp, 1), 1);
1538         res = const_time_select_int(mask, 1, res);
1539         mask = const_time_eq(BN_is_zero(tmp), 1);
1540         res = const_time_select_int(mask, 0, res);
1541
1542 fail:
1543         BN_clear_free(tmp);
1544         BN_clear_free(exp);
1545         BN_CTX_free(bnctx);
1546         return res;
1547 }
1548
1549
1550 #ifdef CONFIG_ECC
1551
1552 struct crypto_ec {
1553         EC_GROUP *group;
1554         int nid;
1555         BN_CTX *bnctx;
1556         BIGNUM *prime;
1557         BIGNUM *order;
1558         BIGNUM *a;
1559         BIGNUM *b;
1560 };
1561
1562 struct crypto_ec * crypto_ec_init(int group)
1563 {
1564         struct crypto_ec *e;
1565         int nid;
1566
1567         /* Map from IANA registry for IKE D-H groups to OpenSSL NID */
1568         switch (group) {
1569         case 19:
1570                 nid = NID_X9_62_prime256v1;
1571                 break;
1572         case 20:
1573                 nid = NID_secp384r1;
1574                 break;
1575         case 21:
1576                 nid = NID_secp521r1;
1577                 break;
1578         case 25:
1579                 nid = NID_X9_62_prime192v1;
1580                 break;
1581         case 26:
1582                 nid = NID_secp224r1;
1583                 break;
1584 #ifdef NID_brainpoolP224r1
1585         case 27:
1586                 nid = NID_brainpoolP224r1;
1587                 break;
1588 #endif /* NID_brainpoolP224r1 */
1589 #ifdef NID_brainpoolP256r1
1590         case 28:
1591                 nid = NID_brainpoolP256r1;
1592                 break;
1593 #endif /* NID_brainpoolP256r1 */
1594 #ifdef NID_brainpoolP384r1
1595         case 29:
1596                 nid = NID_brainpoolP384r1;
1597                 break;
1598 #endif /* NID_brainpoolP384r1 */
1599 #ifdef NID_brainpoolP512r1
1600         case 30:
1601                 nid = NID_brainpoolP512r1;
1602                 break;
1603 #endif /* NID_brainpoolP512r1 */
1604         default:
1605                 return NULL;
1606         }
1607
1608         e = os_zalloc(sizeof(*e));
1609         if (e == NULL)
1610                 return NULL;
1611
1612         e->nid = nid;
1613         e->bnctx = BN_CTX_new();
1614         e->group = EC_GROUP_new_by_curve_name(nid);
1615         e->prime = BN_new();
1616         e->order = BN_new();
1617         e->a = BN_new();
1618         e->b = BN_new();
1619         if (e->group == NULL || e->bnctx == NULL || e->prime == NULL ||
1620             e->order == NULL || e->a == NULL || e->b == NULL ||
1621             !EC_GROUP_get_curve_GFp(e->group, e->prime, e->a, e->b, e->bnctx) ||
1622             !EC_GROUP_get_order(e->group, e->order, e->bnctx)) {
1623                 crypto_ec_deinit(e);
1624                 e = NULL;
1625         }
1626
1627         return e;
1628 }
1629
1630
1631 void crypto_ec_deinit(struct crypto_ec *e)
1632 {
1633         if (e == NULL)
1634                 return;
1635         BN_clear_free(e->b);
1636         BN_clear_free(e->a);
1637         BN_clear_free(e->order);
1638         BN_clear_free(e->prime);
1639         EC_GROUP_free(e->group);
1640         BN_CTX_free(e->bnctx);
1641         os_free(e);
1642 }
1643
1644
1645 struct crypto_ec_point * crypto_ec_point_init(struct crypto_ec *e)
1646 {
1647         if (TEST_FAIL())
1648                 return NULL;
1649         if (e == NULL)
1650                 return NULL;
1651         return (struct crypto_ec_point *) EC_POINT_new(e->group);
1652 }
1653
1654
1655 size_t crypto_ec_prime_len(struct crypto_ec *e)
1656 {
1657         return BN_num_bytes(e->prime);
1658 }
1659
1660
1661 size_t crypto_ec_prime_len_bits(struct crypto_ec *e)
1662 {
1663         return BN_num_bits(e->prime);
1664 }
1665
1666
1667 size_t crypto_ec_order_len(struct crypto_ec *e)
1668 {
1669         return BN_num_bytes(e->order);
1670 }
1671
1672
1673 const struct crypto_bignum * crypto_ec_get_prime(struct crypto_ec *e)
1674 {
1675         return (const struct crypto_bignum *) e->prime;
1676 }
1677
1678
1679 const struct crypto_bignum * crypto_ec_get_order(struct crypto_ec *e)
1680 {
1681         return (const struct crypto_bignum *) e->order;
1682 }
1683
1684
1685 void crypto_ec_point_deinit(struct crypto_ec_point *p, int clear)
1686 {
1687         if (clear)
1688                 EC_POINT_clear_free((EC_POINT *) p);
1689         else
1690                 EC_POINT_free((EC_POINT *) p);
1691 }
1692
1693
1694 int crypto_ec_point_x(struct crypto_ec *e, const struct crypto_ec_point *p,
1695                       struct crypto_bignum *x)
1696 {
1697         return EC_POINT_get_affine_coordinates_GFp(e->group,
1698                                                    (const EC_POINT *) p,
1699                                                    (BIGNUM *) x, NULL,
1700                                                    e->bnctx) == 1 ? 0 : -1;
1701 }
1702
1703
1704 int crypto_ec_point_to_bin(struct crypto_ec *e,
1705                            const struct crypto_ec_point *point, u8 *x, u8 *y)
1706 {
1707         BIGNUM *x_bn, *y_bn;
1708         int ret = -1;
1709         int len = BN_num_bytes(e->prime);
1710
1711         if (TEST_FAIL())
1712                 return -1;
1713
1714         x_bn = BN_new();
1715         y_bn = BN_new();
1716
1717         if (x_bn && y_bn &&
1718             EC_POINT_get_affine_coordinates_GFp(e->group, (EC_POINT *) point,
1719                                                 x_bn, y_bn, e->bnctx)) {
1720                 if (x) {
1721                         crypto_bignum_to_bin((struct crypto_bignum *) x_bn,
1722                                              x, len, len);
1723                 }
1724                 if (y) {
1725                         crypto_bignum_to_bin((struct crypto_bignum *) y_bn,
1726                                              y, len, len);
1727                 }
1728                 ret = 0;
1729         }
1730
1731         BN_clear_free(x_bn);
1732         BN_clear_free(y_bn);
1733         return ret;
1734 }
1735
1736
1737 struct crypto_ec_point * crypto_ec_point_from_bin(struct crypto_ec *e,
1738                                                   const u8 *val)
1739 {
1740         BIGNUM *x, *y;
1741         EC_POINT *elem;
1742         int len = BN_num_bytes(e->prime);
1743
1744         if (TEST_FAIL())
1745                 return NULL;
1746
1747         x = BN_bin2bn(val, len, NULL);
1748         y = BN_bin2bn(val + len, len, NULL);
1749         elem = EC_POINT_new(e->group);
1750         if (x == NULL || y == NULL || elem == NULL) {
1751                 BN_clear_free(x);
1752                 BN_clear_free(y);
1753                 EC_POINT_clear_free(elem);
1754                 return NULL;
1755         }
1756
1757         if (!EC_POINT_set_affine_coordinates_GFp(e->group, elem, x, y,
1758                                                  e->bnctx)) {
1759                 EC_POINT_clear_free(elem);
1760                 elem = NULL;
1761         }
1762
1763         BN_clear_free(x);
1764         BN_clear_free(y);
1765
1766         return (struct crypto_ec_point *) elem;
1767 }
1768
1769
1770 int crypto_ec_point_add(struct crypto_ec *e, const struct crypto_ec_point *a,
1771                         const struct crypto_ec_point *b,
1772                         struct crypto_ec_point *c)
1773 {
1774         if (TEST_FAIL())
1775                 return -1;
1776         return EC_POINT_add(e->group, (EC_POINT *) c, (const EC_POINT *) a,
1777                             (const EC_POINT *) b, e->bnctx) ? 0 : -1;
1778 }
1779
1780
1781 int crypto_ec_point_mul(struct crypto_ec *e, const struct crypto_ec_point *p,
1782                         const struct crypto_bignum *b,
1783                         struct crypto_ec_point *res)
1784 {
1785         if (TEST_FAIL())
1786                 return -1;
1787         return EC_POINT_mul(e->group, (EC_POINT *) res, NULL,
1788                             (const EC_POINT *) p, (const BIGNUM *) b, e->bnctx)
1789                 ? 0 : -1;
1790 }
1791
1792
1793 int crypto_ec_point_invert(struct crypto_ec *e, struct crypto_ec_point *p)
1794 {
1795         if (TEST_FAIL())
1796                 return -1;
1797         return EC_POINT_invert(e->group, (EC_POINT *) p, e->bnctx) ? 0 : -1;
1798 }
1799
1800
1801 int crypto_ec_point_solve_y_coord(struct crypto_ec *e,
1802                                   struct crypto_ec_point *p,
1803                                   const struct crypto_bignum *x, int y_bit)
1804 {
1805         if (TEST_FAIL())
1806                 return -1;
1807         if (!EC_POINT_set_compressed_coordinates_GFp(e->group, (EC_POINT *) p,
1808                                                      (const BIGNUM *) x, y_bit,
1809                                                      e->bnctx) ||
1810             !EC_POINT_is_on_curve(e->group, (EC_POINT *) p, e->bnctx))
1811                 return -1;
1812         return 0;
1813 }
1814
1815
1816 struct crypto_bignum *
1817 crypto_ec_point_compute_y_sqr(struct crypto_ec *e,
1818                               const struct crypto_bignum *x)
1819 {
1820         BIGNUM *tmp, *tmp2, *y_sqr = NULL;
1821
1822         if (TEST_FAIL())
1823                 return NULL;
1824
1825         tmp = BN_new();
1826         tmp2 = BN_new();
1827
1828         /* y^2 = x^3 + ax + b */
1829         if (tmp && tmp2 &&
1830             BN_mod_sqr(tmp, (const BIGNUM *) x, e->prime, e->bnctx) &&
1831             BN_mod_mul(tmp, tmp, (const BIGNUM *) x, e->prime, e->bnctx) &&
1832             BN_mod_mul(tmp2, e->a, (const BIGNUM *) x, e->prime, e->bnctx) &&
1833             BN_mod_add_quick(tmp2, tmp2, tmp, e->prime) &&
1834             BN_mod_add_quick(tmp2, tmp2, e->b, e->prime)) {
1835                 y_sqr = tmp2;
1836                 tmp2 = NULL;
1837         }
1838
1839         BN_clear_free(tmp);
1840         BN_clear_free(tmp2);
1841
1842         return (struct crypto_bignum *) y_sqr;
1843 }
1844
1845
1846 int crypto_ec_point_is_at_infinity(struct crypto_ec *e,
1847                                    const struct crypto_ec_point *p)
1848 {
1849         return EC_POINT_is_at_infinity(e->group, (const EC_POINT *) p);
1850 }
1851
1852
1853 int crypto_ec_point_is_on_curve(struct crypto_ec *e,
1854                                 const struct crypto_ec_point *p)
1855 {
1856         return EC_POINT_is_on_curve(e->group, (const EC_POINT *) p,
1857                                     e->bnctx) == 1;
1858 }
1859
1860
1861 int crypto_ec_point_cmp(const struct crypto_ec *e,
1862                         const struct crypto_ec_point *a,
1863                         const struct crypto_ec_point *b)
1864 {
1865         return EC_POINT_cmp(e->group, (const EC_POINT *) a,
1866                             (const EC_POINT *) b, e->bnctx);
1867 }
1868
1869
1870 struct crypto_ecdh {
1871         struct crypto_ec *ec;
1872         EVP_PKEY *pkey;
1873 };
1874
1875 struct crypto_ecdh * crypto_ecdh_init(int group)
1876 {
1877         struct crypto_ecdh *ecdh;
1878         EVP_PKEY *params = NULL;
1879         EC_KEY *ec_params = NULL;
1880         EVP_PKEY_CTX *kctx = NULL;
1881
1882         ecdh = os_zalloc(sizeof(*ecdh));
1883         if (!ecdh)
1884                 goto fail;
1885
1886         ecdh->ec = crypto_ec_init(group);
1887         if (!ecdh->ec)
1888                 goto fail;
1889
1890         ec_params = EC_KEY_new_by_curve_name(ecdh->ec->nid);
1891         if (!ec_params) {
1892                 wpa_printf(MSG_ERROR,
1893                            "OpenSSL: Failed to generate EC_KEY parameters");
1894                 goto fail;
1895         }
1896         EC_KEY_set_asn1_flag(ec_params, OPENSSL_EC_NAMED_CURVE);
1897         params = EVP_PKEY_new();
1898         if (!params || EVP_PKEY_set1_EC_KEY(params, ec_params) != 1) {
1899                 wpa_printf(MSG_ERROR,
1900                            "OpenSSL: Failed to generate EVP_PKEY parameters");
1901                 goto fail;
1902         }
1903
1904         kctx = EVP_PKEY_CTX_new(params, NULL);
1905         if (!kctx)
1906                 goto fail;
1907
1908         if (EVP_PKEY_keygen_init(kctx) != 1) {
1909                 wpa_printf(MSG_ERROR,
1910                            "OpenSSL: EVP_PKEY_keygen_init failed: %s",
1911                            ERR_error_string(ERR_get_error(), NULL));
1912                 goto fail;
1913         }
1914
1915         if (EVP_PKEY_keygen(kctx, &ecdh->pkey) != 1) {
1916                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_PKEY_keygen failed: %s",
1917                            ERR_error_string(ERR_get_error(), NULL));
1918                 goto fail;
1919         }
1920
1921 done:
1922         EC_KEY_free(ec_params);
1923         EVP_PKEY_free(params);
1924         EVP_PKEY_CTX_free(kctx);
1925
1926         return ecdh;
1927 fail:
1928         crypto_ecdh_deinit(ecdh);
1929         ecdh = NULL;
1930         goto done;
1931 }
1932
1933
1934 struct wpabuf * crypto_ecdh_get_pubkey(struct crypto_ecdh *ecdh, int inc_y)
1935 {
1936         struct wpabuf *buf = NULL;
1937         EC_KEY *eckey;
1938         const EC_POINT *pubkey;
1939         BIGNUM *x, *y = NULL;
1940         int len = BN_num_bytes(ecdh->ec->prime);
1941         int res;
1942
1943         eckey = EVP_PKEY_get1_EC_KEY(ecdh->pkey);
1944         if (!eckey)
1945                 return NULL;
1946
1947         pubkey = EC_KEY_get0_public_key(eckey);
1948         if (!pubkey)
1949                 return NULL;
1950
1951         x = BN_new();
1952         if (inc_y) {
1953                 y = BN_new();
1954                 if (!y)
1955                         goto fail;
1956         }
1957         buf = wpabuf_alloc(inc_y ? 2 * len : len);
1958         if (!x || !buf)
1959                 goto fail;
1960
1961         if (EC_POINT_get_affine_coordinates_GFp(ecdh->ec->group, pubkey,
1962                                                 x, y, ecdh->ec->bnctx) != 1) {
1963                 wpa_printf(MSG_ERROR,
1964                            "OpenSSL: EC_POINT_get_affine_coordinates_GFp failed: %s",
1965                            ERR_error_string(ERR_get_error(), NULL));
1966                 goto fail;
1967         }
1968
1969         res = crypto_bignum_to_bin((struct crypto_bignum *) x,
1970                                    wpabuf_put(buf, len), len, len);
1971         if (res < 0)
1972                 goto fail;
1973
1974         if (inc_y) {
1975                 res = crypto_bignum_to_bin((struct crypto_bignum *) y,
1976                                            wpabuf_put(buf, len), len, len);
1977                 if (res < 0)
1978                         goto fail;
1979         }
1980
1981 done:
1982         BN_clear_free(x);
1983         BN_clear_free(y);
1984         EC_KEY_free(eckey);
1985
1986         return buf;
1987 fail:
1988         wpabuf_free(buf);
1989         buf = NULL;
1990         goto done;
1991 }
1992
1993
1994 struct wpabuf * crypto_ecdh_set_peerkey(struct crypto_ecdh *ecdh, int inc_y,
1995                                         const u8 *key, size_t len)
1996 {
1997         BIGNUM *x, *y = NULL;
1998         EVP_PKEY_CTX *ctx = NULL;
1999         EVP_PKEY *peerkey = NULL;
2000         struct wpabuf *secret = NULL;
2001         size_t secret_len;
2002         EC_POINT *pub;
2003         EC_KEY *eckey = NULL;
2004
2005         x = BN_bin2bn(key, inc_y ? len / 2 : len, NULL);
2006         pub = EC_POINT_new(ecdh->ec->group);
2007         if (!x || !pub)
2008                 goto fail;
2009
2010         if (inc_y) {
2011                 y = BN_bin2bn(key + len / 2, len / 2, NULL);
2012                 if (!y)
2013                         goto fail;
2014                 if (!EC_POINT_set_affine_coordinates_GFp(ecdh->ec->group, pub,
2015                                                          x, y,
2016                                                          ecdh->ec->bnctx)) {
2017                         wpa_printf(MSG_ERROR,
2018                                    "OpenSSL: EC_POINT_set_affine_coordinates_GFp failed: %s",
2019                                    ERR_error_string(ERR_get_error(), NULL));
2020                         goto fail;
2021                 }
2022         } else if (!EC_POINT_set_compressed_coordinates_GFp(ecdh->ec->group,
2023                                                             pub, x, 0,
2024                                                             ecdh->ec->bnctx)) {
2025                 wpa_printf(MSG_ERROR,
2026                            "OpenSSL: EC_POINT_set_compressed_coordinates_GFp failed: %s",
2027                            ERR_error_string(ERR_get_error(), NULL));
2028                 goto fail;
2029         }
2030
2031         if (!EC_POINT_is_on_curve(ecdh->ec->group, pub, ecdh->ec->bnctx)) {
2032                 wpa_printf(MSG_ERROR,
2033                            "OpenSSL: ECDH peer public key is not on curve");
2034                 goto fail;
2035         }
2036
2037         eckey = EC_KEY_new_by_curve_name(ecdh->ec->nid);
2038         if (!eckey || EC_KEY_set_public_key(eckey, pub) != 1) {
2039                 wpa_printf(MSG_ERROR,
2040                            "OpenSSL: EC_KEY_set_public_key failed: %s",
2041                            ERR_error_string(ERR_get_error(), NULL));
2042                 goto fail;
2043         }
2044
2045         peerkey = EVP_PKEY_new();
2046         if (!peerkey || EVP_PKEY_set1_EC_KEY(peerkey, eckey) != 1)
2047                 goto fail;
2048
2049         ctx = EVP_PKEY_CTX_new(ecdh->pkey, NULL);
2050         if (!ctx || EVP_PKEY_derive_init(ctx) != 1 ||
2051             EVP_PKEY_derive_set_peer(ctx, peerkey) != 1 ||
2052             EVP_PKEY_derive(ctx, NULL, &secret_len) != 1) {
2053                 wpa_printf(MSG_ERROR,
2054                            "OpenSSL: EVP_PKEY_derive(1) failed: %s",
2055                            ERR_error_string(ERR_get_error(), NULL));
2056                 goto fail;
2057         }
2058
2059         secret = wpabuf_alloc(secret_len);
2060         if (!secret)
2061                 goto fail;
2062         if (EVP_PKEY_derive(ctx, wpabuf_put(secret, 0), &secret_len) != 1) {
2063                 wpa_printf(MSG_ERROR,
2064                            "OpenSSL: EVP_PKEY_derive(2) failed: %s",
2065                            ERR_error_string(ERR_get_error(), NULL));
2066                 goto fail;
2067         }
2068         if (secret->size != secret_len)
2069                 wpa_printf(MSG_DEBUG,
2070                            "OpenSSL: EVP_PKEY_derive(2) changed secret_len %d -> %d",
2071                            (int) secret->size, (int) secret_len);
2072         wpabuf_put(secret, secret_len);
2073
2074 done:
2075         BN_free(x);
2076         BN_free(y);
2077         EC_KEY_free(eckey);
2078         EC_POINT_free(pub);
2079         EVP_PKEY_CTX_free(ctx);
2080         EVP_PKEY_free(peerkey);
2081         return secret;
2082 fail:
2083         wpabuf_free(secret);
2084         secret = NULL;
2085         goto done;
2086 }
2087
2088
2089 void crypto_ecdh_deinit(struct crypto_ecdh *ecdh)
2090 {
2091         if (ecdh) {
2092                 crypto_ec_deinit(ecdh->ec);
2093                 EVP_PKEY_free(ecdh->pkey);
2094                 os_free(ecdh);
2095         }
2096 }
2097
2098 #endif /* CONFIG_ECC */