LCOV - code coverage report
Current view: top level - src/crypto - crypto_openssl.c (source / functions) Hit Total Coverage
Test: wpa_supplicant/hostapd combined for hwsim test run 1422976643 Lines: 411 521 78.9 %
Date: 2015-02-03 Functions: 70 71 98.6 %

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

Generated by: LCOV version 1.10