00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include "includes.h"
00016 #include <windows.h>
00017 #include <wincrypt.h>
00018
00019 #include "common.h"
00020 #include "crypto.h"
00021
00022 #ifndef MS_ENH_RSA_AES_PROV
00023 #ifdef UNICODE
00024 #define MS_ENH_RSA_AES_PROV \
00025 L"Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)"
00026 #else
00027 #define MS_ENH_RSA_AES_PROV \
00028 "Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)"
00029 #endif
00030 #endif
00031
00032 #ifndef CALG_HMAC
00033 #define CALG_HMAC (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_HMAC)
00034 #endif
00035
00036 #ifdef __MINGW32_VERSION
00037
00038
00039
00040
00041
00042 static BOOL WINAPI
00043 (*CryptImportPublicKeyInfo)(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType,
00044 PCERT_PUBLIC_KEY_INFO pInfo, HCRYPTKEY *phKey)
00045 = NULL;
00046
00047
00048 static int mingw_load_crypto_func(void)
00049 {
00050 HINSTANCE dll;
00051
00052
00053
00054
00055 if (CryptImportPublicKeyInfo)
00056 return 0;
00057
00058 dll = LoadLibrary("crypt32");
00059 if (dll == NULL) {
00060 wpa_printf(MSG_DEBUG, "CryptoAPI: Could not load crypt32 "
00061 "library");
00062 return -1;
00063 }
00064
00065 CryptImportPublicKeyInfo = GetProcAddress(
00066 dll, "CryptImportPublicKeyInfo");
00067 if (CryptImportPublicKeyInfo == NULL) {
00068 wpa_printf(MSG_DEBUG, "CryptoAPI: Could not get "
00069 "CryptImportPublicKeyInfo() address from "
00070 "crypt32 library");
00071 return -1;
00072 }
00073
00074 return 0;
00075 }
00076
00077 #else
00078
00079 static int mingw_load_crypto_func(void)
00080 {
00081 return 0;
00082 }
00083
00084 #endif
00085
00086
00087 static void cryptoapi_report_error(const char *msg)
00088 {
00089 char *s, *pos;
00090 DWORD err = GetLastError();
00091
00092 if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
00093 FORMAT_MESSAGE_FROM_SYSTEM,
00094 NULL, err, 0, (LPTSTR) &s, 0, NULL) == 0) {
00095 wpa_printf(MSG_DEBUG, "CryptoAPI: %s: %d", msg, (int) err);
00096 }
00097
00098 pos = s;
00099 while (*pos) {
00100 if (*pos == '\n' || *pos == '\r') {
00101 *pos = '\0';
00102 break;
00103 }
00104 pos++;
00105 }
00106
00107 wpa_printf(MSG_DEBUG, "CryptoAPI: %s: %d: (%s)", msg, (int) err, s);
00108 LocalFree(s);
00109 }
00110
00111
00112 int cryptoapi_hash_vector(ALG_ID alg, size_t hash_len, size_t num_elem,
00113 const u8 *addr[], const size_t *len, u8 *mac)
00114 {
00115 HCRYPTPROV prov;
00116 HCRYPTHASH hash;
00117 size_t i;
00118 DWORD hlen;
00119 int ret = 0;
00120
00121 if (!CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, 0)) {
00122 cryptoapi_report_error("CryptAcquireContext");
00123 return -1;
00124 }
00125
00126 if (!CryptCreateHash(prov, alg, 0, 0, &hash)) {
00127 cryptoapi_report_error("CryptCreateHash");
00128 CryptReleaseContext(prov, 0);
00129 return -1;
00130 }
00131
00132 for (i = 0; i < num_elem; i++) {
00133 if (!CryptHashData(hash, (BYTE *) addr[i], len[i], 0)) {
00134 cryptoapi_report_error("CryptHashData");
00135 CryptDestroyHash(hash);
00136 CryptReleaseContext(prov, 0);
00137 }
00138 }
00139
00140 hlen = hash_len;
00141 if (!CryptGetHashParam(hash, HP_HASHVAL, mac, &hlen, 0)) {
00142 cryptoapi_report_error("CryptGetHashParam");
00143 ret = -1;
00144 }
00145
00146 CryptDestroyHash(hash);
00147 CryptReleaseContext(prov, 0);
00148
00149 return ret;
00150 }
00151
00152
00153 int md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
00154 {
00155 return cryptoapi_hash_vector(CALG_MD4, 16, num_elem, addr, len, mac);
00156 }
00157
00158
00159 void des_encrypt(const u8 *clear, const u8 *key, u8 *cypher)
00160 {
00161 u8 next, tmp;
00162 int i;
00163 HCRYPTPROV prov;
00164 HCRYPTKEY ckey;
00165 DWORD dlen;
00166 struct {
00167 BLOBHEADER hdr;
00168 DWORD len;
00169 BYTE key[8];
00170 } key_blob;
00171 DWORD mode = CRYPT_MODE_ECB;
00172
00173 key_blob.hdr.bType = PLAINTEXTKEYBLOB;
00174 key_blob.hdr.bVersion = CUR_BLOB_VERSION;
00175 key_blob.hdr.reserved = 0;
00176 key_blob.hdr.aiKeyAlg = CALG_DES;
00177 key_blob.len = 8;
00178
00179
00180 next = 0;
00181 for (i = 0; i < 7; i++) {
00182 tmp = key[i];
00183 key_blob.key[i] = (tmp >> i) | next | 1;
00184 next = tmp << (7 - i);
00185 }
00186 key_blob.key[i] = next | 1;
00187
00188 if (!CryptAcquireContext(&prov, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL,
00189 CRYPT_VERIFYCONTEXT)) {
00190 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptAcquireContext failed: "
00191 "%d", (int) GetLastError());
00192 return;
00193 }
00194
00195 if (!CryptImportKey(prov, (BYTE *) &key_blob, sizeof(key_blob), 0, 0,
00196 &ckey)) {
00197 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptImportKey failed: %d",
00198 (int) GetLastError());
00199 CryptReleaseContext(prov, 0);
00200 return;
00201 }
00202
00203 if (!CryptSetKeyParam(ckey, KP_MODE, (BYTE *) &mode, 0)) {
00204 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptSetKeyParam(KP_MODE) "
00205 "failed: %d", (int) GetLastError());
00206 CryptDestroyKey(ckey);
00207 CryptReleaseContext(prov, 0);
00208 return;
00209 }
00210
00211 os_memcpy(cypher, clear, 8);
00212 dlen = 8;
00213 if (!CryptEncrypt(ckey, 0, FALSE, 0, cypher, &dlen, 8)) {
00214 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptEncrypt failed: %d",
00215 (int) GetLastError());
00216 os_memset(cypher, 0, 8);
00217 }
00218
00219 CryptDestroyKey(ckey);
00220 CryptReleaseContext(prov, 0);
00221 }
00222
00223
00224 int md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
00225 {
00226 return cryptoapi_hash_vector(CALG_MD5, 16, num_elem, addr, len, mac);
00227 }
00228
00229
00230 int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
00231 {
00232 return cryptoapi_hash_vector(CALG_SHA, 20, num_elem, addr, len, mac);
00233 }
00234
00235
00236 struct aes_context {
00237 HCRYPTPROV prov;
00238 HCRYPTKEY ckey;
00239 };
00240
00241
00242 void * aes_encrypt_init(const u8 *key, size_t len)
00243 {
00244 struct aes_context *akey;
00245 struct {
00246 BLOBHEADER hdr;
00247 DWORD len;
00248 BYTE key[16];
00249 } key_blob;
00250 DWORD mode = CRYPT_MODE_ECB;
00251
00252 if (len != 16)
00253 return NULL;
00254
00255 key_blob.hdr.bType = PLAINTEXTKEYBLOB;
00256 key_blob.hdr.bVersion = CUR_BLOB_VERSION;
00257 key_blob.hdr.reserved = 0;
00258 key_blob.hdr.aiKeyAlg = CALG_AES_128;
00259 key_blob.len = len;
00260 os_memcpy(key_blob.key, key, len);
00261
00262 akey = os_zalloc(sizeof(*akey));
00263 if (akey == NULL)
00264 return NULL;
00265
00266 if (!CryptAcquireContext(&akey->prov, NULL,
00267 MS_ENH_RSA_AES_PROV, PROV_RSA_AES,
00268 CRYPT_VERIFYCONTEXT)) {
00269 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptAcquireContext failed: "
00270 "%d", (int) GetLastError());
00271 os_free(akey);
00272 return NULL;
00273 }
00274
00275 if (!CryptImportKey(akey->prov, (BYTE *) &key_blob, sizeof(key_blob),
00276 0, 0, &akey->ckey)) {
00277 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptImportKey failed: %d",
00278 (int) GetLastError());
00279 CryptReleaseContext(akey->prov, 0);
00280 os_free(akey);
00281 return NULL;
00282 }
00283
00284 if (!CryptSetKeyParam(akey->ckey, KP_MODE, (BYTE *) &mode, 0)) {
00285 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptSetKeyParam(KP_MODE) "
00286 "failed: %d", (int) GetLastError());
00287 CryptDestroyKey(akey->ckey);
00288 CryptReleaseContext(akey->prov, 0);
00289 os_free(akey);
00290 return NULL;
00291 }
00292
00293 return akey;
00294 }
00295
00296
00297 void aes_encrypt(void *ctx, const u8 *plain, u8 *crypt)
00298 {
00299 struct aes_context *akey = ctx;
00300 DWORD dlen;
00301
00302 os_memcpy(crypt, plain, 16);
00303 dlen = 16;
00304 if (!CryptEncrypt(akey->ckey, 0, FALSE, 0, crypt, &dlen, 16)) {
00305 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptEncrypt failed: %d",
00306 (int) GetLastError());
00307 os_memset(crypt, 0, 16);
00308 }
00309 }
00310
00311
00312 void aes_encrypt_deinit(void *ctx)
00313 {
00314 struct aes_context *akey = ctx;
00315 if (akey) {
00316 CryptDestroyKey(akey->ckey);
00317 CryptReleaseContext(akey->prov, 0);
00318 os_free(akey);
00319 }
00320 }
00321
00322
00323 void * aes_decrypt_init(const u8 *key, size_t len)
00324 {
00325 return aes_encrypt_init(key, len);
00326 }
00327
00328
00329 void aes_decrypt(void *ctx, const u8 *crypt, u8 *plain)
00330 {
00331 struct aes_context *akey = ctx;
00332 DWORD dlen;
00333
00334 os_memcpy(plain, crypt, 16);
00335 dlen = 16;
00336
00337 if (!CryptDecrypt(akey->ckey, 0, FALSE, 0, plain, &dlen)) {
00338 wpa_printf(MSG_DEBUG, "CryptoAPI: CryptDecrypt failed: %d",
00339 (int) GetLastError());
00340 }
00341 }
00342
00343
00344 void aes_decrypt_deinit(void *ctx)
00345 {
00346 aes_encrypt_deinit(ctx);
00347 }
00348
00349
00350 struct crypto_hash {
00351 enum crypto_hash_alg alg;
00352 int error;
00353 HCRYPTPROV prov;
00354 HCRYPTHASH hash;
00355 HCRYPTKEY key;
00356 };
00357
00358 struct crypto_hash * crypto_hash_init(enum crypto_hash_alg alg, const u8 *key,
00359 size_t key_len)
00360 {
00361 struct crypto_hash *ctx;
00362 ALG_ID calg;
00363 struct {
00364 BLOBHEADER hdr;
00365 DWORD len;
00366 BYTE key[32];
00367 } key_blob;
00368
00369 os_memset(&key_blob, 0, sizeof(key_blob));
00370 switch (alg) {
00371 case CRYPTO_HASH_ALG_MD5:
00372 calg = CALG_MD5;
00373 break;
00374 case CRYPTO_HASH_ALG_SHA1:
00375 calg = CALG_SHA;
00376 break;
00377 case CRYPTO_HASH_ALG_HMAC_MD5:
00378 case CRYPTO_HASH_ALG_HMAC_SHA1:
00379 calg = CALG_HMAC;
00380 key_blob.hdr.bType = PLAINTEXTKEYBLOB;
00381 key_blob.hdr.bVersion = CUR_BLOB_VERSION;
00382 key_blob.hdr.reserved = 0;
00383
00384
00385
00386
00387
00388
00389 key_blob.hdr.aiKeyAlg = CALG_RC2;
00390 key_blob.len = key_len;
00391 if (key_len > sizeof(key_blob.key))
00392 return NULL;
00393 os_memcpy(key_blob.key, key, key_len);
00394 break;
00395 default:
00396 return NULL;
00397 }
00398
00399 ctx = os_zalloc(sizeof(*ctx));
00400 if (ctx == NULL)
00401 return NULL;
00402
00403 ctx->alg = alg;
00404
00405 if (!CryptAcquireContext(&ctx->prov, NULL, NULL, PROV_RSA_FULL, 0)) {
00406 cryptoapi_report_error("CryptAcquireContext");
00407 os_free(ctx);
00408 return NULL;
00409 }
00410
00411 if (calg == CALG_HMAC) {
00412 #ifndef CRYPT_IPSEC_HMAC_KEY
00413 #define CRYPT_IPSEC_HMAC_KEY 0x00000100
00414 #endif
00415 if (!CryptImportKey(ctx->prov, (BYTE *) &key_blob,
00416 sizeof(key_blob), 0, CRYPT_IPSEC_HMAC_KEY,
00417 &ctx->key)) {
00418 cryptoapi_report_error("CryptImportKey");
00419 CryptReleaseContext(ctx->prov, 0);
00420 os_free(ctx);
00421 return NULL;
00422 }
00423 }
00424
00425 if (!CryptCreateHash(ctx->prov, calg, ctx->key, 0, &ctx->hash)) {
00426 cryptoapi_report_error("CryptCreateHash");
00427 CryptReleaseContext(ctx->prov, 0);
00428 os_free(ctx);
00429 return NULL;
00430 }
00431
00432 if (calg == CALG_HMAC) {
00433 HMAC_INFO info;
00434 os_memset(&info, 0, sizeof(info));
00435 switch (alg) {
00436 case CRYPTO_HASH_ALG_HMAC_MD5:
00437 info.HashAlgid = CALG_MD5;
00438 break;
00439 case CRYPTO_HASH_ALG_HMAC_SHA1:
00440 info.HashAlgid = CALG_SHA;
00441 break;
00442 default:
00443
00444 break;
00445 }
00446
00447 if (!CryptSetHashParam(ctx->hash, HP_HMAC_INFO, (BYTE *) &info,
00448 0)) {
00449 cryptoapi_report_error("CryptSetHashParam");
00450 CryptDestroyHash(ctx->hash);
00451 CryptReleaseContext(ctx->prov, 0);
00452 os_free(ctx);
00453 return NULL;
00454 }
00455 }
00456
00457 return ctx;
00458 }
00459
00460
00461 void crypto_hash_update(struct crypto_hash *ctx, const u8 *data, size_t len)
00462 {
00463 if (ctx == NULL || ctx->error)
00464 return;
00465
00466 if (!CryptHashData(ctx->hash, (BYTE *) data, len, 0)) {
00467 cryptoapi_report_error("CryptHashData");
00468 ctx->error = 1;
00469 }
00470 }
00471
00472
00473 int crypto_hash_finish(struct crypto_hash *ctx, u8 *mac, size_t *len)
00474 {
00475 int ret = 0;
00476 DWORD hlen;
00477
00478 if (ctx == NULL)
00479 return -2;
00480
00481 if (mac == NULL || len == NULL)
00482 goto done;
00483
00484 if (ctx->error) {
00485 ret = -2;
00486 goto done;
00487 }
00488
00489 hlen = *len;
00490 if (!CryptGetHashParam(ctx->hash, HP_HASHVAL, mac, &hlen, 0)) {
00491 cryptoapi_report_error("CryptGetHashParam");
00492 ret = -2;
00493 }
00494 *len = hlen;
00495
00496 done:
00497 if (ctx->alg == CRYPTO_HASH_ALG_HMAC_SHA1 ||
00498 ctx->alg == CRYPTO_HASH_ALG_HMAC_MD5)
00499 CryptDestroyKey(ctx->key);
00500
00501 os_free(ctx);
00502
00503 return ret;
00504 }
00505
00506
00507 struct crypto_cipher {
00508 HCRYPTPROV prov;
00509 HCRYPTKEY key;
00510 };
00511
00512
00513 struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg,
00514 const u8 *iv, const u8 *key,
00515 size_t key_len)
00516 {
00517 struct crypto_cipher *ctx;
00518 struct {
00519 BLOBHEADER hdr;
00520 DWORD len;
00521 BYTE key[32];
00522 } key_blob;
00523 DWORD mode = CRYPT_MODE_CBC;
00524
00525 key_blob.hdr.bType = PLAINTEXTKEYBLOB;
00526 key_blob.hdr.bVersion = CUR_BLOB_VERSION;
00527 key_blob.hdr.reserved = 0;
00528 key_blob.len = key_len;
00529 if (key_len > sizeof(key_blob.key))
00530 return NULL;
00531 os_memcpy(key_blob.key, key, key_len);
00532
00533 switch (alg) {
00534 case CRYPTO_CIPHER_ALG_AES:
00535 if (key_len == 32)
00536 key_blob.hdr.aiKeyAlg = CALG_AES_256;
00537 else if (key_len == 24)
00538 key_blob.hdr.aiKeyAlg = CALG_AES_192;
00539 else
00540 key_blob.hdr.aiKeyAlg = CALG_AES_128;
00541 break;
00542 case CRYPTO_CIPHER_ALG_3DES:
00543 key_blob.hdr.aiKeyAlg = CALG_3DES;
00544 break;
00545 case CRYPTO_CIPHER_ALG_DES:
00546 key_blob.hdr.aiKeyAlg = CALG_DES;
00547 break;
00548 case CRYPTO_CIPHER_ALG_RC2:
00549 key_blob.hdr.aiKeyAlg = CALG_RC2;
00550 break;
00551 case CRYPTO_CIPHER_ALG_RC4:
00552 key_blob.hdr.aiKeyAlg = CALG_RC4;
00553 break;
00554 default:
00555 return NULL;
00556 }
00557
00558 ctx = os_zalloc(sizeof(*ctx));
00559 if (ctx == NULL)
00560 return NULL;
00561
00562 if (!CryptAcquireContext(&ctx->prov, NULL, MS_ENH_RSA_AES_PROV,
00563 PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
00564 cryptoapi_report_error("CryptAcquireContext");
00565 goto fail1;
00566 }
00567
00568 if (!CryptImportKey(ctx->prov, (BYTE *) &key_blob,
00569 sizeof(key_blob), 0, 0, &ctx->key)) {
00570 cryptoapi_report_error("CryptImportKey");
00571 goto fail2;
00572 }
00573
00574 if (!CryptSetKeyParam(ctx->key, KP_MODE, (BYTE *) &mode, 0)) {
00575 cryptoapi_report_error("CryptSetKeyParam(KP_MODE)");
00576 goto fail3;
00577 }
00578
00579 if (iv && !CryptSetKeyParam(ctx->key, KP_IV, (BYTE *) iv, 0)) {
00580 cryptoapi_report_error("CryptSetKeyParam(KP_IV)");
00581 goto fail3;
00582 }
00583
00584 return ctx;
00585
00586 fail3:
00587 CryptDestroyKey(ctx->key);
00588 fail2:
00589 CryptReleaseContext(ctx->prov, 0);
00590 fail1:
00591 os_free(ctx);
00592 return NULL;
00593 }
00594
00595
00596 int crypto_cipher_encrypt(struct crypto_cipher *ctx, const u8 *plain,
00597 u8 *crypt, size_t len)
00598 {
00599 DWORD dlen;
00600
00601 os_memcpy(crypt, plain, len);
00602 dlen = len;
00603 if (!CryptEncrypt(ctx->key, 0, FALSE, 0, crypt, &dlen, len)) {
00604 cryptoapi_report_error("CryptEncrypt");
00605 os_memset(crypt, 0, len);
00606 return -1;
00607 }
00608
00609 return 0;
00610 }
00611
00612
00613 int crypto_cipher_decrypt(struct crypto_cipher *ctx, const u8 *crypt,
00614 u8 *plain, size_t len)
00615 {
00616 DWORD dlen;
00617
00618 os_memcpy(plain, crypt, len);
00619 dlen = len;
00620 if (!CryptDecrypt(ctx->key, 0, FALSE, 0, plain, &dlen)) {
00621 cryptoapi_report_error("CryptDecrypt");
00622 return -1;
00623 }
00624
00625 return 0;
00626 }
00627
00628
00629 void crypto_cipher_deinit(struct crypto_cipher *ctx)
00630 {
00631 CryptDestroyKey(ctx->key);
00632 CryptReleaseContext(ctx->prov, 0);
00633 os_free(ctx);
00634 }
00635
00636
00637 struct crypto_public_key {
00638 HCRYPTPROV prov;
00639 HCRYPTKEY rsa;
00640 };
00641
00642 struct crypto_private_key {
00643 HCRYPTPROV prov;
00644 HCRYPTKEY rsa;
00645 };
00646
00647
00648 struct crypto_public_key * crypto_public_key_import(const u8 *key, size_t len)
00649 {
00650
00651 return NULL;
00652 }
00653
00654
00655 struct crypto_private_key * crypto_private_key_import(const u8 *key,
00656 size_t len,
00657 const char *passwd)
00658 {
00659
00660 return NULL;
00661 }
00662
00663
00664 struct crypto_public_key * crypto_public_key_from_cert(const u8 *buf,
00665 size_t len)
00666 {
00667 struct crypto_public_key *pk;
00668 PCCERT_CONTEXT cc;
00669
00670 pk = os_zalloc(sizeof(*pk));
00671 if (pk == NULL)
00672 return NULL;
00673
00674 cc = CertCreateCertificateContext(X509_ASN_ENCODING |
00675 PKCS_7_ASN_ENCODING, buf, len);
00676 if (!cc) {
00677 cryptoapi_report_error("CryptCreateCertificateContext");
00678 os_free(pk);
00679 return NULL;
00680 }
00681
00682 if (!CryptAcquireContext(&pk->prov, NULL, MS_DEF_PROV, PROV_RSA_FULL,
00683 0)) {
00684 cryptoapi_report_error("CryptAcquireContext");
00685 os_free(pk);
00686 CertFreeCertificateContext(cc);
00687 return NULL;
00688 }
00689
00690 if (!CryptImportPublicKeyInfo(pk->prov, X509_ASN_ENCODING |
00691 PKCS_7_ASN_ENCODING,
00692 &cc->pCertInfo->SubjectPublicKeyInfo,
00693 &pk->rsa)) {
00694 cryptoapi_report_error("CryptImportPublicKeyInfo");
00695 CryptReleaseContext(pk->prov, 0);
00696 os_free(pk);
00697 CertFreeCertificateContext(cc);
00698 return NULL;
00699 }
00700
00701 CertFreeCertificateContext(cc);
00702
00703 return pk;
00704 }
00705
00706
00707 int crypto_public_key_encrypt_pkcs1_v15(struct crypto_public_key *key,
00708 const u8 *in, size_t inlen,
00709 u8 *out, size_t *outlen)
00710 {
00711 DWORD clen;
00712 u8 *tmp;
00713 size_t i;
00714
00715 if (*outlen < inlen)
00716 return -1;
00717 tmp = malloc(*outlen);
00718 if (tmp == NULL)
00719 return -1;
00720
00721 os_memcpy(tmp, in, inlen);
00722 clen = inlen;
00723 if (!CryptEncrypt(key->rsa, 0, TRUE, 0, tmp, &clen, *outlen)) {
00724 wpa_printf(MSG_DEBUG, "CryptoAPI: Failed to encrypt using "
00725 "public key: %d", (int) GetLastError());
00726 os_free(tmp);
00727 return -1;
00728 }
00729
00730 *outlen = clen;
00731
00732
00733 for (i = 0; i < *outlen; i++)
00734 out[i] = tmp[*outlen - 1 - i];
00735
00736 os_free(tmp);
00737
00738 return 0;
00739 }
00740
00741
00742 int crypto_private_key_sign_pkcs1(struct crypto_private_key *key,
00743 const u8 *in, size_t inlen,
00744 u8 *out, size_t *outlen)
00745 {
00746
00747 return -1;
00748 }
00749
00750
00751 void crypto_public_key_free(struct crypto_public_key *key)
00752 {
00753 if (key) {
00754 CryptDestroyKey(key->rsa);
00755 CryptReleaseContext(key->prov, 0);
00756 os_free(key);
00757 }
00758 }
00759
00760
00761 void crypto_private_key_free(struct crypto_private_key *key)
00762 {
00763 if (key) {
00764 CryptDestroyKey(key->rsa);
00765 CryptReleaseContext(key->prov, 0);
00766 os_free(key);
00767 }
00768 }
00769
00770
00771 int crypto_global_init(void)
00772 {
00773 return mingw_load_crypto_func();
00774 }
00775
00776
00777 void crypto_global_deinit(void)
00778 {
00779 }
00780
00781
00782 int crypto_mod_exp(const u8 *base, size_t base_len,
00783 const u8 *power, size_t power_len,
00784 const u8 *modulus, size_t modulus_len,
00785 u8 *result, size_t *result_len)
00786 {
00787
00788 return -1;
00789 }