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