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