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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 /***********************************************************************
23 * - Reference counting
28 WINE_DEFAULT_DEBUG_CHANNEL(crypt
);
32 * Note: this code is harmless on little-endian machines.
34 VOID
byteReverse(unsigned char *buf
, unsigned longs
)
40 t
= (unsigned int)((unsigned)buf
[3] << 8 | buf
[2]) << 16 |
41 ((unsigned)buf
[1] << 8 | buf
[0]);
42 *(unsigned int *)buf
= t
;
47 static HWND crypt_hWindow
;
49 #define CRYPT_Alloc(size) (LocalAlloc(LMEM_ZEROINIT, size))
50 #define CRYPT_Free(buffer) (LocalFree(buffer))
52 static inline PWSTR
CRYPT_GetProvKeyName(PCWSTR pProvName
)
54 static const WCHAR KEYSTR
[] = {
55 'S','o','f','t','w','a','r','e','\\',
56 'M','i','c','r','o','s','o','f','t','\\',
57 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
58 'D','e','f','a','u','l','t','s','\\',
59 'P','r','o','v','i','d','e','r','\\',0
63 keyname
= CRYPT_Alloc((strlenW(KEYSTR
) + strlenW(pProvName
) +1)*sizeof(WCHAR
));
66 strcpyW(keyname
, KEYSTR
);
67 strcpyW(keyname
+ strlenW(KEYSTR
), pProvName
);
69 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
73 static inline PWSTR
CRYPT_GetTypeKeyName(DWORD dwType
, BOOL user
)
75 static const WCHAR MACHINESTR
[] = {
76 'S','o','f','t','w','a','r','e','\\',
77 'M','i','c','r','o','s','o','f','t','\\',
78 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
79 'D','e','f','a','u','l','t','s','\\',
80 'P','r','o','v','i','d','e','r',' ','T','y','p','e','s','\\',
81 'T','y','p','e',' ','X','X','X',0
83 static const WCHAR USERSTR
[] = {
84 'S','o','f','t','w','a','r','e','\\',
85 'M','i','c','r','o','s','o','f','t','\\',
86 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
87 'P','r','o','v','i','d','e','r',' ','T','y','p','e',' ','X','X','X',0
92 keyname
= CRYPT_Alloc( ((user
? strlenW(USERSTR
) : strlenW(MACHINESTR
)) +1)*sizeof(WCHAR
));
95 user
? strcpyW(keyname
, USERSTR
) : strcpyW(keyname
, MACHINESTR
);
96 ptr
= keyname
+ strlenW(keyname
);
97 *(--ptr
) = (dwType
% 10) + '0';
98 *(--ptr
) = ((dwType
/ 10) % 10) + '0';
99 *(--ptr
) = (dwType
/ 100) + '0';
101 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
105 /* CRYPT_UnicodeTOANSI
106 * wstr - unicode string
107 * str - pointer to ANSI string
108 * strsize - size of buffer pointed to by str or -1 if we have to do the allocation
110 * returns TRUE if unsuccessful, FALSE otherwise.
111 * if wstr is NULL, returns TRUE and sets str to NULL! Value of str should be checked after call
113 static inline BOOL
CRYPT_UnicodeToANSI(LPCWSTR wstr
, LPSTR
* str
, int strsize
)
122 count
= WideCharToMultiByte(CP_ACP
, 0, wstr
, -1, NULL
, 0, NULL
, NULL
);
124 *str
= CRYPT_Alloc(count
* sizeof(CHAR
));
126 count
= min( count
, strsize
);
129 WideCharToMultiByte(CP_ACP
, 0, wstr
, -1, *str
, count
, NULL
, NULL
);
132 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
136 /* CRYPT_ANSITOUnicode
138 * wstr - pointer to unicode string
139 * wstrsize - size of buffer pointed to by wstr or -1 if we have to do the allocation
141 static inline BOOL
CRYPT_ANSIToUnicode(LPCSTR str
, LPWSTR
* wstr
, int wstrsize
)
150 wcount
= MultiByteToWideChar(CP_ACP
, 0, str
, -1, NULL
, 0);
152 *wstr
= CRYPT_Alloc(wcount
* sizeof(WCHAR
));
154 wcount
= min( wcount
, wstrsize
/sizeof(WCHAR
) );
157 MultiByteToWideChar(CP_ACP
, 0, str
, -1, *wstr
, wcount
);
160 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
164 /* These next 2 functions are used by the VTableProvStruc structure */
165 static BOOL CALLBACK
CRYPT_VerifyImage(LPCSTR lpszImage
, BYTE
* pData
)
167 if (!lpszImage
|| !pData
)
169 SetLastError(ERROR_INVALID_PARAMETER
);
173 FIXME("(%s, %p): not verifying image\n", lpszImage
, pData
);
178 static BOOL CALLBACK
CRYPT_ReturnhWnd(HWND
*phWnd
)
182 *phWnd
= crypt_hWindow
;
186 #define CRYPT_GetProvFunc(name) \
187 if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error
188 #define CRYPT_GetProvFuncOpt(name) \
189 provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)
190 static PCRYPTPROV
CRYPT_LoadProvider(PCWSTR pImage
)
193 DWORD errorcode
= ERROR_NOT_ENOUGH_MEMORY
;
195 if ( !(provider
= CRYPT_Alloc(sizeof(CRYPTPROV
))) ) goto error
;
196 if ( !(provider
->pFuncs
= CRYPT_Alloc(sizeof(PROVFUNCS
))) ) goto error
;
197 if ( !(provider
->pVTable
= CRYPT_Alloc(sizeof(VTableProvStruc
))) ) goto error
;
198 if ( !(provider
->hModule
= LoadLibraryW(pImage
)) )
200 errorcode
= (GetLastError() == ERROR_FILE_NOT_FOUND
) ? NTE_PROV_DLL_NOT_FOUND
: NTE_PROVIDER_DLL_FAIL
;
201 FIXME("Failed to load dll %s\n", debugstr_w(pImage
));
204 provider
->dwMagic
= MAGIC_CRYPTPROV
;
205 provider
->refcount
= 1;
207 errorcode
= NTE_PROVIDER_DLL_FAIL
;
208 CRYPT_GetProvFunc(CPAcquireContext
);
209 CRYPT_GetProvFunc(CPCreateHash
);
210 CRYPT_GetProvFunc(CPDecrypt
);
211 CRYPT_GetProvFunc(CPDeriveKey
);
212 CRYPT_GetProvFunc(CPDestroyHash
);
213 CRYPT_GetProvFunc(CPDestroyKey
);
214 CRYPT_GetProvFuncOpt(CPDuplicateHash
);
215 CRYPT_GetProvFuncOpt(CPDuplicateKey
);
216 CRYPT_GetProvFunc(CPEncrypt
);
217 CRYPT_GetProvFunc(CPExportKey
);
218 CRYPT_GetProvFunc(CPGenKey
);
219 CRYPT_GetProvFunc(CPGenRandom
);
220 CRYPT_GetProvFunc(CPGetHashParam
);
221 CRYPT_GetProvFunc(CPGetKeyParam
);
222 CRYPT_GetProvFunc(CPGetProvParam
);
223 CRYPT_GetProvFunc(CPGetUserKey
);
224 CRYPT_GetProvFunc(CPHashData
);
225 CRYPT_GetProvFunc(CPHashSessionKey
);
226 CRYPT_GetProvFunc(CPImportKey
);
227 CRYPT_GetProvFunc(CPReleaseContext
);
228 CRYPT_GetProvFunc(CPSetHashParam
);
229 CRYPT_GetProvFunc(CPSetKeyParam
);
230 CRYPT_GetProvFunc(CPSetProvParam
);
231 CRYPT_GetProvFunc(CPSignHash
);
232 CRYPT_GetProvFunc(CPVerifySignature
);
234 /* FIXME: Not sure what the pbContextInfo field is for.
235 * Does it need memory allocation?
237 provider
->pVTable
->Version
= 3;
238 provider
->pVTable
->FuncVerifyImage
= CRYPT_VerifyImage
;
239 provider
->pVTable
->FuncReturnhWnd
= CRYPT_ReturnhWnd
;
240 provider
->pVTable
->dwProvType
= 0;
241 provider
->pVTable
->pbContextInfo
= NULL
;
242 provider
->pVTable
->cbContextInfo
= 0;
243 provider
->pVTable
->pszProvName
= NULL
;
247 SetLastError(errorcode
);
250 provider
->dwMagic
= 0;
251 if (provider
->hModule
)
252 FreeLibrary(provider
->hModule
);
253 CRYPT_Free(provider
->pVTable
);
254 CRYPT_Free(provider
->pFuncs
);
255 CRYPT_Free(provider
);
259 #undef CRYPT_GetProvFunc
260 #undef CRYPT_GetProvFuncOpt
263 static void CRYPT_CreateMachineGuid(void)
265 static const WCHAR cryptographyW
[] = {
266 'S','o','f','t','w','a','r','e','\\',
267 'M','i','c','r','o','s','o','f','t','\\',
268 'C','r','y','p','t','o','g','r','a','p','h','y',0 };
269 static const WCHAR machineGuidW
[] = {
270 'M','a','c','h','i','n','e','G','u','i','d',0 };
274 r
= RegOpenKeyExW(HKEY_LOCAL_MACHINE
, cryptographyW
, 0, KEY_ALL_ACCESS
,
280 r
= RegQueryValueExW(key
, machineGuidW
, NULL
, NULL
, NULL
, &size
);
281 if (r
== ERROR_FILE_NOT_FOUND
)
286 static const WCHAR uuidFmt
[] = {
287 '%','0','8','x','-','%','0','4','x','-',
288 '%','0','4','x','-','%','0','2','x',
289 '%','0','2','x','-','%','0','2','x',
290 '%','0','2','x','%','0','2','x',
291 '%','0','2','x','%','0','2','x',
294 rs
= UuidCreate(&uuid
);
297 sprintfW(buf
, uuidFmt
,
298 uuid
.Data1
, uuid
.Data2
, uuid
.Data3
,
299 uuid
.Data4
[0], uuid
.Data4
[1],
300 uuid
.Data4
[2], uuid
.Data4
[3],
301 uuid
.Data4
[4], uuid
.Data4
[5],
302 uuid
.Data4
[6], uuid
.Data4
[7] );
303 RegSetValueExW(key
, machineGuidW
, 0, REG_SZ
,
305 (lstrlenW(buf
)+1)*sizeof(WCHAR
));
312 /******************************************************************************
313 * CryptAcquireContextW (ADVAPI32.@)
315 * Acquire a crypto provider context handle.
318 * phProv [O] Pointer to HCRYPTPROV for the output.
319 * pszContainer [I] Key Container Name
320 * pszProvider [I] Cryptographic Service Provider Name
321 * dwProvType [I] Crypto provider type to get a handle.
322 * dwFlags [I] flags for the operation
325 * TRUE on success, FALSE on failure.
327 BOOL WINAPI
CryptAcquireContextW (HCRYPTPROV
*phProv
, LPCWSTR pszContainer
,
328 LPCWSTR pszProvider
, DWORD dwProvType
, DWORD dwFlags
)
330 PCRYPTPROV pProv
= NULL
;
332 PWSTR imagepath
= NULL
, keyname
= NULL
, provname
= NULL
, temp
= NULL
;
333 PSTR provnameA
= NULL
, pszContainerA
= NULL
;
334 DWORD keytype
, type
, len
;
336 static const WCHAR nameW
[] = {'N','a','m','e',0};
337 static const WCHAR typeW
[] = {'T','y','p','e',0};
338 static const WCHAR imagepathW
[] = {'I','m','a','g','e',' ','P','a','t','h',0};
340 TRACE("(%p, %s, %s, %d, %08x)\n", phProv
, debugstr_w(pszContainer
),
341 debugstr_w(pszProvider
), dwProvType
, dwFlags
);
343 if (dwProvType
< 1 || dwProvType
> MAXPROVTYPES
)
345 SetLastError(NTE_BAD_PROV_TYPE
);
351 SetLastError(ERROR_INVALID_PARAMETER
);
355 /* Make sure the MachineGuid value exists */
356 CRYPT_CreateMachineGuid();
358 if (!pszProvider
|| !*pszProvider
)
360 /* No CSP name specified so try the user default CSP first
361 * then try the machine default CSP
363 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, TRUE
)) ) {
364 TRACE("No provider registered for crypto provider type %d.\n", dwProvType
);
365 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
368 if (RegOpenKeyW(HKEY_CURRENT_USER
, keyname
, &key
))
371 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, FALSE
)) ) {
372 TRACE("No type registered for crypto provider type %d.\n", dwProvType
);
374 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
377 if (RegOpenKeyW(HKEY_LOCAL_MACHINE
, keyname
, &key
)) {
378 TRACE("Did not find registry entry of crypto provider for %s.\n", debugstr_w(keyname
));
381 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
386 r
= RegQueryValueExW(key
, nameW
, NULL
, &keytype
, NULL
, &len
);
387 if( r
!= ERROR_SUCCESS
|| !len
|| keytype
!= REG_SZ
)
389 TRACE("error %d reading size of 'Name' from registry\n", r
);
391 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
394 if(!(provname
= CRYPT_Alloc(len
)))
397 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
400 r
= RegQueryValueExW(key
, nameW
, NULL
, NULL
, (LPBYTE
)provname
, &len
);
401 if( r
!= ERROR_SUCCESS
)
403 TRACE("error %d reading 'Name' from registry\n", r
);
405 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
410 if ( !(provname
= CRYPT_Alloc((strlenW(pszProvider
) +1)*sizeof(WCHAR
))) )
412 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
415 strcpyW(provname
, pszProvider
);
418 keyname
= CRYPT_GetProvKeyName(provname
);
419 r
= RegOpenKeyW(HKEY_LOCAL_MACHINE
, keyname
, &key
);
421 if (r
!= ERROR_SUCCESS
)
423 SetLastError(NTE_KEYSET_NOT_DEF
);
427 r
= RegQueryValueExW(key
, typeW
, NULL
, NULL
, (BYTE
*)&type
, &len
);
428 if (r
!= ERROR_SUCCESS
)
430 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
433 if (type
!= dwProvType
)
435 TRACE("Crypto provider has wrong type (%d vs expected %d).\n", type
, dwProvType
);
436 SetLastError(NTE_PROV_TYPE_NO_MATCH
);
440 r
= RegQueryValueExW(key
, imagepathW
, NULL
, &keytype
, NULL
, &len
);
441 if ( r
!= ERROR_SUCCESS
|| keytype
!= REG_SZ
)
443 TRACE("error %d reading size of 'Image Path' from registry\n", r
);
445 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
448 if (!(temp
= CRYPT_Alloc(len
)))
451 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
454 r
= RegQueryValueExW(key
, imagepathW
, NULL
, NULL
, (LPBYTE
)temp
, &len
);
455 if( r
!= ERROR_SUCCESS
)
457 TRACE("error %d reading 'Image Path' from registry\n", r
);
459 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
463 len
= ExpandEnvironmentStringsW(temp
, NULL
, 0);
464 if ( !(imagepath
= CRYPT_Alloc(len
*sizeof(WCHAR
))) )
466 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
469 if (!ExpandEnvironmentStringsW(temp
, imagepath
, len
))
471 /* ExpandEnvironmentStrings will call SetLastError */
474 pProv
= CRYPT_LoadProvider(imagepath
);
476 /* CRYPT_LoadProvider calls SetLastError */
479 pProv
->pVTable
->dwProvType
= dwProvType
;
480 if(!CRYPT_UnicodeToANSI(provname
, &provnameA
, -1))
482 /* CRYPT_UnicodeToANSI calls SetLastError */
485 pProv
->pVTable
->pszProvName
= provnameA
;
486 if(!CRYPT_UnicodeToANSI(pszContainer
, &pszContainerA
, -1))
488 /* CRYPT_UnicodeToANSI calls SetLastError */
491 if (pProv
->pFuncs
->pCPAcquireContext(&pProv
->hPrivate
, pszContainerA
, dwFlags
, pProv
->pVTable
))
493 /* MSDN: When this flag is set, the value returned in phProv is undefined,
494 * and thus, the CryptReleaseContext function need not be called afterwards.
495 * Therefore, we must clean up everything now.
497 if (dwFlags
& CRYPT_DELETEKEYSET
)
500 FreeLibrary(pProv
->hModule
);
501 CRYPT_Free(provnameA
);
502 CRYPT_Free(pProv
->pVTable
);
503 CRYPT_Free(pProv
->pFuncs
);
506 *phProv
= (HCRYPTPROV
)pProv
;
508 CRYPT_Free(pszContainerA
);
509 CRYPT_Free(provname
);
511 CRYPT_Free(imagepath
);
514 /* FALLTHROUGH TO ERROR IF FALSE - CSP internal error! */
520 FreeLibrary(pProv
->hModule
);
521 CRYPT_Free(pProv
->pVTable
);
522 CRYPT_Free(pProv
->pFuncs
);
525 CRYPT_Free(pszContainerA
);
526 CRYPT_Free(provnameA
);
527 CRYPT_Free(provname
);
529 CRYPT_Free(imagepath
);
533 /******************************************************************************
534 * CryptAcquireContextA (ADVAPI32.@)
536 * See CryptAcquireContextW.
538 BOOL WINAPI
CryptAcquireContextA (HCRYPTPROV
*phProv
, LPCSTR pszContainer
,
539 LPCSTR pszProvider
, DWORD dwProvType
, DWORD dwFlags
)
541 PWSTR pProvider
= NULL
, pContainer
= NULL
;
544 TRACE("(%p, %s, %s, %d, %08x)\n", phProv
, pszContainer
,
545 pszProvider
, dwProvType
, dwFlags
);
547 if ( !CRYPT_ANSIToUnicode(pszContainer
, &pContainer
, -1) )
549 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
552 if ( !CRYPT_ANSIToUnicode(pszProvider
, &pProvider
, -1) )
554 CRYPT_Free(pContainer
);
555 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
559 ret
= CryptAcquireContextW(phProv
, pContainer
, pProvider
, dwProvType
, dwFlags
);
561 CRYPT_Free(pContainer
);
562 CRYPT_Free(pProvider
);
567 /******************************************************************************
568 * CryptContextAddRef (ADVAPI32.@)
570 * Increases reference count of a cryptographic service provider handle
574 * hProv [I] Handle to the CSP whose reference is being incremented.
575 * pdwReserved [IN] Reserved for future use and must be NULL.
576 * dwFlags [I] Reserved for future use and must be NULL.
582 BOOL WINAPI
CryptContextAddRef (HCRYPTPROV hProv
, DWORD
*pdwReserved
, DWORD dwFlags
)
584 PCRYPTPROV pProv
= (PCRYPTPROV
)hProv
;
586 TRACE("(0x%lx, %p, %08x)\n", hProv
, pdwReserved
, dwFlags
);
590 SetLastError(NTE_BAD_UID
);
594 if (pProv
->dwMagic
!= MAGIC_CRYPTPROV
)
596 SetLastError(ERROR_INVALID_PARAMETER
);
604 /******************************************************************************
605 * CryptReleaseContext (ADVAPI32.@)
607 * Releases the handle of a CSP. Reference count is decreased.
610 * hProv [I] Handle of a CSP.
611 * dwFlags [I] Reserved for future use and must be NULL.
617 BOOL WINAPI
CryptReleaseContext (HCRYPTPROV hProv
, DWORD dwFlags
)
619 PCRYPTPROV pProv
= (PCRYPTPROV
)hProv
;
622 TRACE("(0x%lx, %08lx)\n", hProv
, dwFlags
);
626 SetLastError(NTE_BAD_UID
);
630 if (pProv
->dwMagic
!= MAGIC_CRYPTPROV
)
632 SetLastError(ERROR_INVALID_PARAMETER
);
637 if (pProv
->refcount
<= 0)
639 ret
= pProv
->pFuncs
->pCPReleaseContext(pProv
->hPrivate
, dwFlags
);
641 FreeLibrary(pProv
->hModule
);
643 CRYPT_Free(pProv
->pVTable
->pContextInfo
);
645 CRYPT_Free(pProv
->pVTable
->pszProvName
);
646 CRYPT_Free(pProv
->pVTable
);
647 CRYPT_Free(pProv
->pFuncs
);
653 /******************************************************************************
654 * CryptGenRandom (ADVAPI32.@)
656 * Fills a buffer with cryptographically random bytes.
659 * hProv [I] Handle of a CSP.
660 * dwLen [I] Number of bytes to generate.
661 * pbBuffer [I/O] Buffer to contain random bytes.
668 * pdBuffer must be at least dwLen bytes long.
670 BOOL WINAPI
CryptGenRandom (HCRYPTPROV hProv
, DWORD dwLen
, BYTE
*pbBuffer
)
672 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
674 TRACE("(0x%lx, %d, %p)\n", hProv
, dwLen
, pbBuffer
);
678 SetLastError(ERROR_INVALID_HANDLE
);
682 if (prov
->dwMagic
!= MAGIC_CRYPTPROV
)
684 SetLastError(ERROR_INVALID_PARAMETER
);
688 return prov
->pFuncs
->pCPGenRandom(prov
->hPrivate
, dwLen
, pbBuffer
);
691 /******************************************************************************
692 * CryptCreateHash (ADVAPI32.@)
694 * Initiates the hashing of a stream of data.
697 * hProv [I] Handle of a CSP.
698 * Algid [I] Identifies the hash algorithm to use.
699 * hKey [I] Key for the hash (if required).
700 * dwFlags [I] Reserved for future use and must be NULL.
701 * phHash [O] Address of the future handle to the new hash object.
708 * If the algorithm is a keyed hash, hKey is the key.
710 BOOL WINAPI
CryptCreateHash (HCRYPTPROV hProv
, ALG_ID Algid
, HCRYPTKEY hKey
,
711 DWORD dwFlags
, HCRYPTHASH
*phHash
)
713 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
714 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
717 TRACE("(0x%lx, 0x%x, 0x%lx, %08x, %p)\n", hProv
, Algid
, hKey
, dwFlags
, phHash
);
721 SetLastError(ERROR_INVALID_HANDLE
);
724 if (!phHash
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
726 SetLastError(ERROR_INVALID_PARAMETER
);
731 SetLastError(NTE_BAD_FLAGS
);
734 if ( !(hash
= CRYPT_Alloc(sizeof(CRYPTHASH
))) )
736 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
740 hash
->pProvider
= prov
;
742 if (prov
->pFuncs
->pCPCreateHash(prov
->hPrivate
, Algid
,
743 key
? key
->hPrivate
: 0, 0, &hash
->hPrivate
))
745 *phHash
= (HCRYPTHASH
)hash
;
755 /******************************************************************************
756 * CryptDecrypt (ADVAPI32.@)
758 * Decrypts data encrypted by CryptEncrypt.
761 * hKey [I] Handle to the decryption key.
762 * hHash [I] Handle to a hash object.
763 * Final [I] TRUE if this is the last section to be decrypted.
764 * dwFlags [I] Reserved for future use. Can be CRYPT_OAEP.
765 * pbData [I/O] Buffer that holds the encrypted data. Holds decrypted
767 * pdwDataLen [I/O] Length of pbData before and after the call.
773 BOOL WINAPI
CryptDecrypt (HCRYPTKEY hKey
, HCRYPTHASH hHash
, BOOL Final
,
774 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
)
777 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
778 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
780 TRACE("(0x%lx, 0x%lx, %d, %08x, %p, %p)\n", hKey
, hHash
, Final
, dwFlags
, pbData
, pdwDataLen
);
782 if (!key
|| !pbData
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
784 SetLastError(ERROR_INVALID_PARAMETER
);
788 prov
= key
->pProvider
;
789 return prov
->pFuncs
->pCPDecrypt(prov
->hPrivate
, key
->hPrivate
, hash
? hash
->hPrivate
: 0,
790 Final
, dwFlags
, pbData
, pdwDataLen
);
793 /******************************************************************************
794 * CryptDeriveKey (ADVAPI32.@)
796 * Generates session keys derived from a base data value.
799 * hProv [I] Handle to a CSP.
800 * Algid [I] Identifies the symmetric encryption algorithm to use.
801 * hBaseData [I] Handle to a hash object.
802 * dwFlags [I] Type of key to generate.
803 * phKey [I/O] Address of the newly generated key.
809 BOOL WINAPI
CryptDeriveKey (HCRYPTPROV hProv
, ALG_ID Algid
, HCRYPTHASH hBaseData
,
810 DWORD dwFlags
, HCRYPTKEY
*phKey
)
812 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
813 PCRYPTHASH hash
= (PCRYPTHASH
)hBaseData
;
816 TRACE("(0x%lx, 0x%08x, 0x%lx, 0x%08x, %p)\n", hProv
, Algid
, hBaseData
, dwFlags
, phKey
);
820 SetLastError(ERROR_INVALID_HANDLE
);
823 if (!phKey
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
825 SetLastError(ERROR_INVALID_PARAMETER
);
828 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
830 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
834 key
->pProvider
= prov
;
835 if (prov
->pFuncs
->pCPDeriveKey(prov
->hPrivate
, Algid
, hash
->hPrivate
, dwFlags
, &key
->hPrivate
))
837 *phKey
= (HCRYPTKEY
)key
;
847 /******************************************************************************
848 * CryptDestroyHash (ADVAPI32.@)
850 * Destroys the hash object referenced by hHash.
853 * hHash [I] Handle of the hash object to be destroyed.
859 BOOL WINAPI
CryptDestroyHash (HCRYPTHASH hHash
)
861 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
865 TRACE("(0x%lx)\n", hHash
);
869 SetLastError(ERROR_INVALID_HANDLE
);
873 if (!hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
875 SetLastError(ERROR_INVALID_PARAMETER
);
879 prov
= hash
->pProvider
;
880 ret
= prov
->pFuncs
->pCPDestroyHash(prov
->hPrivate
, hash
->hPrivate
);
885 /******************************************************************************
886 * CryptDestroyKey (ADVAPI32.@)
888 * Releases the handle referenced by hKey.
891 * hKey [I] Handle of the key to be destroyed.
897 BOOL WINAPI
CryptDestroyKey (HCRYPTKEY hKey
)
899 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
903 TRACE("(0x%lx)\n", hKey
);
907 SetLastError(ERROR_INVALID_HANDLE
);
911 if (!key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
913 SetLastError(ERROR_INVALID_PARAMETER
);
917 prov
= key
->pProvider
;
918 ret
= prov
->pFuncs
->pCPDestroyKey(prov
->hPrivate
, key
->hPrivate
);
923 /******************************************************************************
924 * CryptDuplicateHash (ADVAPI32.@)
929 * hHash [I] Handle to the hash to be copied.
930 * pdwReserved [I] Reserved for future use and must be zero.
931 * dwFlags [I] Reserved for future use and must be zero.
932 * phHash [O] Address of the handle to receive the copy.
938 BOOL WINAPI
CryptDuplicateHash (HCRYPTHASH hHash
, DWORD
*pdwReserved
,
939 DWORD dwFlags
, HCRYPTHASH
*phHash
)
942 PCRYPTHASH orghash
, newhash
;
944 TRACE("(0x%lx, %p, %08x, %p)\n", hHash
, pdwReserved
, dwFlags
, phHash
);
946 orghash
= (PCRYPTHASH
)hHash
;
947 if (!orghash
|| pdwReserved
|| !phHash
|| !orghash
->pProvider
||
948 orghash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
950 SetLastError(ERROR_INVALID_PARAMETER
);
954 prov
= orghash
->pProvider
;
955 if (!prov
->pFuncs
->pCPDuplicateHash
)
957 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
961 if ( !(newhash
= CRYPT_Alloc(sizeof(CRYPTHASH
))) )
963 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
967 newhash
->pProvider
= prov
;
968 if (prov
->pFuncs
->pCPDuplicateHash(prov
->hPrivate
, orghash
->hPrivate
, pdwReserved
, dwFlags
, &newhash
->hPrivate
))
970 *phHash
= (HCRYPTHASH
)newhash
;
977 /******************************************************************************
978 * CryptDuplicateKey (ADVAPI32.@)
980 * Duplicate a key and the key's state.
983 * hKey [I] Handle of the key to copy.
984 * pdwReserved [I] Reserved for future use and must be NULL.
985 * dwFlags [I] Reserved for future use and must be zero.
986 * phKey [I] Address of the handle to the duplicated key.
992 BOOL WINAPI
CryptDuplicateKey (HCRYPTKEY hKey
, DWORD
*pdwReserved
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
995 PCRYPTKEY orgkey
, newkey
;
997 TRACE("(0x%lx, %p, %08x, %p)\n", hKey
, pdwReserved
, dwFlags
, phKey
);
999 orgkey
= (PCRYPTKEY
)hKey
;
1000 if (!orgkey
|| pdwReserved
|| !phKey
|| !orgkey
->pProvider
||
1001 orgkey
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1003 SetLastError(ERROR_INVALID_PARAMETER
);
1007 prov
= orgkey
->pProvider
;
1008 if (!prov
->pFuncs
->pCPDuplicateKey
)
1010 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1014 if ( !(newkey
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1016 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1020 newkey
->pProvider
= prov
;
1021 if (prov
->pFuncs
->pCPDuplicateKey(prov
->hPrivate
, orgkey
->hPrivate
, pdwReserved
, dwFlags
, &newkey
->hPrivate
))
1023 *phKey
= (HCRYPTKEY
)newkey
;
1030 /******************************************************************************
1031 * CryptEncrypt (ADVAPI32.@)
1036 * hKey [I] Handle to the encryption key.
1037 * hHash [I] Handle to a hash object.
1038 * Final [I] TRUE if this is the last section to encrypt.
1039 * dwFlags [I] Can be CRYPT_OAEP.
1040 * pbData [I/O] Data to be encrypted. Contains encrypted data after call.
1041 * pdwDataLen [I/O] Length of the data to encrypt. Contains the length of the
1042 * encrypted data after call.
1043 * dwBufLen [I] Length of the input pbData buffer.
1050 * If pbData is NULL, CryptEncrypt determines stores the number of bytes
1051 * required for the returned data in pdwDataLen.
1053 BOOL WINAPI
CryptEncrypt (HCRYPTKEY hKey
, HCRYPTHASH hHash
, BOOL Final
,
1054 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
, DWORD dwBufLen
)
1057 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1058 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1060 TRACE("(0x%lx, 0x%lx, %d, %08x, %p, %p, %d)\n", hKey
, hHash
, Final
, dwFlags
, pbData
, pdwDataLen
, dwBufLen
);
1062 if (!key
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1064 SetLastError(ERROR_INVALID_PARAMETER
);
1068 prov
= key
->pProvider
;
1069 return prov
->pFuncs
->pCPEncrypt(prov
->hPrivate
, key
->hPrivate
, hash
? hash
->hPrivate
: 0,
1070 Final
, dwFlags
, pbData
, pdwDataLen
, dwBufLen
);
1073 /******************************************************************************
1074 * CryptEnumProvidersW (ADVAPI32.@)
1076 * Returns the next available CSP.
1079 * dwIndex [I] Index of the next provider to be enumerated.
1080 * pdwReserved [I] Reserved for future use and must be NULL.
1081 * dwFlags [I] Reserved for future use and must be zero.
1082 * pdwProvType [O] DWORD designating the type of the provider.
1083 * pszProvName [O] Buffer that receives data from the provider.
1084 * pcbProvName [I/O] Specifies the size of pszProvName. Contains the number
1085 * of bytes stored in the buffer on return.
1092 * If pszProvName is NULL, CryptEnumProvidersW sets the size of the name
1093 * for memory allocation purposes.
1095 BOOL WINAPI
CryptEnumProvidersW (DWORD dwIndex
, DWORD
*pdwReserved
,
1096 DWORD dwFlags
, DWORD
*pdwProvType
, LPWSTR pszProvName
, DWORD
*pcbProvName
)
1099 static const WCHAR providerW
[] = {
1100 'S','o','f','t','w','a','r','e','\\',
1101 'M','i','c','r','o','s','o','f','t','\\',
1102 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
1103 'D','e','f','a','u','l','t','s','\\',
1104 'P','r','o','v','i','d','e','r',0
1106 static const WCHAR typeW
[] = {'T','y','p','e',0};
1109 TRACE("(%d, %p, %d, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
1110 pdwProvType
, pszProvName
, pcbProvName
);
1112 if (pdwReserved
|| !pcbProvName
)
1114 SetLastError(ERROR_INVALID_PARAMETER
);
1119 SetLastError(NTE_BAD_FLAGS
);
1123 if (RegOpenKeyW(HKEY_LOCAL_MACHINE
, providerW
, &hKey
))
1125 SetLastError(NTE_FAIL
);
1135 RegQueryInfoKeyW(hKey
, NULL
, NULL
, NULL
, &numkeys
, pcbProvName
,
1136 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
1138 if (!(provNameW
= CRYPT_Alloc(*pcbProvName
* sizeof(WCHAR
))))
1140 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1145 RegEnumKeyExW(hKey
, dwIndex
, provNameW
, pcbProvName
, NULL
, NULL
, NULL
, NULL
);
1146 CRYPT_Free(provNameW
);
1148 *pcbProvName
*= sizeof(WCHAR
);
1150 if (dwIndex
>= numkeys
)
1152 SetLastError(ERROR_NO_MORE_ITEMS
);
1156 DWORD size
= sizeof(DWORD
);
1160 result
= RegEnumKeyW(hKey
, dwIndex
, pszProvName
, *pcbProvName
/ sizeof(WCHAR
));
1163 SetLastError(result
);
1167 if (RegOpenKeyW(hKey
, pszProvName
, &subkey
))
1173 if (RegQueryValueExW(subkey
, typeW
, NULL
, NULL
, (BYTE
*)pdwProvType
, &size
))
1176 RegCloseKey(subkey
);
1182 /******************************************************************************
1183 * CryptEnumProvidersA (ADVAPI32.@)
1185 * See CryptEnumProvidersW.
1187 BOOL WINAPI
CryptEnumProvidersA (DWORD dwIndex
, DWORD
*pdwReserved
,
1188 DWORD dwFlags
, DWORD
*pdwProvType
, LPSTR pszProvName
, DWORD
*pcbProvName
)
1192 BOOL ret
; /* = FALSE; */
1194 TRACE("(%d, %p, %08x, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
1195 pdwProvType
, pszProvName
, pcbProvName
);
1197 if(!CryptEnumProvidersW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, NULL
, &bufsize
))
1199 if ( pszProvName
&& !(str
= CRYPT_Alloc(bufsize
)) )
1201 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1204 ret
= CryptEnumProvidersW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, str
, &bufsize
);
1206 CRYPT_UnicodeToANSI(str
, &pszProvName
, *pcbProvName
);
1207 *pcbProvName
= bufsize
/ sizeof(WCHAR
); /* FIXME: not correct */
1211 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1213 SetLastError(ERROR_MORE_DATA
);
1220 /******************************************************************************
1221 * CryptEnumProviderTypesW (ADVAPI32.@)
1223 * Retrieves the next type of CSP supported.
1226 * dwIndex [I] Index of the next provider to be enumerated.
1227 * pdwReserved [I] Reserved for future use and must be NULL.
1228 * dwFlags [I] Reserved for future use and must be zero.
1229 * pdwProvType [O] DWORD designating the type of the provider.
1230 * pszTypeName [O] Buffer that receives data from the provider type.
1231 * pcbTypeName [I/O] Specifies the size of pszTypeName. Contains the number
1232 * of bytes stored in the buffer on return.
1239 * If pszTypeName is NULL, CryptEnumProviderTypesW sets the size of the name
1240 * for memory allocation purposes.
1242 BOOL WINAPI
CryptEnumProviderTypesW (DWORD dwIndex
, DWORD
*pdwReserved
,
1243 DWORD dwFlags
, DWORD
*pdwProvType
, LPWSTR pszTypeName
, DWORD
*pcbTypeName
)
1246 DWORD keylen
, numkeys
, dwType
;
1249 static const WCHAR KEYSTR
[] = {
1250 'S','o','f','t','w','a','r','e','\\',
1251 'M','i','c','r','o','s','o','f','t','\\',
1252 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
1253 'D','e','f','a','u','l','t','s','\\',
1254 'P','r','o','v','i','d','e','r',' ','T','y','p','e','s',0
1256 static const WCHAR typenameW
[] = {'T','y','p','e','N','a','m','e',0};
1258 TRACE("(%d, %p, %08x, %p, %p, %p)\n", dwIndex
, pdwReserved
,
1259 dwFlags
, pdwProvType
, pszTypeName
, pcbTypeName
);
1261 if (pdwReserved
|| !pdwProvType
|| !pcbTypeName
)
1263 SetLastError(ERROR_INVALID_PARAMETER
);
1268 SetLastError(NTE_BAD_FLAGS
);
1272 if (RegOpenKeyW(HKEY_LOCAL_MACHINE
, KEYSTR
, &hKey
))
1275 RegQueryInfoKeyW(hKey
, NULL
, NULL
, NULL
, &numkeys
, &keylen
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
1276 if (dwIndex
>= numkeys
)
1278 SetLastError(ERROR_NO_MORE_ITEMS
);
1282 if ( !(keyname
= CRYPT_Alloc(keylen
*sizeof(WCHAR
))) )
1284 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1287 if ( RegEnumKeyW(hKey
, dwIndex
, keyname
, keylen
) ) {
1288 CRYPT_Free(keyname
);
1291 RegOpenKeyW(hKey
, keyname
, &hSubkey
);
1292 ch
= keyname
+ strlenW(keyname
);
1293 /* Convert "Type 000" to 0, etc/ */
1294 *pdwProvType
= *(--ch
) - '0';
1295 *pdwProvType
+= (*(--ch
) - '0') * 10;
1296 *pdwProvType
+= (*(--ch
) - '0') * 100;
1297 CRYPT_Free(keyname
);
1299 result
= RegQueryValueExW(hSubkey
, typenameW
, NULL
, &dwType
, (LPBYTE
)pszTypeName
, pcbTypeName
);
1302 SetLastError(result
);
1306 RegCloseKey(hSubkey
);
1311 /******************************************************************************
1312 * CryptEnumProviderTypesA (ADVAPI32.@)
1314 * See CryptEnumProviderTypesW.
1316 BOOL WINAPI
CryptEnumProviderTypesA (DWORD dwIndex
, DWORD
*pdwReserved
,
1317 DWORD dwFlags
, DWORD
*pdwProvType
, LPSTR pszTypeName
, DWORD
*pcbTypeName
)
1323 TRACE("(%d, %p, %08x, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
1324 pdwProvType
, pszTypeName
, pcbTypeName
);
1326 if(!CryptEnumProviderTypesW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, NULL
, &bufsize
))
1328 if ( pszTypeName
&& !(str
= CRYPT_Alloc(bufsize
)) )
1330 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1333 ret
= CryptEnumProviderTypesW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, str
, &bufsize
);
1335 CRYPT_UnicodeToANSI(str
, &pszTypeName
, *pcbTypeName
);
1336 *pcbTypeName
= bufsize
/ sizeof(WCHAR
);
1340 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1342 SetLastError(ERROR_MORE_DATA
);
1349 /******************************************************************************
1350 * CryptExportKey (ADVAPI32.@)
1352 * Exports a cryptographic key from a CSP.
1355 * hKey [I] Handle to the key to export.
1356 * hExpKey [I] Handle to a cryptographic key of the end user.
1357 * dwBlobType [I] Type of BLOB to be exported.
1358 * dwFlags [I] CRYPT_DESTROYKEY/SSL2_FALLBACK/OAEP.
1359 * pbData [O] Buffer to receive BLOB data.
1360 * pdwDataLen [I/O] Specifies the size of pbData.
1367 * if pbData is NULL, CryptExportKey sets pdwDataLen as the size of the
1368 * buffer needed to hold the BLOB.
1370 BOOL WINAPI
CryptExportKey (HCRYPTKEY hKey
, HCRYPTKEY hExpKey
, DWORD dwBlobType
,
1371 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
)
1374 PCRYPTKEY key
= (PCRYPTKEY
)hKey
, expkey
= (PCRYPTKEY
)hExpKey
;
1376 TRACE("(0x%lx, 0x%lx, %d, %08x, %p, %p)\n", hKey
, hExpKey
, dwBlobType
, dwFlags
, pbData
, pdwDataLen
);
1378 if (!key
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1380 SetLastError(ERROR_INVALID_PARAMETER
);
1384 prov
= key
->pProvider
;
1385 return prov
->pFuncs
->pCPExportKey(prov
->hPrivate
, key
->hPrivate
, expkey
? expkey
->hPrivate
: 0,
1386 dwBlobType
, dwFlags
, pbData
, pdwDataLen
);
1389 /******************************************************************************
1390 * CryptGenKey (ADVAPI32.@)
1392 * Generates a random cryptographic session key or a pub/priv key pair.
1395 * hProv [I] Handle to a CSP.
1396 * Algid [I] Algorithm to use to make key.
1397 * dwFlags [I] Specifies type of key to make.
1398 * phKey [I] Address of the handle to which the new key is copied.
1404 BOOL WINAPI
CryptGenKey (HCRYPTPROV hProv
, ALG_ID Algid
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
1406 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1409 TRACE("(0x%lx, %d, %08x, %p)\n", hProv
, Algid
, dwFlags
, phKey
);
1413 SetLastError(ERROR_INVALID_HANDLE
);
1416 if (!phKey
|| !prov
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1418 SetLastError(ERROR_INVALID_PARAMETER
);
1421 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1423 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1427 key
->pProvider
= prov
;
1429 if (prov
->pFuncs
->pCPGenKey(prov
->hPrivate
, Algid
, dwFlags
, &key
->hPrivate
))
1431 *phKey
= (HCRYPTKEY
)key
;
1440 /******************************************************************************
1441 * CryptGetDefaultProviderW (ADVAPI32.@)
1443 * Finds the default CSP of a certain provider type.
1446 * dwProvType [I] Provider type to look for.
1447 * pdwReserved [I] Reserved for future use and must be NULL.
1448 * dwFlags [I] CRYPT_MACHINE_DEFAULT/USER_DEFAULT
1449 * pszProvName [O] Name of the default CSP.
1450 * pcbProvName [I/O] Size of pszProvName
1457 * If pszProvName is NULL, pcbProvName will hold the size of the buffer for
1458 * memory allocation purposes on return.
1460 BOOL WINAPI
CryptGetDefaultProviderW (DWORD dwProvType
, DWORD
*pdwReserved
,
1461 DWORD dwFlags
, LPWSTR pszProvName
, DWORD
*pcbProvName
)
1466 static const WCHAR nameW
[] = {'N','a','m','e',0};
1468 if (pdwReserved
|| !pcbProvName
)
1470 SetLastError(ERROR_INVALID_PARAMETER
);
1473 if (dwFlags
& ~(CRYPT_USER_DEFAULT
| CRYPT_MACHINE_DEFAULT
))
1475 SetLastError(NTE_BAD_FLAGS
);
1478 if (dwProvType
> 999)
1480 SetLastError(NTE_BAD_PROV_TYPE
);
1483 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, dwFlags
& CRYPT_USER_DEFAULT
)) )
1485 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1488 if (RegOpenKeyW((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,keyname
, &hKey
))
1490 CRYPT_Free(keyname
);
1491 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
1494 CRYPT_Free(keyname
);
1496 result
= RegQueryValueExW(hKey
, nameW
, NULL
, NULL
, (LPBYTE
)pszProvName
, pcbProvName
);
1499 if (result
!= ERROR_MORE_DATA
)
1500 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
1502 SetLastError(result
);
1511 /******************************************************************************
1512 * CryptGetDefaultProviderA (ADVAPI32.@)
1514 * See CryptGetDefaultProviderW.
1516 BOOL WINAPI
CryptGetDefaultProviderA (DWORD dwProvType
, DWORD
*pdwReserved
,
1517 DWORD dwFlags
, LPSTR pszProvName
, DWORD
*pcbProvName
)
1523 TRACE("(%d, %p, %08x, %p, %p)\n", dwProvType
, pdwReserved
, dwFlags
, pszProvName
, pcbProvName
);
1525 CryptGetDefaultProviderW(dwProvType
, pdwReserved
, dwFlags
, NULL
, &bufsize
);
1526 if ( pszProvName
&& !(str
= CRYPT_Alloc(bufsize
)) )
1528 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1531 ret
= CryptGetDefaultProviderW(dwProvType
, pdwReserved
, dwFlags
, str
, &bufsize
);
1533 CRYPT_UnicodeToANSI(str
, &pszProvName
, *pcbProvName
);
1534 *pcbProvName
= bufsize
/ sizeof(WCHAR
);
1538 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1540 SetLastError(ERROR_MORE_DATA
);
1547 /******************************************************************************
1548 * CryptGetHashParam (ADVAPI32.@)
1550 * Retrieves data that controls the operations of a hash object.
1553 * hHash [I] Handle of the hash object to question.
1554 * dwParam [I] Query type.
1555 * pbData [O] Buffer that receives the value data.
1556 * pdwDataLen [I/O] Size of the pbData buffer.
1557 * dwFlags [I] Reserved for future use and must be zero.
1564 * If pbData is NULL, pdwDataLen will contain the length required.
1566 BOOL WINAPI
CryptGetHashParam (HCRYPTHASH hHash
, DWORD dwParam
, BYTE
*pbData
,
1567 DWORD
*pdwDataLen
, DWORD dwFlags
)
1570 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1572 TRACE("(0x%lx, %d, %p, %p, %08x)\n", hHash
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1574 if (!hash
|| !pdwDataLen
|| !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1576 SetLastError(ERROR_INVALID_PARAMETER
);
1580 prov
= hash
->pProvider
;
1581 return prov
->pFuncs
->pCPGetHashParam(prov
->hPrivate
, hash
->hPrivate
, dwParam
,
1582 pbData
, pdwDataLen
, dwFlags
);
1585 /******************************************************************************
1586 * CryptGetKeyParam (ADVAPI32.@)
1588 * Retrieves data that controls the operations of a key.
1591 * hKey [I] Handle to they key in question.
1592 * dwParam [I] Specifies query type.
1593 * pbData [O] Sequence of bytes to receive data.
1594 * pdwDataLen [I/O] Size of pbData.
1595 * dwFlags [I] Reserved for future use and must be zero.
1602 * If pbData is NULL, pdwDataLen is set to the needed length of the buffer.
1604 BOOL WINAPI
CryptGetKeyParam (HCRYPTKEY hKey
, DWORD dwParam
, BYTE
*pbData
,
1605 DWORD
*pdwDataLen
, DWORD dwFlags
)
1608 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1610 TRACE("(0x%lx, %d, %p, %p, %08x)\n", hKey
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1612 if (!key
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1614 SetLastError(ERROR_INVALID_PARAMETER
);
1618 prov
= key
->pProvider
;
1619 return prov
->pFuncs
->pCPGetKeyParam(prov
->hPrivate
, key
->hPrivate
, dwParam
,
1620 pbData
, pdwDataLen
, dwFlags
);
1623 /******************************************************************************
1624 * CryptGetProvParam (ADVAPI32.@)
1626 * Retrieves parameters that control the operations of a CSP.
1629 * hProv [I] Handle of the CSP in question.
1630 * dwParam [I] Specifies query type.
1631 * pbData [O] Buffer to receive the data.
1632 * pdwDataLen [I/O] Size of pbData.
1633 * dwFlags [I] see MSDN Docs.
1640 * If pbData is NULL, pdwDataLen is set to the needed buffer length.
1642 BOOL WINAPI
CryptGetProvParam (HCRYPTPROV hProv
, DWORD dwParam
, BYTE
*pbData
,
1643 DWORD
*pdwDataLen
, DWORD dwFlags
)
1645 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1647 TRACE("(0x%lx, %d, %p, %p, %08x)\n", hProv
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1649 if (!prov
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1651 SetLastError(ERROR_INVALID_PARAMETER
);
1655 return prov
->pFuncs
->pCPGetProvParam(prov
->hPrivate
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1658 /******************************************************************************
1659 * CryptGetUserKey (ADVAPI32.@)
1661 * Gets a handle of one of a user's two public/private key pairs.
1664 * hProv [I] Handle of a CSP.
1665 * dwKeySpec [I] Private key to use.
1666 * phUserKey [O] Pointer to the handle of the retrieved keys.
1672 BOOL WINAPI
CryptGetUserKey (HCRYPTPROV hProv
, DWORD dwKeySpec
, HCRYPTKEY
*phUserKey
)
1674 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1677 TRACE("(0x%lx, %d, %p)\n", hProv
, dwKeySpec
, phUserKey
);
1681 SetLastError(ERROR_INVALID_HANDLE
);
1684 if (!phUserKey
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1686 SetLastError(ERROR_INVALID_PARAMETER
);
1689 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1691 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1695 key
->pProvider
= prov
;
1697 if (prov
->pFuncs
->pCPGetUserKey(prov
->hPrivate
, dwKeySpec
, &key
->hPrivate
))
1699 *phUserKey
= (HCRYPTKEY
)key
;
1709 /******************************************************************************
1710 * CryptHashData (ADVAPI32.@)
1712 * Adds data to a hash object.
1715 * hHash [I] Handle of the hash object.
1716 * pbData [I] Buffer of data to be hashed.
1717 * dwDataLen [I] Number of bytes to add.
1718 * dwFlags [I] Can be CRYPT_USERDATA
1724 BOOL WINAPI
CryptHashData (HCRYPTHASH hHash
, const BYTE
*pbData
, DWORD dwDataLen
, DWORD dwFlags
)
1726 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1729 TRACE("(0x%lx, %p, %d, %08x)\n", hHash
, pbData
, dwDataLen
, dwFlags
);
1733 SetLastError(ERROR_INVALID_HANDLE
);
1736 if (!hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1738 SetLastError(ERROR_INVALID_PARAMETER
);
1742 prov
= hash
->pProvider
;
1743 return prov
->pFuncs
->pCPHashData(prov
->hPrivate
, hash
->hPrivate
, pbData
, dwDataLen
, dwFlags
);
1746 /******************************************************************************
1747 * CryptHashSessionKey (ADVAPI32.@)
1749 * Compute the cryptographic hash of a session key object.
1752 * hHash [I] Handle to the hash object.
1753 * hKey [I] Handle to the key to be hashed.
1754 * dwFlags [I] Can be CRYPT_LITTLE_ENDIAN.
1760 BOOL WINAPI
CryptHashSessionKey (HCRYPTHASH hHash
, HCRYPTKEY hKey
, DWORD dwFlags
)
1762 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1763 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1766 TRACE("(0x%lx, 0x%lx, %08x)\n", hHash
, hKey
, dwFlags
);
1770 SetLastError(ERROR_INVALID_HANDLE
);
1774 if (!hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1776 SetLastError(ERROR_INVALID_PARAMETER
);
1780 prov
= hash
->pProvider
;
1781 return prov
->pFuncs
->pCPHashSessionKey(prov
->hPrivate
, hash
->hPrivate
, key
->hPrivate
, dwFlags
);
1784 /******************************************************************************
1785 * CryptImportKey (ADVAPI32.@)
1787 * Transfer a cryptographic key from a key BLOB into a cryptographic service provider (CSP).
1790 * hProv [I] Handle of a CSP.
1791 * pbData [I] Contains the key to be imported.
1792 * dwDataLen [I] Length of the key.
1793 * hPubKey [I] Cryptographic key that decrypts pdData
1794 * dwFlags [I] Used only with a public/private key pair.
1795 * phKey [O] Imported key.
1801 BOOL WINAPI
CryptImportKey (HCRYPTPROV hProv
, CONST BYTE
*pbData
, DWORD dwDataLen
,
1802 HCRYPTKEY hPubKey
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
1804 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1805 PCRYPTKEY pubkey
= (PCRYPTKEY
)hPubKey
, importkey
;
1807 TRACE("(0x%lx, %p, %d, 0x%lx, %08x, %p)\n", hProv
, pbData
, dwDataLen
, hPubKey
, dwFlags
, phKey
);
1809 if (!prov
|| !pbData
|| !dwDataLen
|| !phKey
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1811 SetLastError(ERROR_INVALID_PARAMETER
);
1815 if ( !(importkey
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1817 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1821 importkey
->pProvider
= prov
;
1822 if (prov
->pFuncs
->pCPImportKey(prov
->hPrivate
, pbData
, dwDataLen
,
1823 pubkey
? pubkey
->hPrivate
: 0, dwFlags
, &importkey
->hPrivate
))
1825 *phKey
= (HCRYPTKEY
)importkey
;
1829 CRYPT_Free(importkey
);
1833 /******************************************************************************
1834 * CryptSignHashW (ADVAPI32.@)
1839 * hHash [I] Handle of the hash object to be signed.
1840 * dwKeySpec [I] Private key to use.
1841 * sDescription [I] Should be NULL.
1842 * dwFlags [I] CRYPT_NOHASHOID/X931_FORMAT.
1843 * pbSignature [O] Buffer of the signature data.
1844 * pdwSigLen [I/O] Size of the pbSignature buffer.
1851 * Because of security flaws sDescription should not be used and should thus be
1852 * NULL. It is supported only for compatibility with Microsoft's Cryptographic
1855 BOOL WINAPI
CryptSignHashW (HCRYPTHASH hHash
, DWORD dwKeySpec
, LPCWSTR sDescription
,
1856 DWORD dwFlags
, BYTE
*pbSignature
, DWORD
*pdwSigLen
)
1858 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1861 TRACE("(0x%lx, %d, %s, %08x, %p, %p)\n",
1862 hHash
, dwKeySpec
, debugstr_w(sDescription
), dwFlags
, pbSignature
, pdwSigLen
);
1866 SetLastError(ERROR_INVALID_HANDLE
);
1869 if (!pdwSigLen
|| !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1871 SetLastError(ERROR_INVALID_PARAMETER
);
1875 prov
= hash
->pProvider
;
1876 return prov
->pFuncs
->pCPSignHash(prov
->hPrivate
, hash
->hPrivate
, dwKeySpec
, sDescription
,
1877 dwFlags
, pbSignature
, pdwSigLen
);
1880 /******************************************************************************
1881 * CryptSignHashA (ADVAPI32.@)
1883 * See CryptSignHashW.
1885 BOOL WINAPI
CryptSignHashA (HCRYPTHASH hHash
, DWORD dwKeySpec
, LPCSTR sDescription
,
1886 DWORD dwFlags
, BYTE
*pbSignature
, DWORD
*pdwSigLen
)
1888 LPWSTR wsDescription
;
1891 TRACE("(0x%lx, %d, %s, %08x, %p, %p)\n",
1892 hHash
, dwKeySpec
, debugstr_a(sDescription
), dwFlags
, pbSignature
, pdwSigLen
);
1894 CRYPT_ANSIToUnicode(sDescription
, &wsDescription
, -1);
1895 result
= CryptSignHashW(hHash
, dwKeySpec
, wsDescription
, dwFlags
, pbSignature
, pdwSigLen
);
1896 CRYPT_Free(wsDescription
);
1901 /******************************************************************************
1902 * CryptSetHashParam (ADVAPI32.@)
1904 * Customizes the operations of a hash object.
1907 * hHash [I] Handle of the hash object to set parameters.
1908 * dwParam [I] HP_HMAC_INFO/HASHVAL.
1909 * pbData [I] Value data buffer.
1910 * dwFlags [I] Reserved for future use and must be zero.
1916 BOOL WINAPI
CryptSetHashParam (HCRYPTHASH hHash
, DWORD dwParam
, CONST BYTE
*pbData
, DWORD dwFlags
)
1919 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1921 TRACE("(0x%lx, %d, %p, %08x)\n", hHash
, dwParam
, pbData
, dwFlags
);
1923 if (!hash
|| !pbData
|| !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1925 SetLastError(ERROR_INVALID_PARAMETER
);
1929 prov
= hash
->pProvider
;
1930 return prov
->pFuncs
->pCPSetHashParam(prov
->hPrivate
, hash
->hPrivate
,
1931 dwParam
, pbData
, dwFlags
);
1934 /******************************************************************************
1935 * CryptSetKeyParam (ADVAPI32.@)
1937 * Customizes a session key's operations.
1940 * hKey [I] Handle to the key to set values.
1941 * dwParam [I] See MSDN Doc.
1942 * pbData [I] Buffer of values to set.
1943 * dwFlags [I] Only used when dwParam == KP_ALGID.
1949 BOOL WINAPI
CryptSetKeyParam (HCRYPTKEY hKey
, DWORD dwParam
, CONST BYTE
*pbData
, DWORD dwFlags
)
1952 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1954 TRACE("(0x%lx, %d, %p, %08x)\n", hKey
, dwParam
, pbData
, dwFlags
);
1956 if (!key
|| !pbData
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1958 SetLastError(ERROR_INVALID_PARAMETER
);
1962 prov
= key
->pProvider
;
1963 return prov
->pFuncs
->pCPSetKeyParam(prov
->hPrivate
, key
->hPrivate
,
1964 dwParam
, pbData
, dwFlags
);
1967 /******************************************************************************
1968 * CryptSetProviderA (ADVAPI32.@)
1970 * Specifies the current user's default CSP.
1973 * pszProvName [I] Name of the new default CSP.
1974 * dwProvType [I] Provider type of the CSP.
1980 BOOL WINAPI
CryptSetProviderA (LPCSTR pszProvName
, DWORD dwProvType
)
1982 TRACE("(%s, %d)\n", pszProvName
, dwProvType
);
1983 return CryptSetProviderExA(pszProvName
, dwProvType
, NULL
, CRYPT_USER_DEFAULT
);
1986 /******************************************************************************
1987 * CryptSetProviderW (ADVAPI32.@)
1989 * See CryptSetProviderA.
1991 BOOL WINAPI
CryptSetProviderW (LPCWSTR pszProvName
, DWORD dwProvType
)
1993 TRACE("(%s, %d)\n", debugstr_w(pszProvName
), dwProvType
);
1994 return CryptSetProviderExW(pszProvName
, dwProvType
, NULL
, CRYPT_USER_DEFAULT
);
1997 /******************************************************************************
1998 * CryptSetProviderExW (ADVAPI32.@)
2000 * Specifies the default CSP.
2003 * pszProvName [I] Name of the new default CSP.
2004 * dwProvType [I] Provider type of the CSP.
2005 * pdwReserved [I] Reserved for future use and must be NULL.
2006 * dwFlags [I] See MSDN Doc.
2012 BOOL WINAPI
CryptSetProviderExW (LPCWSTR pszProvName
, DWORD dwProvType
, DWORD
*pdwReserved
, DWORD dwFlags
)
2014 HKEY hProvKey
, hTypeKey
;
2016 static const WCHAR nameW
[] = {'N','a','m','e',0};
2018 TRACE("(%s, %d, %p, %08x)\n", debugstr_w(pszProvName
), dwProvType
, pdwReserved
, dwFlags
);
2020 if (!pszProvName
|| pdwReserved
)
2022 SetLastError(ERROR_INVALID_PARAMETER
);
2025 if (dwProvType
> MAXPROVTYPES
)
2027 SetLastError(NTE_BAD_PROV_TYPE
);
2030 if (dwFlags
& ~(CRYPT_MACHINE_DEFAULT
| CRYPT_USER_DEFAULT
| CRYPT_DELETE_DEFAULT
)
2031 || dwFlags
== CRYPT_DELETE_DEFAULT
)
2033 SetLastError(NTE_BAD_FLAGS
);
2037 if (!(keyname
= CRYPT_GetTypeKeyName(dwProvType
, dwFlags
& CRYPT_USER_DEFAULT
)))
2039 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2042 if (RegOpenKeyW((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,
2043 keyname
, &hTypeKey
))
2045 CRYPT_Free(keyname
);
2046 SetLastError(NTE_BAD_PROVIDER
);
2049 CRYPT_Free(keyname
);
2051 if (dwFlags
& CRYPT_DELETE_DEFAULT
)
2053 RegDeleteValueW(hTypeKey
, nameW
);
2057 if (!(keyname
= CRYPT_GetProvKeyName(pszProvName
)))
2059 RegCloseKey(hTypeKey
);
2060 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2063 if (RegOpenKeyW((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,
2064 keyname
, &hProvKey
))
2066 CRYPT_Free(keyname
);
2067 RegCloseKey(hTypeKey
);
2068 SetLastError(NTE_BAD_PROVIDER
);
2071 CRYPT_Free(keyname
);
2073 if (RegSetValueExW(hTypeKey
, nameW
, 0, REG_SZ
, (const BYTE
*)pszProvName
,
2074 (strlenW(pszProvName
) + 1)*sizeof(WCHAR
)))
2076 RegCloseKey(hTypeKey
);
2077 RegCloseKey(hProvKey
);
2081 RegCloseKey(hProvKey
);
2083 RegCloseKey(hTypeKey
);
2088 /******************************************************************************
2089 * CryptSetProviderExA (ADVAPI32.@)
2091 * See CryptSetProviderExW.
2093 BOOL WINAPI
CryptSetProviderExA (LPCSTR pszProvName
, DWORD dwProvType
, DWORD
*pdwReserved
, DWORD dwFlags
)
2098 TRACE("(%s, %d, %p, %08x)\n", pszProvName
, dwProvType
, pdwReserved
, dwFlags
);
2100 if (CRYPT_ANSIToUnicode(pszProvName
, &str
, -1))
2102 ret
= CryptSetProviderExW(str
, dwProvType
, pdwReserved
, dwFlags
);
2108 /******************************************************************************
2109 * CryptSetProvParam (ADVAPI32.@)
2111 * Customizes the operations of a CSP.
2114 * hProv [I] Handle of a CSP.
2115 * dwParam [I] See MSDN Doc.
2116 * pbData [I] Buffer that contains a value to set as a parameter.
2117 * dwFlags [I] if dwParam is PP_USE_HARDWARE_RNG, dwFlags must be zero.
2123 BOOL WINAPI
CryptSetProvParam (HCRYPTPROV hProv
, DWORD dwParam
, CONST BYTE
*pbData
, DWORD dwFlags
)
2125 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
2127 TRACE("(0x%lx, %d, %p, %08x)\n", hProv
, dwParam
, pbData
, dwFlags
);
2131 SetLastError(ERROR_INVALID_HANDLE
);
2134 if (prov
->dwMagic
!= MAGIC_CRYPTPROV
)
2136 SetLastError(ERROR_INVALID_PARAMETER
);
2139 if (dwFlags
& PP_USE_HARDWARE_RNG
)
2141 FIXME("PP_USE_HARDWARE_RNG: What do I do with this?\n");
2142 FIXME("\tLetting the CSP decide.\n");
2144 if (dwFlags
& PP_CLIENT_HWND
)
2146 /* FIXME: Should verify the parameter */
2147 if (pbData
/* && IsWindow((HWND)pbData) */)
2149 crypt_hWindow
= (HWND
)(pbData
);
2152 SetLastError(ERROR_INVALID_PARAMETER
);
2156 /* All other flags go to the CSP */
2157 return prov
->pFuncs
->pCPSetProvParam(prov
->hPrivate
, dwParam
, pbData
, dwFlags
);
2160 /******************************************************************************
2161 * CryptVerifySignatureW (ADVAPI32.@)
2163 * Verifies the signature of a hash object.
2166 * hHash [I] Handle of the hash object to verify.
2167 * pbSignature [I] Signature data to verify.
2168 * dwSigLen [I] Size of pbSignature.
2169 * hPubKey [I] Handle to the public key to authenticate signature.
2170 * sDescription [I] Should be NULL.
2171 * dwFlags [I] See MSDN doc.
2178 * Because of security flaws sDescription should not be used and should thus be
2179 * NULL. It is supported only for compatibility with Microsoft's Cryptographic
2182 BOOL WINAPI
CryptVerifySignatureW (HCRYPTHASH hHash
, CONST BYTE
*pbSignature
, DWORD dwSigLen
,
2183 HCRYPTKEY hPubKey
, LPCWSTR sDescription
, DWORD dwFlags
)
2185 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
2186 PCRYPTKEY key
= (PCRYPTKEY
)hPubKey
;
2189 TRACE("(0x%lx, %p, %d, 0x%lx, %s, %08x)\n", hHash
, pbSignature
,
2190 dwSigLen
, hPubKey
, debugstr_w(sDescription
), dwFlags
);
2192 if (!hash
|| !key
||
2193 !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
||
2194 !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
2196 SetLastError(ERROR_INVALID_PARAMETER
);
2200 prov
= hash
->pProvider
;
2201 return prov
->pFuncs
->pCPVerifySignature(prov
->hPrivate
, hash
->hPrivate
, pbSignature
, dwSigLen
,
2202 key
->hPrivate
, sDescription
, dwFlags
);
2205 /******************************************************************************
2206 * CryptVerifySignatureA (ADVAPI32.@)
2208 * See CryptVerifySignatureW.
2210 BOOL WINAPI
CryptVerifySignatureA (HCRYPTHASH hHash
, CONST BYTE
*pbSignature
, DWORD dwSigLen
,
2211 HCRYPTKEY hPubKey
, LPCSTR sDescription
, DWORD dwFlags
)
2213 LPWSTR wsDescription
;
2216 TRACE("(0x%lx, %p, %d, 0x%lx, %s, %08x)\n", hHash
, pbSignature
,
2217 dwSigLen
, hPubKey
, debugstr_a(sDescription
), dwFlags
);
2219 CRYPT_ANSIToUnicode(sDescription
, &wsDescription
, -1);
2220 result
= CryptVerifySignatureW(hHash
, pbSignature
, dwSigLen
, hPubKey
, wsDescription
, dwFlags
);
2221 CRYPT_Free(wsDescription
);