contrib/wpa/src/crypto/crypto_openssl.c

   1 /*
   2  * WPA Supplicant / wrapper functions for libcrypto
   3  * Copyright (c) 2004-2012, 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
  23 #include "common.h"
  24 #include "wpabuf.h"
  25 #include "dh_group5.h"
  26 #include "crypto.h"
  27
  28 #if OPENSSL_VERSION_NUMBER < 0x00907000
  29 #define DES_key_schedule des_key_schedule
  30 #define DES_cblock des_cblock
  31 #define DES_set_key(key, schedule) des_set_key((key), *(schedule))
  32 #define DES_ecb_encrypt(input, output, ks, enc) \
  33         des_ecb_encrypt((input), (output), *(ks), (enc))
  34 #endif /* openssl < 0.9.7 */
  35
  36 static BIGNUM * get_group5_prime(void)
  37 {
  38 #if OPENSSL_VERSION_NUMBER < 0x00908000
  39         static const unsigned char RFC3526_PRIME_1536[] = {
  40                 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC9,0x0F,0xDA,0xA2,
  41                 0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,0x80,0xDC,0x1C,0xD1,
  42                 0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,0x02,0x0B,0xBE,0xA6,
  43                 0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,0x8E,0x34,0x04,0xDD,
  44                 0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,0x30,0x2B,0x0A,0x6D,
  45                 0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,0x6D,0x51,0xC2,0x45,
  46                 0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,0xF4,0x4C,0x42,0xE9,
  47                 0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,0xF4,0x06,0xB7,0xED,
  48                 0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,0xAE,0x9F,0x24,0x11,
  49                 0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,0xEC,0xE4,0x5B,0x3D,
  50                 0xC2,0x00,0x7C,0xB8,0xA1,0x63,0xBF,0x05,0x98,0xDA,0x48,0x36,
  51                 0x1C,0x55,0xD3,0x9A,0x69,0x16,0x3F,0xA8,0xFD,0x24,0xCF,0x5F,
  52                 0x83,0x65,0x5D,0x23,0xDC,0xA3,0xAD,0x96,0x1C,0x62,0xF3,0x56,
  53                 0x20,0x85,0x52,0xBB,0x9E,0xD5,0x29,0x07,0x70,0x96,0x96,0x6D,
  54                 0x67,0x0C,0x35,0x4E,0x4A,0xBC,0x98,0x04,0xF1,0x74,0x6C,0x08,
  55                 0xCA,0x23,0x73,0x27,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  56         };
  57         return BN_bin2bn(RFC3526_PRIME_1536, sizeof(RFC3526_PRIME_1536), NULL);
  58 #else /* openssl < 0.9.8 */
  59         return get_rfc3526_prime_1536(NULL);
  60 #endif /* openssl < 0.9.8 */
  61 }
  62
  63 #if OPENSSL_VERSION_NUMBER < 0x00908000
  64 #ifndef OPENSSL_NO_SHA256
  65 #ifndef OPENSSL_FIPS
  66 #define NO_SHA256_WRAPPER
  67 #endif
  68 #endif
  69
  70 #endif /* openssl < 0.9.8 */
  71
  72 #ifdef OPENSSL_NO_SHA256
  73 #define NO_SHA256_WRAPPER
  74 #endif
  75
  76 static int openssl_digest_vector(const EVP_MD *type, size_t num_elem,
  77                                  const u8 *addr[], const size_t *len, u8 *mac)
  78 {
  79         EVP_MD_CTX ctx;
  80         size_t i;
  81         unsigned int mac_len;
  82
  83         EVP_MD_CTX_init(&ctx);
  84         if (!EVP_DigestInit_ex(&ctx, type, NULL)) {
  85                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_DigestInit_ex failed: %s",
  86                            ERR_error_string(ERR_get_error(), NULL));
  87                 return -1;
  88         }
  89         for (i = 0; i < num_elem; i++) {
  90                 if (!EVP_DigestUpdate(&ctx, addr[i], len[i])) {
  91                         wpa_printf(MSG_ERROR, "OpenSSL: EVP_DigestUpdate "
  92                                    "failed: %s",
  93                                    ERR_error_string(ERR_get_error(), NULL));
  94                         return -1;
  95                 }
  96         }
  97         if (!EVP_DigestFinal(&ctx, mac, &mac_len)) {
  98                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_DigestFinal failed: %s",
  99                            ERR_error_string(ERR_get_error(), NULL));
 100                 return -1;
 101         }
 102
 103         return 0;
 104 }
 105
 106
 107 int md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 108 {
 109         return openssl_digest_vector(EVP_md4(), num_elem, addr, len, mac);
 110 }
 111
 112
 113 void des_encrypt(const u8 *clear, const u8 *key, u8 *cypher)
 114 {
 115         u8 pkey[8], next, tmp;
 116         int i;
 117         DES_key_schedule ks;
 118
 119         /* Add parity bits to the key */
 120         next = 0;
 121         for (i = 0; i < 7; i++) {
 122                 tmp = key[i];
 123                 pkey[i] = (tmp >> i) | next | 1;
 124                 next = tmp << (7 - i);
 125         }
 126         pkey[i] = next | 1;
 127
 128         DES_set_key(&pkey, &ks);
 129         DES_ecb_encrypt((DES_cblock *) clear, (DES_cblock *) cypher, &ks,
 130                         DES_ENCRYPT);
 131 }
 132
 133
 134 int rc4_skip(const u8 *key, size_t keylen, size_t skip,
 135              u8 *data, size_t data_len)
 136 {
 137 #ifdef OPENSSL_NO_RC4
 138         return -1;
 139 #else /* OPENSSL_NO_RC4 */
 140         EVP_CIPHER_CTX ctx;
 141         int outl;
 142         int res = -1;
 143         unsigned char skip_buf[16];
 144
 145         EVP_CIPHER_CTX_init(&ctx);
 146         if (!EVP_CIPHER_CTX_set_padding(&ctx, 0) ||
 147             !EVP_CipherInit_ex(&ctx, EVP_rc4(), NULL, NULL, NULL, 1) ||
 148             !EVP_CIPHER_CTX_set_key_length(&ctx, keylen) ||
 149             !EVP_CipherInit_ex(&ctx, NULL, NULL, key, NULL, 1))
 150                 goto out;
 151
 152         while (skip >= sizeof(skip_buf)) {
 153                 size_t len = skip;
 154                 if (len > sizeof(skip_buf))
 155                         len = sizeof(skip_buf);
 156                 if (!EVP_CipherUpdate(&ctx, skip_buf, &outl, skip_buf, len))
 157                         goto out;
 158                 skip -= len;
 159         }
 160
 161         if (EVP_CipherUpdate(&ctx, data, &outl, data, data_len))
 162                 res = 0;
 163
 164 out:
 165         EVP_CIPHER_CTX_cleanup(&ctx);
 166         return res;
 167 #endif /* OPENSSL_NO_RC4 */
 168 }
 169
 170
 171 int md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 172 {
 173         return openssl_digest_vector(EVP_md5(), num_elem, addr, len, mac);
 174 }
 175
 176
 177 int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 178 {
 179         return openssl_digest_vector(EVP_sha1(), num_elem, addr, len, mac);
 180 }
 181
 182
 183 #ifndef NO_SHA256_WRAPPER
 184 int sha256_vector(size_t num_elem, const u8 *addr[], const size_t *len,
 185                   u8 *mac)
 186 {
 187         return openssl_digest_vector(EVP_sha256(), num_elem, addr, len, mac);
 188 }
 189 #endif /* NO_SHA256_WRAPPER */
 190
 191
 192 static const EVP_CIPHER * aes_get_evp_cipher(size_t keylen)
 193 {
 194         switch (keylen) {
 195         case 16:
 196                 return EVP_aes_128_ecb();
 197         case 24:
 198                 return EVP_aes_192_ecb();
 199         case 32:
 200                 return EVP_aes_256_ecb();
 201         }
 202
 203         return NULL;
 204 }
 205
 206
 207 void * aes_encrypt_init(const u8 *key, size_t len)
 208 {
 209         EVP_CIPHER_CTX *ctx;
 210         const EVP_CIPHER *type;
 211
 212         type = aes_get_evp_cipher(len);
 213         if (type == NULL)
 214                 return NULL;
 215
 216         ctx = os_malloc(sizeof(*ctx));
 217         if (ctx == NULL)
 218                 return NULL;
 219         EVP_CIPHER_CTX_init(ctx);
 220         if (EVP_EncryptInit_ex(ctx, type, NULL, key, NULL) != 1) {
 221                 os_free(ctx);
 222                 return NULL;
 223         }
 224         EVP_CIPHER_CTX_set_padding(ctx, 0);
 225         return ctx;
 226 }
 227
 228
 229 void aes_encrypt(void *ctx, const u8 *plain, u8 *crypt)
 230 {
 231         EVP_CIPHER_CTX *c = ctx;
 232         int clen = 16;
 233         if (EVP_EncryptUpdate(c, crypt, &clen, plain, 16) != 1) {
 234                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_EncryptUpdate failed: %s",
 235                            ERR_error_string(ERR_get_error(), NULL));
 236         }
 237 }
 238
 239
 240 void aes_encrypt_deinit(void *ctx)
 241 {
 242         EVP_CIPHER_CTX *c = ctx;
 243         u8 buf[16];
 244         int len = sizeof(buf);
 245         if (EVP_EncryptFinal_ex(c, buf, &len) != 1) {
 246                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_EncryptFinal_ex failed: "
 247                            "%s", ERR_error_string(ERR_get_error(), NULL));
 248         }
 249         if (len != 0) {
 250                 wpa_printf(MSG_ERROR, "OpenSSL: Unexpected padding length %d "
 251                            "in AES encrypt", len);
 252         }
 253         EVP_CIPHER_CTX_cleanup(c);
 254         os_free(c);
 255 }
 256
 257
 258 void * aes_decrypt_init(const u8 *key, size_t len)
 259 {
 260         EVP_CIPHER_CTX *ctx;
 261         const EVP_CIPHER *type;
 262
 263         type = aes_get_evp_cipher(len);
 264         if (type == NULL)
 265                 return NULL;
 266
 267         ctx = os_malloc(sizeof(*ctx));
 268         if (ctx == NULL)
 269                 return NULL;
 270         EVP_CIPHER_CTX_init(ctx);
 271         if (EVP_DecryptInit_ex(ctx, type, NULL, key, NULL) != 1) {
 272                 os_free(ctx);
 273                 return NULL;
 274         }
 275         EVP_CIPHER_CTX_set_padding(ctx, 0);
 276         return ctx;
 277 }
 278
 279
 280 void aes_decrypt(void *ctx, const u8 *crypt, u8 *plain)
 281 {
 282         EVP_CIPHER_CTX *c = ctx;
 283         int plen = 16;
 284         if (EVP_DecryptUpdate(c, plain, &plen, crypt, 16) != 1) {
 285                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_DecryptUpdate failed: %s",
 286                            ERR_error_string(ERR_get_error(), NULL));
 287         }
 288 }
 289
 290
 291 void aes_decrypt_deinit(void *ctx)
 292 {
 293         EVP_CIPHER_CTX *c = ctx;
 294         u8 buf[16];
 295         int len = sizeof(buf);
 296         if (EVP_DecryptFinal_ex(c, buf, &len) != 1) {
 297                 wpa_printf(MSG_ERROR, "OpenSSL: EVP_DecryptFinal_ex failed: "
 298                            "%s", ERR_error_string(ERR_get_error(), NULL));
 299         }
 300         if (len != 0) {
 301                 wpa_printf(MSG_ERROR, "OpenSSL: Unexpected padding length %d "
 302                            "in AES decrypt", len);
 303         }
 304         EVP_CIPHER_CTX_cleanup(c);
 305         os_free(ctx);
 306 }
 307
 308
 309 int crypto_mod_exp(const u8 *base, size_t base_len,
 310                    const u8 *power, size_t power_len,
 311                    const u8 *modulus, size_t modulus_len,
 312                    u8 *result, size_t *result_len)
 313 {
 314         BIGNUM *bn_base, *bn_exp, *bn_modulus, *bn_result;
 315         int ret = -1;
 316         BN_CTX *ctx;
 317
 318         ctx = BN_CTX_new();
 319         if (ctx == NULL)
 320                 return -1;
 321
 322         bn_base = BN_bin2bn(base, base_len, NULL);
 323         bn_exp = BN_bin2bn(power, power_len, NULL);
 324         bn_modulus = BN_bin2bn(modulus, modulus_len, NULL);
 325         bn_result = BN_new();
 326
 327         if (bn_base == NULL || bn_exp == NULL || bn_modulus == NULL ||
 328             bn_result == NULL)
 329                 goto error;
 330
 331         if (BN_mod_exp(bn_result, bn_base, bn_exp, bn_modulus, ctx) != 1)
 332                 goto error;
 333
 334         *result_len = BN_bn2bin(bn_result, result);
 335         ret = 0;
 336
 337 error:
 338         BN_free(bn_base);
 339         BN_free(bn_exp);
 340         BN_free(bn_modulus);
 341         BN_free(bn_result);
 342         BN_CTX_free(ctx);
 343         return ret;
 344 }
 345
 346
 347 struct crypto_cipher {
 348         EVP_CIPHER_CTX enc;
 349         EVP_CIPHER_CTX dec;
 350 };
 351
 352
 353 struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg,
 354                                           const u8 *iv, const u8 *key,
 355                                           size_t key_len)
 356 {
 357         struct crypto_cipher *ctx;
 358         const EVP_CIPHER *cipher;
 359
 360         ctx = os_zalloc(sizeof(*ctx));
 361         if (ctx == NULL)
 362                 return NULL;
 363
 364         switch (alg) {
 365 #ifndef OPENSSL_NO_RC4
 366         case CRYPTO_CIPHER_ALG_RC4:
 367                 cipher = EVP_rc4();
 368                 break;
 369 #endif /* OPENSSL_NO_RC4 */
 370 #ifndef OPENSSL_NO_AES
 371         case CRYPTO_CIPHER_ALG_AES:
 372                 switch (key_len) {
 373                 case 16:
 374                         cipher = EVP_aes_128_cbc();
 375                         break;
 376                 case 24:
 377                         cipher = EVP_aes_192_cbc();
 378                         break;
 379                 case 32:
 380                         cipher = EVP_aes_256_cbc();
 381                         break;
 382                 default:
 383                         os_free(ctx);
 384                         return NULL;
 385                 }
 386                 break;
 387 #endif /* OPENSSL_NO_AES */
 388 #ifndef OPENSSL_NO_DES
 389         case CRYPTO_CIPHER_ALG_3DES:
 390                 cipher = EVP_des_ede3_cbc();
 391                 break;
 392         case CRYPTO_CIPHER_ALG_DES:
 393                 cipher = EVP_des_cbc();
 394                 break;
 395 #endif /* OPENSSL_NO_DES */
 396 #ifndef OPENSSL_NO_RC2
 397         case CRYPTO_CIPHER_ALG_RC2:
 398                 cipher = EVP_rc2_ecb();
 399                 break;
 400 #endif /* OPENSSL_NO_RC2 */
 401         default:
 402                 os_free(ctx);
 403                 return NULL;
 404         }
 405
 406         EVP_CIPHER_CTX_init(&ctx->enc);
 407         EVP_CIPHER_CTX_set_padding(&ctx->enc, 0);
 408         if (!EVP_EncryptInit_ex(&ctx->enc, cipher, NULL, NULL, NULL) ||
 409             !EVP_CIPHER_CTX_set_key_length(&ctx->enc, key_len) ||
 410             !EVP_EncryptInit_ex(&ctx->enc, NULL, NULL, key, iv)) {
 411                 EVP_CIPHER_CTX_cleanup(&ctx->enc);
 412                 os_free(ctx);
 413                 return NULL;
 414         }
 415
 416         EVP_CIPHER_CTX_init(&ctx->dec);
 417         EVP_CIPHER_CTX_set_padding(&ctx->dec, 0);
 418         if (!EVP_DecryptInit_ex(&ctx->dec, cipher, NULL, NULL, NULL) ||
 419             !EVP_CIPHER_CTX_set_key_length(&ctx->dec, key_len) ||
 420             !EVP_DecryptInit_ex(&ctx->dec, NULL, NULL, key, iv)) {
 421                 EVP_CIPHER_CTX_cleanup(&ctx->enc);
 422                 EVP_CIPHER_CTX_cleanup(&ctx->dec);
 423                 os_free(ctx);
 424                 return NULL;
 425         }
 426
 427         return ctx;
 428 }
 429
 430
 431 int crypto_cipher_encrypt(struct crypto_cipher *ctx, const u8 *plain,
 432                           u8 *crypt, size_t len)
 433 {
 434         int outl;
 435         if (!EVP_EncryptUpdate(&ctx->enc, crypt, &outl, plain, len))
 436                 return -1;
 437         return 0;
 438 }
 439
 440
 441 int crypto_cipher_decrypt(struct crypto_cipher *ctx, const u8 *crypt,
 442                           u8 *plain, size_t len)
 443 {
 444         int outl;
 445         outl = len;
 446         if (!EVP_DecryptUpdate(&ctx->dec, plain, &outl, crypt, len))
 447                 return -1;
 448         return 0;
 449 }
 450
 451
 452 void crypto_cipher_deinit(struct crypto_cipher *ctx)
 453 {
 454         EVP_CIPHER_CTX_cleanup(&ctx->enc);
 455         EVP_CIPHER_CTX_cleanup(&ctx->dec);
 456         os_free(ctx);
 457 }
 458
 459
 460 void * dh5_init(struct wpabuf **priv, struct wpabuf **publ)
 461 {
 462         DH *dh;
 463         struct wpabuf *pubkey = NULL, *privkey = NULL;
 464         size_t publen, privlen;
 465
 466         *priv = NULL;
 467         *publ = NULL;
 468
 469         dh = DH_new();
 470         if (dh == NULL)
 471                 return NULL;
 472
 473         dh->g = BN_new();
 474         if (dh->g == NULL || BN_set_word(dh->g, 2) != 1)
 475                 goto err;
 476
 477         dh->p = get_group5_prime();
 478         if (dh->p == NULL)
 479                 goto err;
 480
 481         if (DH_generate_key(dh) != 1)
 482                 goto err;
 483
 484         publen = BN_num_bytes(dh->pub_key);
 485         pubkey = wpabuf_alloc(publen);
 486         if (pubkey == NULL)
 487                 goto err;
 488         privlen = BN_num_bytes(dh->priv_key);
 489         privkey = wpabuf_alloc(privlen);
 490         if (privkey == NULL)
 491                 goto err;
 492
 493         BN_bn2bin(dh->pub_key, wpabuf_put(pubkey, publen));
 494         BN_bn2bin(dh->priv_key, wpabuf_put(privkey, privlen));
 495
 496         *priv = privkey;
 497         *publ = pubkey;
 498         return dh;
 499
 500 err:
 501         wpabuf_free(pubkey);
 502         wpabuf_free(privkey);
 503         DH_free(dh);
 504         return NULL;
 505 }
 506
 507
 508 void * dh5_init_fixed(const struct wpabuf *priv, const struct wpabuf *publ)
 509 {
 510         DH *dh;
 511
 512         dh = DH_new();
 513         if (dh == NULL)
 514                 return NULL;
 515
 516         dh->g = BN_new();
 517         if (dh->g == NULL || BN_set_word(dh->g, 2) != 1)
 518                 goto err;
 519
 520         dh->p = get_group5_prime();
 521         if (dh->p == NULL)
 522                 goto err;
 523
 524         dh->priv_key = BN_bin2bn(wpabuf_head(priv), wpabuf_len(priv), NULL);
 525         if (dh->priv_key == NULL)
 526                 goto err;
 527
 528         dh->pub_key = BN_bin2bn(wpabuf_head(publ), wpabuf_len(publ), NULL);
 529         if (dh->pub_key == NULL)
 530                 goto err;
 531
 532         if (DH_generate_key(dh) != 1)
 533                 goto err;
 534
 535         return dh;
 536
 537 err:
 538         DH_free(dh);
 539         return NULL;
 540 }
 541
 542
 543 struct wpabuf * dh5_derive_shared(void *ctx, const struct wpabuf *peer_public,
 544                                   const struct wpabuf *own_private)
 545 {
 546         BIGNUM *pub_key;
 547         struct wpabuf *res = NULL;
 548         size_t rlen;
 549         DH *dh = ctx;
 550         int keylen;
 551
 552         if (ctx == NULL)
 553                 return NULL;
 554
 555         pub_key = BN_bin2bn(wpabuf_head(peer_public), wpabuf_len(peer_public),
 556                             NULL);
 557         if (pub_key == NULL)
 558                 return NULL;
 559
 560         rlen = DH_size(dh);
 561         res = wpabuf_alloc(rlen);
 562         if (res == NULL)
 563                 goto err;
 564
 565         keylen = DH_compute_key(wpabuf_mhead(res), pub_key, dh);
 566         if (keylen < 0)
 567                 goto err;
 568         wpabuf_put(res, keylen);
 569         BN_free(pub_key);
 570
 571         return res;
 572
 573 err:
 574         BN_free(pub_key);
 575         wpabuf_free(res);
 576         return NULL;
 577 }
 578
 579
 580 void dh5_free(void *ctx)
 581 {
 582         DH *dh;
 583         if (ctx == NULL)
 584                 return;
 585         dh = ctx;
 586         DH_free(dh);
 587 }
 588
 589
 590 struct crypto_hash {
 591         HMAC_CTX ctx;
 592 };
 593
 594
 595 struct crypto_hash * crypto_hash_init(enum crypto_hash_alg alg, const u8 *key,
 596                                       size_t key_len)
 597 {
 598         struct crypto_hash *ctx;
 599         const EVP_MD *md;
 600
 601         switch (alg) {
 602 #ifndef OPENSSL_NO_MD5
 603         case CRYPTO_HASH_ALG_HMAC_MD5:
 604                 md = EVP_md5();
 605                 break;
 606 #endif /* OPENSSL_NO_MD5 */
 607 #ifndef OPENSSL_NO_SHA
 608         case CRYPTO_HASH_ALG_HMAC_SHA1:
 609                 md = EVP_sha1();
 610                 break;
 611 #endif /* OPENSSL_NO_SHA */
 612 #ifndef OPENSSL_NO_SHA256
 613 #ifdef CONFIG_SHA256
 614         case CRYPTO_HASH_ALG_HMAC_SHA256:
 615                 md = EVP_sha256();
 616                 break;
 617 #endif /* CONFIG_SHA256 */
 618 #endif /* OPENSSL_NO_SHA256 */
 619         default:
 620                 return NULL;
 621         }
 622
 623         ctx = os_zalloc(sizeof(*ctx));
 624         if (ctx == NULL)
 625                 return NULL;
 626         HMAC_CTX_init(&ctx->ctx);
 627
 628 #if OPENSSL_VERSION_NUMBER < 0x00909000
 629         HMAC_Init_ex(&ctx->ctx, key, key_len, md, NULL);
 630 #else /* openssl < 0.9.9 */
 631         if (HMAC_Init_ex(&ctx->ctx, key, key_len, md, NULL) != 1) {
 632                 os_free(ctx);
 633                 return NULL;
 634         }
 635 #endif /* openssl < 0.9.9 */
 636
 637         return ctx;
 638 }
 639
 640
 641 void crypto_hash_update(struct crypto_hash *ctx, const u8 *data, size_t len)
 642 {
 643         if (ctx == NULL)
 644                 return;
 645         HMAC_Update(&ctx->ctx, data, len);
 646 }
 647
 648
 649 int crypto_hash_finish(struct crypto_hash *ctx, u8 *mac, size_t *len)
 650 {
 651         unsigned int mdlen;
 652         int res;
 653
 654         if (ctx == NULL)
 655                 return -2;
 656
 657         if (mac == NULL || len == NULL) {
 658                 os_free(ctx);
 659                 return 0;
 660         }
 661
 662         mdlen = *len;
 663 #if OPENSSL_VERSION_NUMBER < 0x00909000
 664         HMAC_Final(&ctx->ctx, mac, &mdlen);
 665         res = 1;
 666 #else /* openssl < 0.9.9 */
 667         res = HMAC_Final(&ctx->ctx, mac, &mdlen);
 668 #endif /* openssl < 0.9.9 */
 669         HMAC_CTX_cleanup(&ctx->ctx);
 670         os_free(ctx);
 671
 672         if (res == 1) {
 673                 *len = mdlen;
 674                 return 0;
 675         }
 676
 677         return -1;
 678 }
 679
 680
 681 int pbkdf2_sha1(const char *passphrase, const u8 *ssid, size_t ssid_len,
 682                 int iterations, u8 *buf, size_t buflen)
 683 {
 684 #if OPENSSL_VERSION_NUMBER < 0x00908000
 685         if (PKCS5_PBKDF2_HMAC_SHA1(passphrase, os_strlen(passphrase),
 686                                    (unsigned char *) ssid,
 687                                    ssid_len, 4096, buflen, buf) != 1)
 688                 return -1;
 689 #else /* openssl < 0.9.8 */
 690         if (PKCS5_PBKDF2_HMAC_SHA1(passphrase, os_strlen(passphrase), ssid,
 691                                    ssid_len, 4096, buflen, buf) != 1)
 692                 return -1;
 693 #endif /* openssl < 0.9.8 */
 694         return 0;
 695 }
 696
 697
 698 int hmac_sha1_vector(const u8 *key, size_t key_len, size_t num_elem,
 699                      const u8 *addr[], const size_t *len, u8 *mac)
 700 {
 701         HMAC_CTX ctx;
 702         size_t i;
 703         unsigned int mdlen;
 704         int res;
 705
 706         HMAC_CTX_init(&ctx);
 707 #if OPENSSL_VERSION_NUMBER < 0x00909000
 708         HMAC_Init_ex(&ctx, key, key_len, EVP_sha1(), NULL);
 709 #else /* openssl < 0.9.9 */
 710         if (HMAC_Init_ex(&ctx, key, key_len, EVP_sha1(), NULL) != 1)
 711                 return -1;
 712 #endif /* openssl < 0.9.9 */
 713
 714         for (i = 0; i < num_elem; i++)
 715                 HMAC_Update(&ctx, addr[i], len[i]);
 716
 717         mdlen = 20;
 718 #if OPENSSL_VERSION_NUMBER < 0x00909000
 719         HMAC_Final(&ctx, mac, &mdlen);
 720         res = 1;
 721 #else /* openssl < 0.9.9 */
 722         res = HMAC_Final(&ctx, mac, &mdlen);
 723 #endif /* openssl < 0.9.9 */
 724         HMAC_CTX_cleanup(&ctx);
 725
 726         return res == 1 ? 0 : -1;
 727 }
 728
 729
 730 int hmac_sha1(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
 731                u8 *mac)
 732 {
 733         return hmac_sha1_vector(key, key_len, 1, &data, &data_len, mac);
 734 }
 735
 736
 737 #ifdef CONFIG_SHA256
 738
 739 int hmac_sha256_vector(const u8 *key, size_t key_len, size_t num_elem,
 740                        const u8 *addr[], const size_t *len, u8 *mac)
 741 {
 742         HMAC_CTX ctx;
 743         size_t i;
 744         unsigned int mdlen;
 745         int res;
 746
 747         HMAC_CTX_init(&ctx);
 748 #if OPENSSL_VERSION_NUMBER < 0x00909000
 749         HMAC_Init_ex(&ctx, key, key_len, EVP_sha256(), NULL);
 750 #else /* openssl < 0.9.9 */
 751         if (HMAC_Init_ex(&ctx, key, key_len, EVP_sha256(), NULL) != 1)
 752                 return -1;
 753 #endif /* openssl < 0.9.9 */
 754
 755         for (i = 0; i < num_elem; i++)
 756                 HMAC_Update(&ctx, addr[i], len[i]);
 757
 758         mdlen = 32;
 759 #if OPENSSL_VERSION_NUMBER < 0x00909000
 760         HMAC_Final(&ctx, mac, &mdlen);
 761         res = 1;
 762 #else /* openssl < 0.9.9 */
 763         res = HMAC_Final(&ctx, mac, &mdlen);
 764 #endif /* openssl < 0.9.9 */
 765         HMAC_CTX_cleanup(&ctx);
 766
 767         return res == 1 ? 0 : -1;
 768 }
 769
 770
 771 int hmac_sha256(const u8 *key, size_t key_len, const u8 *data,
 772                 size_t data_len, u8 *mac)
 773 {
 774         return hmac_sha256_vector(key, key_len, 1, &data, &data_len, mac);
 775 }
 776
 777 #endif /* CONFIG_SHA256 */
 778
 779
 780 int crypto_get_random(void *buf, size_t len)
 781 {
 782         if (RAND_bytes(buf, len) != 1)
 783                 return -1;
 784         return 0;
 785 }
 786
 787
 788 #ifdef CONFIG_OPENSSL_CMAC
 789 int omac1_aes_128_vector(const u8 *key, size_t num_elem,
 790                          const u8 *addr[], const size_t *len, u8 *mac)
 791 {
 792         CMAC_CTX *ctx;
 793         int ret = -1;
 794         size_t outlen, i;
 795
 796         ctx = CMAC_CTX_new();
 797         if (ctx == NULL)
 798                 return -1;
 799
 800         if (!CMAC_Init(ctx, key, 16, EVP_aes_128_cbc(), NULL))
 801                 goto fail;
 802         for (i = 0; i < num_elem; i++) {
 803                 if (!CMAC_Update(ctx, addr[i], len[i]))
 804                         goto fail;
 805         }
 806         if (!CMAC_Final(ctx, mac, &outlen) || outlen != 16)
 807                 goto fail;
 808
 809         ret = 0;
 810 fail:
 811         CMAC_CTX_free(ctx);
 812         return ret;
 813 }
 814
 815
 816 int omac1_aes_128(const u8 *key, const u8 *data, size_t data_len, u8 *mac)
 817 {
 818         return omac1_aes_128_vector(key, 1, &data, &data_len, mac);
 819 }
 820 #endif /* CONFIG_OPENSSL_CMAC */