2 * Copyright 1999 Ian Schmidt
3 * Copyright 2001 Travis Michielsen
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 ///////////////////////
23 // - Reference counting
25 // - Signature checking
31 #include "wine/unicode.h"
40 #include "wine/debug.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
44 HWND crypt_hWindow = 0;
46 #define CRYPT_ReturnLastError(err) {SetLastError(err); return FALSE;}
48 #define CRYPT_Alloc(size) ((LPVOID)LocalAlloc(LMEM_ZEROINIT, size))
49 #define CRYPT_Free(buffer) (LocalFree((HLOCAL)buffer))
51 static inline PSTR CRYPT_GetProvKeyName(PCSTR pProvName)
53 const PSTR KEYSTR = "Software\\Microsoft\\Cryptography\\Defaults\\Provider\\";
56 keyname = CRYPT_Alloc(strlen(KEYSTR) + strlen(pProvName) +1);
59 strcpy(keyname, KEYSTR);
60 strcpy(keyname + strlen(KEYSTR), pProvName);
62 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
66 static inline PSTR CRYPT_GetTypeKeyName(DWORD dwType, BOOL user)
68 const PSTR MACHINESTR = "Software\\Microsoft\\Cryptography\\Defaults\\Provider Types\\Type XXX";
69 const PSTR USERSTR = "Software\\Microsoft\\Cryptography\\Provider Type XXX";
73 keyname = CRYPT_Alloc( (user ? strlen(USERSTR) : strlen(MACHINESTR)) +1);
76 user ? strcpy(keyname, USERSTR) : strcpy(keyname, MACHINESTR);
77 ptr = keyname + strlen(keyname);
78 *(--ptr) = (dwType % 10) + '0';
79 *(--ptr) = (dwType / 10) + '0';
80 *(--ptr) = (dwType / 100) + '0';
82 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
86 /* CRYPT_UnicodeTOANSI
87 * wstr - unicode string
88 * str - pointer to ANSI string
89 * strsize - size of buffer pointed to by str or -1 if we have to do the allocation
91 * returns TRUE if unsuccessfull, FALSE otherwise.
92 * if wstr is NULL, returns TRUE and sets str to NULL! Value of str should be checked after call
94 static inline BOOL CRYPT_UnicodeToANSI(LPCWSTR wstr, LPSTR* str, int strsize)
103 count = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
104 count = count < strsize ? count : strsize;
106 *str = CRYPT_Alloc(count * sizeof(CHAR));
109 WideCharToMultiByte(CP_ACP, 0, wstr, -1, *str, count, NULL, NULL);
112 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
116 /* CRYPT_ANSITOUnicode
118 * wstr - pointer to unicode string
119 * wstrsize - size of buffer pointed to by wstr or -1 if we have to do the allocation
121 static inline BOOL CRYPT_ANSIToUnicode(LPCSTR str, LPWSTR* wstr, int wstrsize)
130 wcount = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
131 wcount = wcount < wstrsize/sizeof(WCHAR) ? wcount : wstrsize/sizeof(WCHAR);
133 *wstr = CRYPT_Alloc(wcount * sizeof(WCHAR));
136 MultiByteToWideChar(CP_ACP, 0, str, -1, *wstr, wcount);
139 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
143 //These next 2 functions are used by the VTableProvStruc structure
144 BOOL CRYPT_VerifyImage(LPCSTR lpszImage, BYTE* pData)
146 if (!lpszImage || !pData)
148 SetLastError(ERROR_INVALID_PARAMETER);
151 //FIXME: Actually verify the image!
155 BOOL CRYPT_ReturnhWnd(DWORD *phWnd)
159 *phWnd = crypt_hWindow;
163 #define CRYPT_GetProvFunc(name) \
164 if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error
165 #define CRYPT_GetProvFuncOpt(name) \
166 provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)
167 PCRYPTPROV CRYPT_LoadProvider(PSTR pImage)
170 DWORD errorcode = ERROR_NOT_ENOUGH_MEMORY;
172 if ( !(provider = CRYPT_Alloc(sizeof(CRYPTPROV))) ) goto error;
173 if ( !(provider->pFuncs = CRYPT_Alloc(sizeof(PROVFUNCS))) ) goto error;
174 if ( !(provider->pVTable = CRYPT_Alloc(sizeof(VTableProvStruc))) ) goto error;
175 if ( !(provider->hModule = LoadLibraryA(pImage)) )
177 errorcode = (GetLastError() == ERROR_FILE_NOT_FOUND) ? NTE_PROV_DLL_NOT_FOUND : NTE_PROVIDER_DLL_FAIL;
181 errorcode = NTE_PROVIDER_DLL_FAIL;
182 CRYPT_GetProvFunc(CPAcquireContext);
183 CRYPT_GetProvFunc(CPCreateHash);
184 CRYPT_GetProvFunc(CPDecrypt);
185 CRYPT_GetProvFunc(CPDeriveKey);
186 CRYPT_GetProvFunc(CPDestroyHash);
187 CRYPT_GetProvFunc(CPDestroyKey);
188 CRYPT_GetProvFuncOpt(CPDuplicateHash);
189 CRYPT_GetProvFuncOpt(CPDuplicateKey);
190 CRYPT_GetProvFunc(CPEncrypt);
191 CRYPT_GetProvFunc(CPExportKey);
192 CRYPT_GetProvFunc(CPGenKey);
193 CRYPT_GetProvFunc(CPGenRandom);
194 CRYPT_GetProvFunc(CPGetHashParam);
195 CRYPT_GetProvFunc(CPGetKeyParam);
196 CRYPT_GetProvFunc(CPGetProvParam);
197 CRYPT_GetProvFunc(CPGetUserKey);
198 CRYPT_GetProvFunc(CPHashData);
199 CRYPT_GetProvFunc(CPHashSessionKey);
200 CRYPT_GetProvFunc(CPImportKey);
201 CRYPT_GetProvFunc(CPReleaseContext);
202 CRYPT_GetProvFunc(CPSetHashParam);
203 CRYPT_GetProvFunc(CPSetKeyParam);
204 CRYPT_GetProvFunc(CPSetProvParam);
205 CRYPT_GetProvFunc(CPSignHash);
206 CRYPT_GetProvFunc(CPVerifySignature);
208 //FIXME: Not sure what the pbContextInfo field is for
209 // Does it need memory allocation?
210 provider->pVTable->Version = 3;
211 provider->pVTable->pFuncVerifyImage = CRYPT_VerifyImage;
212 provider->pVTable->pFuncReturnhWnd = CRYPT_ReturnhWnd;
213 provider->pVTable->dwProvType = 0;
214 provider->pVTable->pbContextInfo = NULL;
215 provider->pVTable->cbContextInfo = 0;
216 provider->pVTable->pszProvName = NULL;
220 SetLastError(errorcode);
223 if (provider->hModule)
224 FreeLibrary(provider->hModule);
225 CRYPT_Free(provider->pVTable);
226 CRYPT_Free(provider->pFuncs);
227 CRYPT_Free(provider);
231 #undef CRYPT_GetProvFunc
232 #undef CRYPT_GetProvFuncOpt
235 /******************************************************************************
236 * CryptAcquireContextA (ADVAPI32.@)
237 * Acquire a crypto provider context handle.
240 * phProv: Pointer to HCRYPTPROV for the output.
241 * pszContainer: Key Container Name
242 * pszProvider: Cryptographic Service Provider Name
243 * dwProvType: Crypto provider type to get a handle.
244 * dwFlags: flags for the operation
246 * RETURNS TRUE on success, FALSE on failure.
248 BOOL WINAPI CryptAcquireContextA (HCRYPTPROV *phProv, LPCSTR pszContainer,
249 LPCSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
251 PCRYPTPROV pProv = NULL;
253 PSTR imagepath = NULL, keyname = NULL, provname = NULL, temp = NULL;
255 DWORD keytype, type, len;//, siglen;
257 TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv, pszContainer,
258 pszProvider, dwProvType, dwFlags);
260 if (!phProv || !dwProvType)
262 SetLastError(ERROR_INVALID_PARAMETER);
265 if (dwProvType > MAXPROVTYPES)
267 SetLastError(NTE_BAD_PROV_TYPE);
273 //No CSP name specified so try the user default CSP first
274 // then try the machine default CSP
275 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, TRUE)) )
276 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
277 if (RegOpenKeyA(HKEY_CURRENT_USER, keyname, &key))
280 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, FALSE)) )
281 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
282 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, keyname, &key)) goto error;
285 RegQueryValueExA(key, "Name", NULL, &keytype, NULL, &len);
286 if (!len || keytype != REG_SZ || !(provname = CRYPT_Alloc(len))) goto error;
287 RegQueryValueExA(key, "Name", NULL, NULL, provname, &len);
290 if ( !(provname = CRYPT_Alloc(strlen(pszProvider) +1)) )
291 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
292 strcpy(provname, pszProvider);
295 keyname = CRYPT_GetProvKeyName(provname);
296 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, keyname, &key)) goto error;
299 RegQueryValueExA(key, "Type", NULL, NULL, (BYTE*)&type, &len);
300 if (type != dwProvType)
302 SetLastError(NTE_BAD_PROV_TYPE);
306 RegQueryValueExA(key, "Image Path", NULL, &keytype, NULL, &len);
307 if (keytype != REG_SZ || !(temp = CRYPT_Alloc(len))) goto error;
308 RegQueryValueExA(key, "Image Path", NULL, NULL, temp, &len);
311 len = ExpandEnvironmentStringsA(temp, NULL, 0);
312 if ( !(imagepath = CRYPT_Alloc(len)) )
314 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
317 if (!ExpandEnvironmentStringsA(temp, imagepath, len)) goto error;
319 // if (!CRYPT_VerifyImage(imagepath, signature)) goto error;
320 pProv = CRYPT_LoadProvider(imagepath);
322 CRYPT_Free(imagepath);
323 if (!pProv) goto error;
325 if (pProv->pFuncs->pCPAcquireContext(&pProv->hPrivate, (CHAR*)pszContainer, dwFlags, pProv->pVTable))
327 //MSDN: When this flag is set, the value returned in phProv is undefined,
328 // and thus, the CryptReleaseContext function need not be called afterwards.
329 //Therefore, we must clean up everything now.
330 if (dwFlags & CRYPT_DELETEKEYSET)
332 FreeLibrary(pProv->hModule);
333 CRYPT_Free(provname);
334 CRYPT_Free(pProv->pFuncs);
337 pProv->pVTable->pszProvName = provname;
338 pProv->pVTable->dwProvType = dwProvType;
339 *phProv = (HCRYPTPROV)pProv;
343 //FALLTHROUGH TO ERROR IF FALSE - CSP internal error!
347 FreeLibrary(pProv->hModule);
348 CRYPT_Free(pProv->pVTable);
349 CRYPT_Free(pProv->pFuncs);
352 CRYPT_Free(provname);
354 CRYPT_Free(imagepath);
359 /******************************************************************************
360 * CryptAcquireContextW (ADVAPI32.@)
362 BOOL WINAPI CryptAcquireContextW (HCRYPTPROV *phProv, LPCWSTR pszContainer,
363 LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
365 PSTR pProvider = NULL, pContainer = NULL;
368 TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv, debugstr_w(pszContainer),
369 debugstr_w(pszProvider), dwProvType, dwFlags);
371 if ( !CRYPT_UnicodeToANSI(pszContainer, &pContainer, -1) )
372 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
373 if ( !CRYPT_UnicodeToANSI(pszProvider, &pProvider, -1) )
375 CRYPT_Free(pContainer);
376 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
379 ret = CryptAcquireContextA(phProv, pContainer, pProvider, dwProvType, dwFlags);
382 CRYPT_Free(pContainer);
384 CRYPT_Free(pProvider);
389 /******************************************************************************
390 * CryptContextAddRef (ADVAPI32.@)
392 BOOL WINAPI CryptContextAddRef (HCRYPTPROV hProv, DWORD *pdwReserved, DWORD dwFlags)
394 FIXME("(0x%lx, %p, %08lx): stub!\n", hProv, pdwReserved, dwFlags);
396 //InterlockIncrement??
399 /******************************************************************************
400 * CryptReleaseContext (ADVAPI32.@)
402 BOOL WINAPI CryptReleaseContext (HCRYPTPROV hProv, DWORD dwFlags)
404 PCRYPTPROV pProv = (PCRYPTPROV)hProv;
407 TRACE("(0x%lx, %08ld)\n", hProv, dwFlags);
411 SetLastError(NTE_BAD_UID);
414 //FIXME: Decrement the counter here first if possible
415 ret = pProv->pFuncs->pCPReleaseContext(pProv->hPrivate, dwFlags);
416 FreeLibrary(pProv->hModule);
417 // CRYPT_Free(pProv->pVTable->pContextInfo);
418 CRYPT_Free(pProv->pVTable->pszProvName);
419 CRYPT_Free(pProv->pVTable);
420 CRYPT_Free(pProv->pFuncs);
425 /******************************************************************************
426 * CryptGenRandom (ADVAPI32.@)
428 BOOL WINAPI CryptGenRandom (HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer)
430 PCRYPTPROV prov = (PCRYPTPROV)hProv;
432 TRACE("(0x%lx, %ld, %p)\n", hProv, dwLen, pbBuffer);
435 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
437 return prov->pFuncs->pCPGenRandom(prov->hPrivate, dwLen, pbBuffer);
440 /******************************************************************************
441 * CryptCreateHash (ADVAPI32.@)
443 BOOL WINAPI CryptCreateHash (HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey,
444 DWORD dwFlags, HCRYPTHASH *phHash)
446 PCRYPTPROV prov = (PCRYPTPROV)hProv;
447 PCRYPTKEY key = (PCRYPTKEY)hKey;
450 TRACE("(0x%lx, 0x%x, 0x%lx, %08lx, %p)\n", hProv, Algid, hKey, dwFlags, phHash);
453 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
455 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
457 CRYPT_ReturnLastError(NTE_BAD_FLAGS);
458 if ( !(hash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
459 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
461 hash->pProvider = prov;
463 *phHash = (HCRYPTHASH)hash;
464 if (prov->pFuncs->pCPCreateHash(prov->hPrivate, Algid,
465 key ? key->hPrivate : 0, 0, &hash->hPrivate))
473 /******************************************************************************
474 * CryptDecrypt (ADVAPI32.@)
476 BOOL WINAPI CryptDecrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final,
477 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
480 PCRYPTKEY key = (PCRYPTKEY)hKey;
481 PCRYPTHASH hash = (PCRYPTHASH)hHash;
483 TRACE("(0x%lx, 0x%lx, %d, %08lx, %p, %p)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen);
485 if (!key || !pbData || !pdwDataLen)
486 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
488 prov = key->pProvider;
489 return prov->pFuncs->pCPDecrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
490 Final, dwFlags, pbData, pdwDataLen);
493 /******************************************************************************
494 * CryptDeriveKey (ADVAPI32.@)
496 BOOL WINAPI CryptDeriveKey (HCRYPTPROV hProv, ALG_ID Algid, HCRYPTHASH hBaseData,
497 DWORD dwFlags, HCRYPTKEY *phKey)
499 PCRYPTPROV prov = (PCRYPTPROV)hProv;
500 PCRYPTHASH hash = (PCRYPTHASH)hBaseData;
503 TRACE("(0x%lx, %d, 0x%ld, %08ld, %p)\n", hProv, Algid, hBaseData, dwFlags, phKey);
506 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
508 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
509 if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
510 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
512 key->pProvider = prov;
513 if (prov->pFuncs->pCPDeriveKey(prov->hPrivate, Algid, hash->hPrivate, dwFlags, &key->hPrivate))
521 /******************************************************************************
522 * CryptDestroyHash (ADVAPI32.@)
524 BOOL WINAPI CryptDestroyHash (HCRYPTHASH hHash)
526 PCRYPTHASH hash = (PCRYPTHASH)hHash;
530 TRACE("(0x%lx)\n", hHash);
533 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
535 prov = hash->pProvider;
536 ret = prov->pFuncs->pCPDestroyHash(prov->hPrivate, hash->hPrivate);
541 /******************************************************************************
542 * CryptDestroyKey (ADVAPI32.@)
544 BOOL WINAPI CryptDestroyKey (HCRYPTKEY hKey)
546 PCRYPTKEY key = (PCRYPTKEY)hKey;
550 TRACE("(0x%lx)\n", hKey);
553 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
555 prov = key->pProvider;
556 ret = prov->pFuncs->pCPDestroyKey(prov->hPrivate, key->hPrivate);
561 /******************************************************************************
562 * CryptDuplicateHash (ADVAPI32.@)
564 BOOL WINAPI CryptDuplicateHash (HCRYPTHASH hHash, DWORD *pdwReserved,
565 DWORD dwFlags, HCRYPTHASH *phHash)
568 PCRYPTHASH orghash, newhash;
570 TRACE("(0x%lx, %p, %08ld, %p)\n", hHash, pdwReserved, dwFlags, phHash);
572 orghash = (PCRYPTHASH)hHash;
573 if (!orghash || pdwReserved || !phHash)
574 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
576 prov = orghash->pProvider;
577 if (!prov->pFuncs->pCPDuplicateHash)
578 CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED);
580 if ( !(newhash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
581 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
583 newhash->pProvider = prov;
584 if (prov->pFuncs->pCPDuplicateHash(prov->hPrivate, orghash->hPrivate, pdwReserved, dwFlags, &newhash->hPrivate))
586 *phHash = (HCRYPTHASH)newhash;
593 /******************************************************************************
594 * CryptDuplicateKey (ADVAPI32.@)
596 BOOL WINAPI CryptDuplicateKey (HCRYPTKEY hKey, DWORD *pdwReserved, DWORD dwFlags, HCRYPTKEY *phKey)
599 PCRYPTKEY orgkey, newkey;
601 TRACE("(0x%lx, %p, %08ld, %p)\n", hKey, pdwReserved, dwFlags, phKey);
603 orgkey = (PCRYPTKEY)hKey;
604 if (!orgkey || pdwReserved || !phKey)
605 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
607 prov = orgkey->pProvider;
608 if (!prov->pFuncs->pCPDuplicateKey)
609 CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED);
611 if ( !(newkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
612 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
614 newkey->pProvider = prov;
615 if (prov->pFuncs->pCPDuplicateKey(prov->hPrivate, orgkey->hPrivate, pdwReserved, dwFlags, &newkey->hPrivate))
617 *phKey = (HCRYPTKEY)newkey;
624 /******************************************************************************
625 * CryptEncrypt (ADVAPI32.@)
627 BOOL WINAPI CryptEncrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final,
628 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen)
631 PCRYPTKEY key = (PCRYPTKEY)hKey;
632 PCRYPTHASH hash = (PCRYPTHASH)hHash;
634 TRACE("(0x%lx, 0x%lx, %d, %08ld, %p, %p, %ld)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen, dwBufLen);
636 if (!key || !pdwDataLen)
637 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
639 prov = key->pProvider;
640 return prov->pFuncs->pCPEncrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
641 Final, dwFlags, pbData, pdwDataLen, dwBufLen);
644 /******************************************************************************
645 * CryptEnumProvidersA (ADVAPI32.@)
647 BOOL WINAPI CryptEnumProvidersA (DWORD dwIndex, DWORD *pdwReserved,
648 DWORD dwFlags, DWORD *pdwProvType, LPSTR pszProvName, DWORD *pcbProvName)
652 TRACE("(%ld, %p, %ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
653 pdwProvType, pszProvName, pcbProvName);
655 if (pdwReserved || !pcbProvName) CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
656 if (dwFlags) CRYPT_ReturnLastError(NTE_BAD_FLAGS);
658 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\Defaults\\Provider", &hKey))
659 CRYPT_ReturnLastError(NTE_FAIL);
664 RegQueryInfoKeyA(hKey, NULL, NULL, NULL, &numkeys, pcbProvName, NULL, NULL, NULL, NULL, NULL, NULL);
666 if (dwIndex >= numkeys)
667 CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS);
669 DWORD size = sizeof(DWORD);
671 if (RegEnumKeyA(hKey, dwIndex, pszProvName, *pcbProvName))
673 if (RegOpenKeyA(hKey, pszProvName, &subkey))
675 if (RegQueryValueExA(subkey, "Type", NULL, NULL, (BYTE*)pdwProvType, &size))
683 /******************************************************************************
684 * CryptEnumProvidersW (ADVAPI32.@)
686 BOOL WINAPI CryptEnumProvidersW (DWORD dwIndex, DWORD *pdwReserved,
687 DWORD dwFlags, DWORD *pdwProvType, LPWSTR pszProvName, DWORD *pcbProvName)
693 TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
694 pdwProvType, pszProvName, pcbProvName);
696 strlen = *pcbProvName / sizeof(WCHAR);
697 if ( pszProvName && (str = CRYPT_Alloc(strlen)) )
698 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
699 ret = CryptEnumProvidersA(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &strlen);
702 CRYPT_ANSIToUnicode(str, &pszProvName, *pcbProvName);
705 *pcbProvName = strlen * sizeof(WCHAR);
709 /******************************************************************************
710 * CryptEnumProviderTypesA (ADVAPI32.@)
712 BOOL WINAPI CryptEnumProviderTypesA (DWORD dwIndex, DWORD *pdwReserved,
713 DWORD dwFlags, DWORD *pdwProvType, LPSTR pszTypeName, DWORD *pcbTypeName)
716 DWORD keylen, numkeys;
719 TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex, pdwReserved,
720 dwFlags, pdwProvType, pszTypeName, pcbTypeName);
722 if (pdwReserved || !pdwProvType || !pcbTypeName)
723 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
724 if (dwFlags) CRYPT_ReturnLastError(NTE_BAD_FLAGS);
726 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\Defaults\\Provider Types", &hKey))
729 RegQueryInfoKeyA(hKey, NULL, NULL, NULL, &numkeys, &keylen, NULL, NULL, NULL, NULL, NULL, NULL);
730 if (dwIndex >= numkeys)
731 CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS);
733 if ( !(keyname = CRYPT_Alloc(keylen)) )
734 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
735 if ( RegEnumKeyA(hKey, dwIndex, keyname, keylen) )
737 RegOpenKeyA(hKey, keyname, &hSubkey);
738 ch = keyname + strlen(keyname);
739 //Convert "Type 000" to 0, etc/
740 *pdwProvType = *(--ch) - '0';
741 *pdwProvType += (*(--ch) - '0') * 10;
742 *pdwProvType += (*(--ch) - '0') * 100;
744 RegQueryValueA(hSubkey, "TypeName", pszTypeName, pcbTypeName);
745 RegCloseKey(hSubkey);
750 /******************************************************************************
751 * CryptEnumProviderTypesW (ADVAPI32.@)
753 BOOL WINAPI CryptEnumProviderTypesW (DWORD dwIndex, DWORD *pdwReserved,
754 DWORD dwFlags, DWORD *pdwProvType, LPWSTR pszTypeName, DWORD *pcbTypeName)
760 TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
761 pdwProvType, pszTypeName, pcbTypeName);
762 strlen = *pcbTypeName / sizeof(WCHAR);
763 if ( pszTypeName && (str = CRYPT_Alloc(strlen)) )
764 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
765 ret = CryptEnumProviderTypesA(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &strlen);
768 CRYPT_ANSIToUnicode(str, &pszTypeName, *pcbTypeName);
771 *pcbTypeName = strlen * sizeof(WCHAR);
775 /******************************************************************************
776 * CryptExportKey (ADVAPI32.@)
778 BOOL WINAPI CryptExportKey (HCRYPTKEY hKey, HCRYPTKEY hExpKey, DWORD dwBlobType,
779 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
782 PCRYPTKEY key = (PCRYPTKEY)hKey, expkey = (PCRYPTKEY)hExpKey;
784 TRACE("(0x%lx, 0x%lx, %ld, %08ld, %p, %p)\n", hKey, hExpKey, dwBlobType, dwFlags, pbData, pdwDataLen);
786 if (!key || pdwDataLen)
787 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
789 prov = key->pProvider;
790 return prov->pFuncs->pCPExportKey(prov->hPrivate, key->hPrivate, expkey ? expkey->hPrivate : 0,
791 dwBlobType, dwFlags, pbData, pdwDataLen);
794 /******************************************************************************
795 * CryptGenKey (ADVAPI32.@)
797 BOOL WINAPI CryptGenKey (HCRYPTPROV hProv, ALG_ID Algid, DWORD dwFlags, HCRYPTKEY *phKey)
799 PCRYPTPROV prov = (PCRYPTPROV)hProv;
802 TRACE("(0x%lx, %d, %08ld, %p)\n", hProv, Algid, dwFlags, phKey);
805 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
807 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
808 if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
809 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
811 key->pProvider = prov;
813 *phKey = (HCRYPTKEY)key;
814 if (prov->pFuncs->pCPGenKey(prov->hPrivate, Algid, dwFlags, &key->hPrivate))
822 /******************************************************************************
823 * CryptGetDefaultProviderA (ADVAPI32.@)
825 BOOL WINAPI CryptGetDefaultProviderA (DWORD dwProvType, DWORD *pdwReserved,
826 DWORD dwFlags, LPSTR pszProvName, DWORD *pcbProvName)
831 if (pdwReserved || !pcbProvName)
832 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
833 if (dwFlags & ~(CRYPT_USER_DEFAULT | CRYPT_MACHINE_DEFAULT))
834 CRYPT_ReturnLastError(NTE_BAD_FLAGS);
835 if (dwProvType < 0 || dwProvType > 999)
836 CRYPT_ReturnLastError(NTE_BAD_PROV_TYPE);
837 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)) )
838 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
839 if (RegOpenKeyA((dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE ,keyname, &hKey))
842 CRYPT_ReturnLastError(NTE_PROV_TYPE_NOT_DEF);
845 if (RegQueryValueExA(hKey, "Name", NULL, NULL, pszProvName, pcbProvName))
847 if (GetLastError() != ERROR_MORE_DATA)
848 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
855 /******************************************************************************
856 * CryptGetDefaultProviderW (ADVAPI32.@)
858 BOOL WINAPI CryptGetDefaultProviderW (DWORD dwProvType, DWORD *pdwReserved,
859 DWORD dwFlags, LPWSTR pszProvName, DWORD *pcbProvName)
865 TRACE("(%ld, %p, %08ld, %p, %p)\n", dwProvType, pdwReserved, dwFlags, pszProvName, pcbProvName);
867 strlen = *pcbProvName / sizeof(WCHAR);
868 if ( pszProvName && !(str = CRYPT_Alloc(strlen)) )
869 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
870 ret = CryptGetDefaultProviderA(dwProvType, pdwReserved, dwFlags, str, &strlen);
873 CRYPT_ANSIToUnicode(str, &pszProvName, *pcbProvName);
876 *pcbProvName = strlen * sizeof(WCHAR);
880 /******************************************************************************
881 * CryptGetHashParam (ADVAPI32.@)
883 BOOL WINAPI CryptGetHashParam (HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData,
884 DWORD *pdwDataLen, DWORD dwFlags)
887 PCRYPTHASH hash = (PCRYPTHASH)hHash;
889 TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hHash, dwParam, pbData, pdwDataLen, dwFlags);
891 if (!hash || !pdwDataLen)
892 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
894 prov = hash->pProvider;
895 return prov->pFuncs->pCPGetHashParam(prov->hPrivate, hash->hPrivate, dwParam,
896 pbData, pdwDataLen, dwFlags);
899 /******************************************************************************
900 * CryptGetKeyParam (ADVAPI32.@)
902 BOOL WINAPI CryptGetKeyParam (HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData,
903 DWORD *pdwDataLen, DWORD dwFlags)
906 PCRYPTKEY key = (PCRYPTKEY)hKey;
908 TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hKey, dwParam, pbData, pdwDataLen, dwFlags);
910 if (!key || !pdwDataLen)
911 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
913 prov = key->pProvider;
914 return prov->pFuncs->pCPGetKeyParam(prov->hPrivate, key->hPrivate, dwParam,
915 pbData, pdwDataLen, dwFlags);
918 /******************************************************************************
919 * CryptGetProvParam (ADVAPI32.@)
921 BOOL WINAPI CryptGetProvParam (HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData,
922 DWORD *pdwDataLen, DWORD dwFlags)
924 PCRYPTPROV prov = (PCRYPTPROV)hProv;
926 TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hProv, dwParam, pbData, pdwDataLen, dwFlags);
928 return prov->pFuncs->pCPGetProvParam(prov->hPrivate, dwParam, pbData, pdwDataLen, dwFlags);
931 /******************************************************************************
932 * CryptGetUserKey (ADVAPI32.@)
934 BOOL WINAPI CryptGetUserKey (HCRYPTPROV hProv, DWORD dwKeySpec, HCRYPTKEY *phUserKey)
936 PCRYPTPROV prov = (PCRYPTPROV)hProv;
939 TRACE("(0x%lx, %ld, %p)\n", hProv, dwKeySpec, phUserKey);
942 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
944 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
945 if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
946 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
948 key->pProvider = prov;
950 *phUserKey = (HCRYPTKEY)key;
951 if (prov->pFuncs->pCPGetUserKey(prov->hPrivate, dwKeySpec, &key->hPrivate))
959 /******************************************************************************
960 * CryptHashData (ADVAPI32.@)
962 BOOL WINAPI CryptHashData (HCRYPTHASH hHash, BYTE *pbData, DWORD dwDataLen, DWORD dwFlags)
964 PCRYPTHASH hash = (PCRYPTHASH)hHash;
967 TRACE("(0x%lx, %p, %ld, %08ld)\n", hHash, pbData, dwDataLen, dwFlags);
970 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
971 if (!pbData || !dwDataLen)
972 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
974 prov = hash->pProvider;
975 return prov->pFuncs->pCPHashData(prov->hPrivate, hash->hPrivate, pbData, dwDataLen, dwFlags);
978 /******************************************************************************
979 * CryptHashSessionKey (ADVAPI32.@)
981 BOOL WINAPI CryptHashSessionKey (HCRYPTHASH hHash, HCRYPTKEY hKey, DWORD dwFlags)
983 PCRYPTHASH hash = (PCRYPTHASH)hHash;
984 PCRYPTKEY key = (PCRYPTKEY)hKey;
987 TRACE("(0x%lx, 0x%lx, %08ld)\n", hHash, hKey, dwFlags);
990 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
992 prov = hash->pProvider;
993 return prov->pFuncs->pCPHashSessionKey(prov->hPrivate, hash->hPrivate, key->hPrivate, dwFlags);
996 /******************************************************************************
997 * CryptImportKey (ADVAPI32.@)
999 BOOL WINAPI CryptImportKey (HCRYPTPROV hProv, BYTE *pbData, DWORD dwDataLen,
1000 HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey)
1002 PCRYPTPROV prov = (PCRYPTPROV)hProv;
1003 PCRYPTKEY pubkey = (PCRYPTKEY)hPubKey, importkey;
1005 TRACE("(0x%lx, %p, %ld, 0x%lx, %08ld, %p)\n", hProv, pbData, dwDataLen, hPubKey, dwFlags, phKey);
1007 if (!prov || !pbData || !dwDataLen || !phKey)
1008 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1010 if ( !(importkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
1011 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1013 importkey->pProvider = prov;
1014 if (prov->pFuncs->pCPImportKey(prov->hPrivate, pbData, dwDataLen,
1015 pubkey ? pubkey->hPrivate : 0, dwFlags, &importkey->hPrivate))
1017 *phKey = (HCRYPTKEY)importkey;
1021 CRYPT_Free(importkey);
1025 /******************************************************************************
1028 * Note: Since the sDesciption (string) is supposed to be NULL and
1029 * is only retained for compatibility no string conversions are required
1030 * and only one implementation is required for both ANSI and Unicode.
1031 * We still need to export both:
1033 * CryptSignHashA (ADVAPI32.@)
1034 * CryptSignHashW (ADVAPI32.@)
1036 BOOL WINAPI CryptSignHashA (HCRYPTHASH hHash, DWORD dwKeySpec, LPCSTR sDescription,
1037 DWORD dwFlags, BYTE *pbSignature, DWORD *pdwSigLen)
1039 PCRYPTHASH hash = (PCRYPTHASH)hHash;
1042 TRACE("(0x%lx, %ld, %08ld, %p, %p)\n", hHash, dwKeySpec, dwFlags, pbSignature, pdwSigLen);
1044 WARN("The sDescription parameter is not supported (and no longer used). Ignoring.");
1047 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1049 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1051 prov = hash->pProvider;
1052 return prov->pFuncs->pCPSignHash(prov->hPrivate, hash->hPrivate, dwKeySpec, NULL,
1053 dwFlags, pbSignature, pdwSigLen);
1056 /******************************************************************************
1057 * CryptSetHashParam (ADVAPI32.@)
1059 BOOL WINAPI CryptSetHashParam (HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
1062 PCRYPTHASH hash = (PCRYPTHASH)hHash;
1064 TRACE("(0x%lx, %ld, %p, %08ld)\n", hHash, dwParam, pbData, dwFlags);
1066 if (!hash || !pbData)
1067 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1069 prov = hash->pProvider;
1070 return prov->pFuncs->pCPSetHashParam(prov->hPrivate, hash->hPrivate,
1071 dwParam, pbData, dwFlags);
1074 /******************************************************************************
1075 * CryptSetKeyParam (ADVAPI32.@)
1077 BOOL WINAPI CryptSetKeyParam (HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
1080 PCRYPTKEY key = (PCRYPTKEY)hKey;
1082 TRACE("(0x%lx, %ld, %p, %08ld)\n", hKey, dwParam, pbData, dwFlags);
1084 if (!key || !pbData)
1085 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1087 prov = key->pProvider;
1088 return prov->pFuncs->pCPSetKeyParam(prov->hPrivate, key->hPrivate,
1089 dwParam, pbData, dwFlags);
1092 /******************************************************************************
1093 * CryptSetProviderA (ADVAPI32.@)
1095 BOOL WINAPI CryptSetProviderA (LPCSTR pszProvName, DWORD dwProvType)
1097 TRACE("(%s, %ld)\n", pszProvName, dwProvType);
1098 return CryptSetProviderExA(pszProvName, dwProvType, NULL, CRYPT_USER_DEFAULT);
1101 /******************************************************************************
1102 * CryptSetProviderW (ADVAPI32.@)
1104 BOOL WINAPI CryptSetProviderW (LPCWSTR pszProvName, DWORD dwProvType)
1106 TRACE("(%s, %ld)\n", debugstr_w(pszProvName), dwProvType);
1107 return CryptSetProviderExW(pszProvName, dwProvType, NULL, CRYPT_USER_DEFAULT);
1110 /******************************************************************************
1111 * CryptSetProviderExA (ADVAPI32.@)
1113 BOOL WINAPI CryptSetProviderExA (LPCSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags)
1118 TRACE("(%s, %ld, %p, %08ld)\n", pszProvName, dwProvType, pdwReserved, dwFlags);
1120 if (!pszProvName || pdwReserved)
1121 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1122 if (dwProvType < 0 || dwProvType > MAXPROVTYPES)
1123 CRYPT_ReturnLastError(NTE_BAD_PROV_TYPE);
1124 if (dwFlags & ~(CRYPT_MACHINE_DEFAULT | CRYPT_USER_DEFAULT | CRYPT_DELETE_DEFAULT)
1125 || dwFlags == CRYPT_DELETE_DEFAULT)
1126 CRYPT_ReturnLastError(NTE_BAD_FLAGS);
1128 if (dwFlags & CRYPT_DELETE_DEFAULT)
1130 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)) )
1131 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1132 RegDeleteKeyA( (dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, keyname);
1133 CRYPT_Free(keyname);
1137 if ( !(keyname = CRYPT_GetProvKeyName(pszProvName)) )
1138 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1139 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, keyname, &hKey))
1141 CRYPT_Free(keyname);
1142 CRYPT_ReturnLastError(NTE_BAD_PROVIDER);
1144 CRYPT_Free(keyname);
1146 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)) )
1147 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1148 RegCreateKeyA( (dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, keyname, &hKey);
1149 CRYPT_Free(keyname);
1150 if (RegSetValueExA(hKey, "Name", 0, REG_SZ, pszProvName, strlen(pszProvName) +1))
1155 /******************************************************************************
1156 * CryptSetProviderExW (ADVAPI32.@)
1158 BOOL WINAPI CryptSetProviderExW (LPCWSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags)
1163 TRACE("(%s, %ld, %p, %08ld)\n", debugstr_w(pszProvName), dwProvType, pdwReserved, dwFlags);
1165 if (CRYPT_UnicodeToANSI(pszProvName, &str, -1))
1167 ret = CryptSetProviderExA(str, dwProvType, pdwReserved, dwFlags);
1173 /******************************************************************************
1174 * CryptSetProvParam (ADVAPI32.@)
1176 BOOL WINAPI CryptSetProvParam (HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
1178 PCRYPTPROV prov = (PCRYPTPROV)hProv;
1180 TRACE("(0x%lx, %ld, %p, %08ld)\n", hProv, dwParam, pbData, dwFlags);
1183 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1184 if (dwFlags & PP_USE_HARDWARE_RNG)
1186 FIXME("PP_USE_HARDWARE_RNG: What do I do with this?\n");
1187 FIXME("\tLetting the CSP decide.\n");
1189 if (dwFlags & PP_CLIENT_HWND)
1191 //FIXME: Should verify the parameter
1192 if (pbData /*&& IsWindow((HWND)pbData)*/)
1194 crypt_hWindow = (HWND)(pbData);
1197 SetLastError(ERROR_INVALID_PARAMETER);
1201 //All other flags go to the CSP
1202 return prov->pFuncs->pCPSetProvParam(prov->hPrivate, dwParam, pbData, dwFlags);
1205 /******************************************************************************
1206 * CryptVerifySignatureA
1208 * Note: Since the sDesciption (string) is supposed to be NULL and
1209 * is only retained for compatibility no string conversions are required
1210 * and only one implementation is required for both ANSI and Unicode.
1211 * We still need to export both:
1213 * CryptVerifySignatureA (ADVAPI32.@)
1214 * CryptVerifySignatureW (ADVAPI32.@)
1216 BOOL WINAPI CryptVerifySignatureA (HCRYPTHASH hHash, BYTE *pbSignature, DWORD dwSigLen,
1217 HCRYPTKEY hPubKey, LPCSTR sDescription, DWORD dwFlags)
1219 PCRYPTHASH hash = (PCRYPTHASH)hHash;
1220 PCRYPTKEY key = (PCRYPTKEY)hPubKey;
1223 TRACE("(0x%lx, %p, %ld, 0x%lx, %08ld)\n", hHash, pbSignature,
1224 dwSigLen, hPubKey, dwFlags);
1226 WARN("The sDescription parameter is not supported (and no longer used). Ignoring.");
1229 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1230 if (!pbSignature || !dwSigLen)
1231 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1233 prov = hash->pProvider;
1234 return prov->pFuncs->pCPVerifySignature(prov->hPrivate, hash->hPrivate, pbSignature, dwSigLen,
1235 key->hPrivate, NULL, dwFlags);