contrib/hostapd/src/crypto/crypto_cryptoapi.c

   1 /*
   2  * Crypto wrapper for Microsoft CryptoAPI
   3  * Copyright (c) 2005-2009, 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 <windows.h>
  11 #include <wincrypt.h>
  12
  13 #include "common.h"
  14 #include "crypto.h"
  15
  16 #ifndef MS_ENH_RSA_AES_PROV
  17 #ifdef UNICODE
  18 #define MS_ENH_RSA_AES_PROV \
  19 L"Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)"
  20 #else
  21 #define MS_ENH_RSA_AES_PROV \
  22 "Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)"
  23 #endif
  24 #endif /* MS_ENH_RSA_AES_PROV */
  25
  26 #ifndef CALG_HMAC
  27 #define CALG_HMAC (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_HMAC)
  28 #endif
  29
  30 #ifdef __MINGW32_VERSION
  31 /*
  32  * MinGW does not yet include all the needed definitions for CryptoAPI, so
  33  * define here whatever extra is needed.
  34  */
  35
  36 static BOOL WINAPI
  37 (*CryptImportPublicKeyInfo)(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType,
  38                             PCERT_PUBLIC_KEY_INFO pInfo, HCRYPTKEY *phKey)
  39 = NULL; /* to be loaded from crypt32.dll */
  40
  41
  42 static int mingw_load_crypto_func(void)
  43 {
  44         HINSTANCE dll;
  45
  46         /* MinGW does not yet have full CryptoAPI support, so load the needed
  47          * function here. */
  48
  49         if (CryptImportPublicKeyInfo)
  50                 return 0;
  51
  52         dll = LoadLibrary("crypt32");
  53         if (dll == NULL) {
  54                 wpa_printf(MSG_DEBUG, "CryptoAPI: Could not load crypt32 "
  55                            "library");
  56                 return -1;
  57         }
  58
  59         CryptImportPublicKeyInfo = GetProcAddress(
  60                 dll, "CryptImportPublicKeyInfo");
  61         if (CryptImportPublicKeyInfo == NULL) {
  62                 wpa_printf(MSG_DEBUG, "CryptoAPI: Could not get "
  63                            "CryptImportPublicKeyInfo() address from "
  64                            "crypt32 library");
  65                 return -1;
  66         }
  67
  68         return 0;
  69 }
  70
  71 #else /* __MINGW32_VERSION */
  72
  73 static int mingw_load_crypto_func(void)
  74 {
  75         return 0;
  76 }
  77
  78 #endif /* __MINGW32_VERSION */
  79
  80
  81 static void cryptoapi_report_error(const char *msg)
  82 {
  83         char *s, *pos;
  84         DWORD err = GetLastError();
  85
  86         if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
  87                           FORMAT_MESSAGE_FROM_SYSTEM,
  88                           NULL, err, 0, (LPTSTR) &s, 0, NULL) == 0) {
  89                 wpa_printf(MSG_DEBUG, "CryptoAPI: %s: %d", msg, (int) err);
  90         }
  91
  92         pos = s;
  93         while (*pos) {
  94                 if (*pos == '\n' || *pos == '\r') {
  95                         *pos = '\0';
  96                         break;
  97                 }
  98                 pos++;
  99         }
 100
 101         wpa_printf(MSG_DEBUG, "CryptoAPI: %s: %d: (%s)", msg, (int) err, s);
 102         LocalFree(s);
 103 }
 104
 105
 106 int cryptoapi_hash_vector(ALG_ID alg, size_t hash_len, size_t num_elem,
 107                           const u8 *addr[], const size_t *len, u8 *mac)
 108 {
 109         HCRYPTPROV prov;
 110         HCRYPTHASH hash;
 111         size_t i;
 112         DWORD hlen;
 113         int ret = 0;
 114
 115         if (!CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, 0)) {
 116                 cryptoapi_report_error("CryptAcquireContext");
 117                 return -1;
 118         }
 119
 120         if (!CryptCreateHash(prov, alg, 0, 0, &hash)) {
 121                 cryptoapi_report_error("CryptCreateHash");
 122                 CryptReleaseContext(prov, 0);
 123                 return -1;
 124         }
 125
 126         for (i = 0; i < num_elem; i++) {
 127                 if (!CryptHashData(hash, (BYTE *) addr[i], len[i], 0)) {
 128                         cryptoapi_report_error("CryptHashData");
 129                         CryptDestroyHash(hash);
 130                         CryptReleaseContext(prov, 0);
 131                 }
 132         }
 133
 134         hlen = hash_len;
 135         if (!CryptGetHashParam(hash, HP_HASHVAL, mac, &hlen, 0)) {
 136                 cryptoapi_report_error("CryptGetHashParam");
 137                 ret = -1;
 138         }
 139
 140         CryptDestroyHash(hash);
 141         CryptReleaseContext(prov, 0);
 142
 143         return ret;
 144 }
 145
 146
 147 int md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 148 {
 149         return cryptoapi_hash_vector(CALG_MD4, 16, num_elem, addr, len, mac);
 150 }
 151
 152
 153 void des_encrypt(const u8 *clear, const u8 *key, u8 *cypher)
 154 {
 155         u8 next, tmp;
 156         int i;
 157         HCRYPTPROV prov;
 158         HCRYPTKEY ckey;
 159         DWORD dlen;
 160         struct {
 161                 BLOBHEADER hdr;
 162                 DWORD len;
 163                 BYTE key[8];
 164         } key_blob;
 165         DWORD mode = CRYPT_MODE_ECB;
 166
 167         key_blob.hdr.bType = PLAINTEXTKEYBLOB;
 168         key_blob.hdr.bVersion = CUR_BLOB_VERSION;
 169         key_blob.hdr.reserved = 0;
 170         key_blob.hdr.aiKeyAlg = CALG_DES;
 171         key_blob.len = 8;
 172
 173         /* Add parity bits to the key */
 174         next = 0;
 175         for (i = 0; i < 7; i++) {
 176                 tmp = key[i];
 177                 key_blob.key[i] = (tmp >> i) | next | 1;
 178                 next = tmp << (7 - i);
 179         }
 180         key_blob.key[i] = next | 1;
 181
 182         if (!CryptAcquireContext(&prov, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL,
 183                                  CRYPT_VERIFYCONTEXT)) {
 184                 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptAcquireContext failed: "
 185                            "%d", (int) GetLastError());
 186                 return;
 187         }
 188
 189         if (!CryptImportKey(prov, (BYTE *) &key_blob, sizeof(key_blob), 0, 0,
 190                             &ckey)) {
 191                 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptImportKey failed: %d",
 192                            (int) GetLastError());
 193                 CryptReleaseContext(prov, 0);
 194                 return;
 195         }
 196
 197         if (!CryptSetKeyParam(ckey, KP_MODE, (BYTE *) &mode, 0)) {
 198                 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptSetKeyParam(KP_MODE) "
 199                            "failed: %d", (int) GetLastError());
 200                 CryptDestroyKey(ckey);
 201                 CryptReleaseContext(prov, 0);
 202                 return;
 203         }
 204
 205         os_memcpy(cypher, clear, 8);
 206         dlen = 8;
 207         if (!CryptEncrypt(ckey, 0, FALSE, 0, cypher, &dlen, 8)) {
 208                 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptEncrypt failed: %d",
 209                            (int) GetLastError());
 210                 os_memset(cypher, 0, 8);
 211         }
 212
 213         CryptDestroyKey(ckey);
 214         CryptReleaseContext(prov, 0);
 215 }
 216
 217
 218 int md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 219 {
 220         return cryptoapi_hash_vector(CALG_MD5, 16, num_elem, addr, len, mac);
 221 }
 222
 223
 224 int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
 225 {
 226         return cryptoapi_hash_vector(CALG_SHA, 20, num_elem, addr, len, mac);
 227 }
 228
 229
 230 struct aes_context {
 231         HCRYPTPROV prov;
 232         HCRYPTKEY ckey;
 233 };
 234
 235
 236 void * aes_encrypt_init(const u8 *key, size_t len)
 237 {
 238         struct aes_context *akey;
 239         struct {
 240                 BLOBHEADER hdr;
 241                 DWORD len;
 242                 BYTE key[16];
 243         } key_blob;
 244         DWORD mode = CRYPT_MODE_ECB;
 245
 246         if (len != 16)
 247                 return NULL;
 248
 249         key_blob.hdr.bType = PLAINTEXTKEYBLOB;
 250         key_blob.hdr.bVersion = CUR_BLOB_VERSION;
 251         key_blob.hdr.reserved = 0;
 252         key_blob.hdr.aiKeyAlg = CALG_AES_128;
 253         key_blob.len = len;
 254         os_memcpy(key_blob.key, key, len);
 255
 256         akey = os_zalloc(sizeof(*akey));
 257         if (akey == NULL)
 258                 return NULL;
 259
 260         if (!CryptAcquireContext(&akey->prov, NULL,
 261                                  MS_ENH_RSA_AES_PROV, PROV_RSA_AES,
 262                                  CRYPT_VERIFYCONTEXT)) {
 263                 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptAcquireContext failed: "
 264                            "%d", (int) GetLastError());
 265                 os_free(akey);
 266                 return NULL;
 267         }
 268
 269         if (!CryptImportKey(akey->prov, (BYTE *) &key_blob, sizeof(key_blob),
 270                             0, 0, &akey->ckey)) {
 271                 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptImportKey failed: %d",
 272                            (int) GetLastError());
 273                 CryptReleaseContext(akey->prov, 0);
 274                 os_free(akey);
 275                 return NULL;
 276         }
 277
 278         if (!CryptSetKeyParam(akey->ckey, KP_MODE, (BYTE *) &mode, 0)) {
 279                 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptSetKeyParam(KP_MODE) "
 280                            "failed: %d", (int) GetLastError());
 281                 CryptDestroyKey(akey->ckey);
 282                 CryptReleaseContext(akey->prov, 0);
 283                 os_free(akey);
 284                 return NULL;
 285         }
 286
 287         return akey;
 288 }
 289
 290
 291 void aes_encrypt(void *ctx, const u8 *plain, u8 *crypt)
 292 {
 293         struct aes_context *akey = ctx;
 294         DWORD dlen;
 295
 296         os_memcpy(crypt, plain, 16);
 297         dlen = 16;
 298         if (!CryptEncrypt(akey->ckey, 0, FALSE, 0, crypt, &dlen, 16)) {
 299                 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptEncrypt failed: %d",
 300                            (int) GetLastError());
 301                 os_memset(crypt, 0, 16);
 302         }
 303 }
 304
 305
 306 void aes_encrypt_deinit(void *ctx)
 307 {
 308         struct aes_context *akey = ctx;
 309         if (akey) {
 310                 CryptDestroyKey(akey->ckey);
 311                 CryptReleaseContext(akey->prov, 0);
 312                 os_free(akey);
 313         }
 314 }
 315
 316
 317 void * aes_decrypt_init(const u8 *key, size_t len)
 318 {
 319         return aes_encrypt_init(key, len);
 320 }
 321
 322
 323 void aes_decrypt(void *ctx, const u8 *crypt, u8 *plain)
 324 {
 325         struct aes_context *akey = ctx;
 326         DWORD dlen;
 327
 328         os_memcpy(plain, crypt, 16);
 329         dlen = 16;
 330
 331         if (!CryptDecrypt(akey->ckey, 0, FALSE, 0, plain, &dlen)) {
 332                 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptDecrypt failed: %d",
 333                            (int) GetLastError());
 334         }
 335 }
 336
 337
 338 void aes_decrypt_deinit(void *ctx)
 339 {
 340         aes_encrypt_deinit(ctx);
 341 }
 342
 343
 344 struct crypto_hash {
 345         enum crypto_hash_alg alg;
 346         int error;
 347         HCRYPTPROV prov;
 348         HCRYPTHASH hash;
 349         HCRYPTKEY key;
 350 };
 351
 352 struct crypto_hash * crypto_hash_init(enum crypto_hash_alg alg, const u8 *key,
 353                                       size_t key_len)
 354 {
 355         struct crypto_hash *ctx;
 356         ALG_ID calg;
 357         struct {
 358                 BLOBHEADER hdr;
 359                 DWORD len;
 360                 BYTE key[32];
 361         } key_blob;
 362
 363         os_memset(&key_blob, 0, sizeof(key_blob));
 364         switch (alg) {
 365         case CRYPTO_HASH_ALG_MD5:
 366                 calg = CALG_MD5;
 367                 break;
 368         case CRYPTO_HASH_ALG_SHA1:
 369                 calg = CALG_SHA;
 370                 break;
 371         case CRYPTO_HASH_ALG_HMAC_MD5:
 372         case CRYPTO_HASH_ALG_HMAC_SHA1:
 373                 calg = CALG_HMAC;
 374                 key_blob.hdr.bType = PLAINTEXTKEYBLOB;
 375                 key_blob.hdr.bVersion = CUR_BLOB_VERSION;
 376                 key_blob.hdr.reserved = 0;
 377                 /*
 378                  * Note: RC2 is not really used, but that can be used to
 379                  * import HMAC keys of up to 16 byte long.
 380                  * CRYPT_IPSEC_HMAC_KEY flag for CryptImportKey() is needed to
 381                  * be able to import longer keys (HMAC-SHA1 uses 20-byte key).
 382                  */
 383                 key_blob.hdr.aiKeyAlg = CALG_RC2;
 384                 key_blob.len = key_len;
 385                 if (key_len > sizeof(key_blob.key))
 386                         return NULL;
 387                 os_memcpy(key_blob.key, key, key_len);
 388                 break;
 389         default:
 390                 return NULL;
 391         }
 392
 393         ctx = os_zalloc(sizeof(*ctx));
 394         if (ctx == NULL)
 395                 return NULL;
 396
 397         ctx->alg = alg;
 398
 399         if (!CryptAcquireContext(&ctx->prov, NULL, NULL, PROV_RSA_FULL, 0)) {
 400                 cryptoapi_report_error("CryptAcquireContext");
 401                 os_free(ctx);
 402                 return NULL;
 403         }
 404
 405         if (calg == CALG_HMAC) {
 406 #ifndef CRYPT_IPSEC_HMAC_KEY
 407 #define CRYPT_IPSEC_HMAC_KEY 0x00000100
 408 #endif
 409                 if (!CryptImportKey(ctx->prov, (BYTE *) &key_blob,
 410                                     sizeof(key_blob), 0, CRYPT_IPSEC_HMAC_KEY,
 411                                     &ctx->key)) {
 412                         cryptoapi_report_error("CryptImportKey");
 413                         CryptReleaseContext(ctx->prov, 0);
 414                         os_free(ctx);
 415                         return NULL;
 416                 }
 417         }
 418
 419         if (!CryptCreateHash(ctx->prov, calg, ctx->key, 0, &ctx->hash)) {
 420                 cryptoapi_report_error("CryptCreateHash");
 421                 CryptReleaseContext(ctx->prov, 0);
 422                 os_free(ctx);
 423                 return NULL;
 424         }
 425
 426         if (calg == CALG_HMAC) {
 427                 HMAC_INFO info;
 428                 os_memset(&info, 0, sizeof(info));
 429                 switch (alg) {
 430                 case CRYPTO_HASH_ALG_HMAC_MD5:
 431                         info.HashAlgid = CALG_MD5;
 432                         break;
 433                 case CRYPTO_HASH_ALG_HMAC_SHA1:
 434                         info.HashAlgid = CALG_SHA;
 435                         break;
 436                 default:
 437                         /* unreachable */
 438                         break;
 439                 }
 440
 441                 if (!CryptSetHashParam(ctx->hash, HP_HMAC_INFO, (BYTE *) &info,
 442                                        0)) {
 443                         cryptoapi_report_error("CryptSetHashParam");
 444                         CryptDestroyHash(ctx->hash);
 445                         CryptReleaseContext(ctx->prov, 0);
 446                         os_free(ctx);
 447                         return NULL;
 448                 }
 449         }
 450
 451         return ctx;
 452 }
 453
 454
 455 void crypto_hash_update(struct crypto_hash *ctx, const u8 *data, size_t len)
 456 {
 457         if (ctx == NULL || ctx->error)
 458                 return;
 459
 460         if (!CryptHashData(ctx->hash, (BYTE *) data, len, 0)) {
 461                 cryptoapi_report_error("CryptHashData");
 462                 ctx->error = 1;
 463         }
 464 }
 465
 466
 467 int crypto_hash_finish(struct crypto_hash *ctx, u8 *mac, size_t *len)
 468 {
 469         int ret = 0;
 470         DWORD hlen;
 471
 472         if (ctx == NULL)
 473                 return -2;
 474
 475         if (mac == NULL || len == NULL)
 476                 goto done;
 477
 478         if (ctx->error) {
 479                 ret = -2;
 480                 goto done;
 481         }
 482
 483         hlen = *len;
 484         if (!CryptGetHashParam(ctx->hash, HP_HASHVAL, mac, &hlen, 0)) {
 485                 cryptoapi_report_error("CryptGetHashParam");
 486                 ret = -2;
 487         }
 488         *len = hlen;
 489
 490 done:
 491         if (ctx->alg == CRYPTO_HASH_ALG_HMAC_SHA1 ||
 492             ctx->alg == CRYPTO_HASH_ALG_HMAC_MD5)
 493                 CryptDestroyKey(ctx->key);
 494
 495         os_free(ctx);
 496
 497         return ret;
 498 }
 499
 500
 501 struct crypto_cipher {
 502         HCRYPTPROV prov;
 503         HCRYPTKEY key;
 504 };
 505
 506
 507 struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg,
 508                                           const u8 *iv, const u8 *key,
 509                                           size_t key_len)
 510 {
 511         struct crypto_cipher *ctx;
 512         struct {
 513                 BLOBHEADER hdr;
 514                 DWORD len;
 515                 BYTE key[32];
 516         } key_blob;
 517         DWORD mode = CRYPT_MODE_CBC;
 518
 519         key_blob.hdr.bType = PLAINTEXTKEYBLOB;
 520         key_blob.hdr.bVersion = CUR_BLOB_VERSION;
 521         key_blob.hdr.reserved = 0;
 522         key_blob.len = key_len;
 523         if (key_len > sizeof(key_blob.key))
 524                 return NULL;
 525         os_memcpy(key_blob.key, key, key_len);
 526
 527         switch (alg) {
 528         case CRYPTO_CIPHER_ALG_AES:
 529                 if (key_len == 32)
 530                         key_blob.hdr.aiKeyAlg = CALG_AES_256;
 531                 else if (key_len == 24)
 532                         key_blob.hdr.aiKeyAlg = CALG_AES_192;
 533                 else
 534                         key_blob.hdr.aiKeyAlg = CALG_AES_128;
 535                 break;
 536         case CRYPTO_CIPHER_ALG_3DES:
 537                 key_blob.hdr.aiKeyAlg = CALG_3DES;
 538                 break;
 539         case CRYPTO_CIPHER_ALG_DES:
 540                 key_blob.hdr.aiKeyAlg = CALG_DES;
 541                 break;
 542         case CRYPTO_CIPHER_ALG_RC2:
 543                 key_blob.hdr.aiKeyAlg = CALG_RC2;
 544                 break;
 545         case CRYPTO_CIPHER_ALG_RC4:
 546                 key_blob.hdr.aiKeyAlg = CALG_RC4;
 547                 break;
 548         default:
 549                 return NULL;
 550         }
 551
 552         ctx = os_zalloc(sizeof(*ctx));
 553         if (ctx == NULL)
 554                 return NULL;
 555
 556         if (!CryptAcquireContext(&ctx->prov, NULL, MS_ENH_RSA_AES_PROV,
 557                                  PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
 558                 cryptoapi_report_error("CryptAcquireContext");
 559                 goto fail1;
 560         }
 561
 562         if (!CryptImportKey(ctx->prov, (BYTE *) &key_blob,
 563                             sizeof(key_blob), 0, 0, &ctx->key)) {
 564                 cryptoapi_report_error("CryptImportKey");
 565                 goto fail2;
 566         }
 567
 568         if (!CryptSetKeyParam(ctx->key, KP_MODE, (BYTE *) &mode, 0)) {
 569                 cryptoapi_report_error("CryptSetKeyParam(KP_MODE)");
 570                 goto fail3;
 571         }
 572
 573         if (iv && !CryptSetKeyParam(ctx->key, KP_IV, (BYTE *) iv, 0)) {
 574                 cryptoapi_report_error("CryptSetKeyParam(KP_IV)");
 575                 goto fail3;
 576         }
 577
 578         return ctx;
 579
 580 fail3:
 581         CryptDestroyKey(ctx->key);
 582 fail2:
 583         CryptReleaseContext(ctx->prov, 0);
 584 fail1:
 585         os_free(ctx);
 586         return NULL;
 587 }
 588
 589
 590 int crypto_cipher_encrypt(struct crypto_cipher *ctx, const u8 *plain,
 591                           u8 *crypt, size_t len)
 592 {
 593         DWORD dlen;
 594
 595         os_memcpy(crypt, plain, len);
 596         dlen = len;
 597         if (!CryptEncrypt(ctx->key, 0, FALSE, 0, crypt, &dlen, len)) {
 598                 cryptoapi_report_error("CryptEncrypt");
 599                 os_memset(crypt, 0, len);
 600                 return -1;
 601         }
 602
 603         return 0;
 604 }
 605
 606
 607 int crypto_cipher_decrypt(struct crypto_cipher *ctx, const u8 *crypt,
 608                           u8 *plain, size_t len)
 609 {
 610         DWORD dlen;
 611
 612         os_memcpy(plain, crypt, len);
 613         dlen = len;
 614         if (!CryptDecrypt(ctx->key, 0, FALSE, 0, plain, &dlen)) {
 615                 cryptoapi_report_error("CryptDecrypt");
 616                 return -1;
 617         }
 618
 619         return 0;
 620 }
 621
 622
 623 void crypto_cipher_deinit(struct crypto_cipher *ctx)
 624 {
 625         CryptDestroyKey(ctx->key);
 626         CryptReleaseContext(ctx->prov, 0);
 627         os_free(ctx);
 628 }
 629
 630
 631 struct crypto_public_key {
 632         HCRYPTPROV prov;
 633         HCRYPTKEY rsa;
 634 };
 635
 636 struct crypto_private_key {
 637         HCRYPTPROV prov;
 638         HCRYPTKEY rsa;
 639 };
 640
 641
 642 struct crypto_public_key * crypto_public_key_import(const u8 *key, size_t len)
 643 {
 644         /* Use crypto_public_key_from_cert() instead. */
 645         return NULL;
 646 }
 647
 648
 649 struct crypto_private_key * crypto_private_key_import(const u8 *key,
 650                                                       size_t len,
 651                                                       const char *passwd)
 652 {
 653         /* TODO */
 654         return NULL;
 655 }
 656
 657
 658 struct crypto_public_key * crypto_public_key_from_cert(const u8 *buf,
 659                                                        size_t len)
 660 {
 661         struct crypto_public_key *pk;
 662         PCCERT_CONTEXT cc;
 663
 664         pk = os_zalloc(sizeof(*pk));
 665         if (pk == NULL)
 666                 return NULL;
 667
 668         cc = CertCreateCertificateContext(X509_ASN_ENCODING |
 669                                           PKCS_7_ASN_ENCODING, buf, len);
 670         if (!cc) {
 671                 cryptoapi_report_error("CryptCreateCertificateContext");
 672                 os_free(pk);
 673                 return NULL;
 674         }
 675
 676         if (!CryptAcquireContext(&pk->prov, NULL, MS_DEF_PROV, PROV_RSA_FULL,
 677                                  0)) {
 678                 cryptoapi_report_error("CryptAcquireContext");
 679                 os_free(pk);
 680                 CertFreeCertificateContext(cc);
 681                 return NULL;
 682         }
 683
 684         if (!CryptImportPublicKeyInfo(pk->prov, X509_ASN_ENCODING |
 685                                       PKCS_7_ASN_ENCODING,
 686                                       &cc->pCertInfo->SubjectPublicKeyInfo,
 687                                       &pk->rsa)) {
 688                 cryptoapi_report_error("CryptImportPublicKeyInfo");
 689                 CryptReleaseContext(pk->prov, 0);
 690                 os_free(pk);
 691                 CertFreeCertificateContext(cc);
 692                 return NULL;
 693         }
 694
 695         CertFreeCertificateContext(cc);
 696
 697         return pk;
 698 }
 699
 700
 701 int crypto_public_key_encrypt_pkcs1_v15(struct crypto_public_key *key,
 702                                         const u8 *in, size_t inlen,
 703                                         u8 *out, size_t *outlen)
 704 {
 705         DWORD clen;
 706         u8 *tmp;
 707         size_t i;
 708
 709         if (*outlen < inlen)
 710                 return -1;
 711         tmp = malloc(*outlen);
 712         if (tmp == NULL)
 713                 return -1;
 714
 715         os_memcpy(tmp, in, inlen);
 716         clen = inlen;
 717         if (!CryptEncrypt(key->rsa, 0, TRUE, 0, tmp, &clen, *outlen)) {
 718                 wpa_printf(MSG_DEBUG, "CryptoAPI: Failed to encrypt using "
 719                            "public key: %d", (int) GetLastError());
 720                 os_free(tmp);
 721                 return -1;
 722         }
 723
 724         *outlen = clen;
 725
 726         /* Reverse the output */
 727         for (i = 0; i < *outlen; i++)
 728                 out[i] = tmp[*outlen - 1 - i];
 729
 730         os_free(tmp);
 731
 732         return 0;
 733 }
 734
 735
 736 int crypto_private_key_sign_pkcs1(struct crypto_private_key *key,
 737                                   const u8 *in, size_t inlen,
 738                                   u8 *out, size_t *outlen)
 739 {
 740         /* TODO */
 741         return -1;
 742 }
 743
 744
 745 void crypto_public_key_free(struct crypto_public_key *key)
 746 {
 747         if (key) {
 748                 CryptDestroyKey(key->rsa);
 749                 CryptReleaseContext(key->prov, 0);
 750                 os_free(key);
 751         }
 752 }
 753
 754
 755 void crypto_private_key_free(struct crypto_private_key *key)
 756 {
 757         if (key) {
 758                 CryptDestroyKey(key->rsa);
 759                 CryptReleaseContext(key->prov, 0);
 760                 os_free(key);
 761         }
 762 }
 763
 764
 765 int crypto_global_init(void)
 766 {
 767         return mingw_load_crypto_func();
 768 }
 769
 770
 771 void crypto_global_deinit(void)
 772 {
 773 }
 774
 775
 776 int crypto_mod_exp(const u8 *base, size_t base_len,
 777                    const u8 *power, size_t power_len,
 778                    const u8 *modulus, size_t modulus_len,
 779                    u8 *result, size_t *result_len)
 780 {
 781         /* TODO */
 782         return -1;
 783 }