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
);
30 static HWND crypt_hWindow
;
32 #define CRYPT_Alloc(size) (LocalAlloc(LMEM_ZEROINIT, size))
33 #define CRYPT_Free(buffer) (LocalFree(buffer))
35 static inline PWSTR
CRYPT_GetProvKeyName(PCWSTR pProvName
)
37 static const WCHAR KEYSTR
[] = {
38 'S','o','f','t','w','a','r','e','\\',
39 'M','i','c','r','o','s','o','f','t','\\',
40 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
41 'D','e','f','a','u','l','t','s','\\',
42 'P','r','o','v','i','d','e','r','\\',0
46 keyname
= CRYPT_Alloc((strlenW(KEYSTR
) + strlenW(pProvName
) +1)*sizeof(WCHAR
));
49 strcpyW(keyname
, KEYSTR
);
50 strcpyW(keyname
+ strlenW(KEYSTR
), pProvName
);
52 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
56 static inline PWSTR
CRYPT_GetTypeKeyName(DWORD dwType
, BOOL user
)
58 static const WCHAR MACHINESTR
[] = {
59 'S','o','f','t','w','a','r','e','\\',
60 'M','i','c','r','o','s','o','f','t','\\',
61 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
62 'D','e','f','a','u','l','t','s','\\',
63 'P','r','o','v','i','d','e','r',' ','T','y','p','e','s','\\',
64 'T','y','p','e',' ','X','X','X',0
66 static const WCHAR USERSTR
[] = {
67 'S','o','f','t','w','a','r','e','\\',
68 'M','i','c','r','o','s','o','f','t','\\',
69 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
70 'P','r','o','v','i','d','e','r',' ','T','y','p','e',' ','X','X','X',0
75 keyname
= CRYPT_Alloc( ((user
? strlenW(USERSTR
) : strlenW(MACHINESTR
)) +1)*sizeof(WCHAR
));
78 user
? strcpyW(keyname
, USERSTR
) : strcpyW(keyname
, MACHINESTR
);
79 ptr
= keyname
+ strlenW(keyname
);
80 *(--ptr
) = (dwType
% 10) + '0';
81 *(--ptr
) = ((dwType
/ 10) % 10) + '0';
82 *(--ptr
) = (dwType
/ 100) + '0';
84 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
88 /* CRYPT_UnicodeToANSI
89 * wstr - unicode string
90 * str - pointer to ANSI string or pointer to null pointer if we have to do the allocation
91 * strsize - size of buffer pointed to by str
93 * returns TRUE if unsuccessful, FALSE otherwise.
94 * if wstr is NULL, returns TRUE and sets str to NULL! Value of str should be checked after call
96 static inline BOOL
CRYPT_UnicodeToANSI(LPCWSTR wstr
, LPSTR
* str
, int strsize
)
106 strsize
= WideCharToMultiByte(CP_ACP
, 0, wstr
, -1, NULL
, 0, NULL
, NULL
);
107 *str
= CRYPT_Alloc(strsize
* sizeof(CHAR
));
109 else if (strsize
< 0)
111 strsize
= INT_MAX
; /* windows will pretend that the buffer is infinitely long */
116 WideCharToMultiByte(CP_ACP
, 0, wstr
, -1, *str
, strsize
, NULL
, NULL
);
120 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
124 /* CRYPT_ANSITOUnicode
126 * wstr - pointer to unicode string
127 * wstrsize - size of buffer pointed to by wstr or -1 if we have to do the allocation
129 static inline BOOL
CRYPT_ANSIToUnicode(LPCSTR str
, LPWSTR
* wstr
, int wstrsize
)
138 wcount
= MultiByteToWideChar(CP_ACP
, 0, str
, -1, NULL
, 0);
140 *wstr
= CRYPT_Alloc(wcount
* sizeof(WCHAR
));
142 wcount
= min( wcount
, wstrsize
/sizeof(WCHAR
) );
145 MultiByteToWideChar(CP_ACP
, 0, str
, -1, *wstr
, wcount
);
148 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
152 /* These next 2 functions are used by the VTableProvStruc structure */
153 static BOOL CALLBACK
CRYPT_VerifyImage(LPCSTR lpszImage
, BYTE
* pData
)
155 if (!lpszImage
|| !pData
)
157 SetLastError(ERROR_INVALID_PARAMETER
);
161 FIXME("(%s, %p): not verifying image\n", lpszImage
, pData
);
166 static void CALLBACK
CRYPT_ReturnhWnd(HWND
*phWnd
)
168 if (phWnd
) *phWnd
= crypt_hWindow
;
171 #define CRYPT_GetProvFunc(name) \
172 if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error
173 #define CRYPT_GetProvFuncOpt(name) \
174 provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)
175 static PCRYPTPROV
CRYPT_LoadProvider(PCWSTR pImage
)
178 DWORD errorcode
= ERROR_NOT_ENOUGH_MEMORY
;
180 if ( !(provider
= CRYPT_Alloc(sizeof(CRYPTPROV
))) ) goto error
;
181 if ( !(provider
->pFuncs
= CRYPT_Alloc(sizeof(PROVFUNCS
))) ) goto error
;
182 if ( !(provider
->pVTable
= CRYPT_Alloc(sizeof(VTableProvStruc
))) ) goto error
;
183 if ( !(provider
->hModule
= LoadLibraryW(pImage
)) )
185 errorcode
= (GetLastError() == ERROR_FILE_NOT_FOUND
) ? NTE_PROV_DLL_NOT_FOUND
: NTE_PROVIDER_DLL_FAIL
;
186 FIXME("Failed to load dll %s\n", debugstr_w(pImage
));
189 provider
->dwMagic
= MAGIC_CRYPTPROV
;
190 provider
->refcount
= 1;
192 errorcode
= NTE_PROVIDER_DLL_FAIL
;
193 CRYPT_GetProvFunc(CPAcquireContext
);
194 CRYPT_GetProvFunc(CPCreateHash
);
195 CRYPT_GetProvFunc(CPDecrypt
);
196 CRYPT_GetProvFunc(CPDeriveKey
);
197 CRYPT_GetProvFunc(CPDestroyHash
);
198 CRYPT_GetProvFunc(CPDestroyKey
);
199 CRYPT_GetProvFuncOpt(CPDuplicateHash
);
200 CRYPT_GetProvFuncOpt(CPDuplicateKey
);
201 CRYPT_GetProvFunc(CPEncrypt
);
202 CRYPT_GetProvFunc(CPExportKey
);
203 CRYPT_GetProvFunc(CPGenKey
);
204 CRYPT_GetProvFunc(CPGenRandom
);
205 CRYPT_GetProvFunc(CPGetHashParam
);
206 CRYPT_GetProvFunc(CPGetKeyParam
);
207 CRYPT_GetProvFunc(CPGetProvParam
);
208 CRYPT_GetProvFunc(CPGetUserKey
);
209 CRYPT_GetProvFunc(CPHashData
);
210 CRYPT_GetProvFunc(CPHashSessionKey
);
211 CRYPT_GetProvFunc(CPImportKey
);
212 CRYPT_GetProvFunc(CPReleaseContext
);
213 CRYPT_GetProvFunc(CPSetHashParam
);
214 CRYPT_GetProvFunc(CPSetKeyParam
);
215 CRYPT_GetProvFunc(CPSetProvParam
);
216 CRYPT_GetProvFunc(CPSignHash
);
217 CRYPT_GetProvFunc(CPVerifySignature
);
219 /* FIXME: Not sure what the pbContextInfo field is for.
220 * Does it need memory allocation?
222 provider
->pVTable
->Version
= 3;
223 provider
->pVTable
->FuncVerifyImage
= CRYPT_VerifyImage
;
224 provider
->pVTable
->FuncReturnhWnd
= CRYPT_ReturnhWnd
;
225 provider
->pVTable
->dwProvType
= 0;
226 provider
->pVTable
->pbContextInfo
= NULL
;
227 provider
->pVTable
->cbContextInfo
= 0;
228 provider
->pVTable
->pszProvName
= NULL
;
232 SetLastError(errorcode
);
235 provider
->dwMagic
= 0;
236 if (provider
->hModule
)
237 FreeLibrary(provider
->hModule
);
238 CRYPT_Free(provider
->pVTable
);
239 CRYPT_Free(provider
->pFuncs
);
240 CRYPT_Free(provider
);
244 #undef CRYPT_GetProvFunc
245 #undef CRYPT_GetProvFuncOpt
248 static void CRYPT_CreateMachineGuid(void)
250 static const WCHAR cryptographyW
[] = {
251 'S','o','f','t','w','a','r','e','\\',
252 'M','i','c','r','o','s','o','f','t','\\',
253 'C','r','y','p','t','o','g','r','a','p','h','y',0 };
254 static const WCHAR machineGuidW
[] = {
255 'M','a','c','h','i','n','e','G','u','i','d',0 };
259 r
= RegOpenKeyExW(HKEY_LOCAL_MACHINE
, cryptographyW
, 0, KEY_ALL_ACCESS
,
265 r
= RegQueryValueExW(key
, machineGuidW
, NULL
, NULL
, NULL
, &size
);
266 if (r
== ERROR_FILE_NOT_FOUND
)
271 static const WCHAR uuidFmt
[] = {
272 '%','0','8','x','-','%','0','4','x','-',
273 '%','0','4','x','-','%','0','2','x',
274 '%','0','2','x','-','%','0','2','x',
275 '%','0','2','x','%','0','2','x',
276 '%','0','2','x','%','0','2','x',
279 rs
= UuidCreate(&uuid
);
282 sprintfW(buf
, uuidFmt
,
283 uuid
.Data1
, uuid
.Data2
, uuid
.Data3
,
284 uuid
.Data4
[0], uuid
.Data4
[1],
285 uuid
.Data4
[2], uuid
.Data4
[3],
286 uuid
.Data4
[4], uuid
.Data4
[5],
287 uuid
.Data4
[6], uuid
.Data4
[7] );
288 RegSetValueExW(key
, machineGuidW
, 0, REG_SZ
,
290 (lstrlenW(buf
)+1)*sizeof(WCHAR
));
297 /******************************************************************************
298 * CryptAcquireContextW (ADVAPI32.@)
300 * Acquire a crypto provider context handle.
303 * phProv [O] Pointer to HCRYPTPROV for the output.
304 * pszContainer [I] Key Container Name
305 * pszProvider [I] Cryptographic Service Provider Name
306 * dwProvType [I] Crypto provider type to get a handle.
307 * dwFlags [I] flags for the operation
310 * TRUE on success, FALSE on failure.
312 BOOL WINAPI
CryptAcquireContextW (HCRYPTPROV
*phProv
, LPCWSTR pszContainer
,
313 LPCWSTR pszProvider
, DWORD dwProvType
, DWORD dwFlags
)
315 PCRYPTPROV pProv
= NULL
;
317 PWSTR imagepath
= NULL
, keyname
= NULL
, provname
= NULL
, temp
= NULL
;
318 PSTR provnameA
= NULL
, pszContainerA
= NULL
;
319 DWORD keytype
, type
, len
;
321 static const WCHAR nameW
[] = {'N','a','m','e',0};
322 static const WCHAR typeW
[] = {'T','y','p','e',0};
323 static const WCHAR imagepathW
[] = {'I','m','a','g','e',' ','P','a','t','h',0};
325 TRACE("(%p, %s, %s, %d, %08x)\n", phProv
, debugstr_w(pszContainer
),
326 debugstr_w(pszProvider
), dwProvType
, dwFlags
);
328 if (dwProvType
< 1 || dwProvType
> MAXPROVTYPES
)
330 SetLastError(NTE_BAD_PROV_TYPE
);
336 SetLastError(ERROR_INVALID_PARAMETER
);
340 /* Make sure the MachineGuid value exists */
341 CRYPT_CreateMachineGuid();
343 if (!pszProvider
|| !*pszProvider
)
345 /* No CSP name specified so try the user default CSP first
346 * then try the machine default CSP
348 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, TRUE
)) ) {
349 TRACE("No provider registered for crypto provider type %d.\n", dwProvType
);
350 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
353 if (RegOpenKeyW(HKEY_CURRENT_USER
, keyname
, &key
))
356 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, FALSE
)) ) {
357 TRACE("No type registered for crypto provider type %d.\n", dwProvType
);
359 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
362 if (RegOpenKeyW(HKEY_LOCAL_MACHINE
, keyname
, &key
)) {
363 TRACE("Did not find registry entry of crypto provider for %s.\n", debugstr_w(keyname
));
366 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
371 r
= RegQueryValueExW(key
, nameW
, NULL
, &keytype
, NULL
, &len
);
372 if( r
!= ERROR_SUCCESS
|| !len
|| keytype
!= REG_SZ
)
374 TRACE("error %d reading size of 'Name' from registry\n", r
);
376 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
379 if(!(provname
= CRYPT_Alloc(len
)))
382 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
385 r
= RegQueryValueExW(key
, nameW
, NULL
, NULL
, (LPBYTE
)provname
, &len
);
386 if( r
!= ERROR_SUCCESS
)
388 TRACE("error %d reading 'Name' from registry\n", r
);
390 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
395 if ( !(provname
= CRYPT_Alloc((strlenW(pszProvider
) +1)*sizeof(WCHAR
))) )
397 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
400 strcpyW(provname
, pszProvider
);
403 keyname
= CRYPT_GetProvKeyName(provname
);
404 r
= RegOpenKeyW(HKEY_LOCAL_MACHINE
, keyname
, &key
);
406 if (r
!= ERROR_SUCCESS
)
408 SetLastError(NTE_KEYSET_NOT_DEF
);
412 r
= RegQueryValueExW(key
, typeW
, NULL
, NULL
, (BYTE
*)&type
, &len
);
413 if (r
!= ERROR_SUCCESS
)
415 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
418 if (type
!= dwProvType
)
420 TRACE("Crypto provider has wrong type (%d vs expected %d).\n", type
, dwProvType
);
421 SetLastError(NTE_PROV_TYPE_NO_MATCH
);
425 r
= RegQueryValueExW(key
, imagepathW
, NULL
, &keytype
, NULL
, &len
);
426 if ( r
!= ERROR_SUCCESS
|| keytype
!= REG_SZ
)
428 TRACE("error %d reading size of 'Image Path' from registry\n", r
);
430 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
433 if (!(temp
= CRYPT_Alloc(len
)))
436 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
439 r
= RegQueryValueExW(key
, imagepathW
, NULL
, NULL
, (LPBYTE
)temp
, &len
);
440 if( r
!= ERROR_SUCCESS
)
442 TRACE("error %d reading 'Image Path' from registry\n", r
);
444 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
448 len
= ExpandEnvironmentStringsW(temp
, NULL
, 0);
449 if ( !(imagepath
= CRYPT_Alloc(len
*sizeof(WCHAR
))) )
451 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
454 if (!ExpandEnvironmentStringsW(temp
, imagepath
, len
))
456 /* ExpandEnvironmentStrings will call SetLastError */
459 pProv
= CRYPT_LoadProvider(imagepath
);
461 /* CRYPT_LoadProvider calls SetLastError */
464 pProv
->pVTable
->dwProvType
= dwProvType
;
465 if(!CRYPT_UnicodeToANSI(provname
, &provnameA
, 0))
467 /* CRYPT_UnicodeToANSI calls SetLastError */
470 pProv
->pVTable
->pszProvName
= provnameA
;
471 if(!CRYPT_UnicodeToANSI(pszContainer
, &pszContainerA
, 0))
473 /* CRYPT_UnicodeToANSI calls SetLastError */
476 if (pProv
->pFuncs
->pCPAcquireContext(&pProv
->hPrivate
, pszContainerA
, dwFlags
, pProv
->pVTable
))
478 /* MSDN: When this flag is set, the value returned in phProv is undefined,
479 * and thus, the CryptReleaseContext function need not be called afterwards.
480 * Therefore, we must clean up everything now.
482 if (dwFlags
& CRYPT_DELETEKEYSET
)
485 FreeLibrary(pProv
->hModule
);
486 CRYPT_Free(provnameA
);
487 CRYPT_Free(pProv
->pVTable
);
488 CRYPT_Free(pProv
->pFuncs
);
491 *phProv
= (HCRYPTPROV
)pProv
;
493 CRYPT_Free(pszContainerA
);
494 CRYPT_Free(provname
);
496 CRYPT_Free(imagepath
);
499 /* FALLTHROUGH TO ERROR IF FALSE - CSP internal error! */
505 FreeLibrary(pProv
->hModule
);
506 CRYPT_Free(pProv
->pVTable
);
507 CRYPT_Free(pProv
->pFuncs
);
510 CRYPT_Free(pszContainerA
);
511 CRYPT_Free(provnameA
);
512 CRYPT_Free(provname
);
514 CRYPT_Free(imagepath
);
518 /******************************************************************************
519 * CryptAcquireContextA (ADVAPI32.@)
521 * See CryptAcquireContextW.
523 BOOL WINAPI
CryptAcquireContextA (HCRYPTPROV
*phProv
, LPCSTR pszContainer
,
524 LPCSTR pszProvider
, DWORD dwProvType
, DWORD dwFlags
)
526 PWSTR pProvider
= NULL
, pContainer
= NULL
;
529 TRACE("(%p, %s, %s, %d, %08x)\n", phProv
, debugstr_a(pszContainer
),
530 debugstr_a(pszProvider
), dwProvType
, dwFlags
);
532 if ( !CRYPT_ANSIToUnicode(pszContainer
, &pContainer
, -1) )
534 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
537 if ( !CRYPT_ANSIToUnicode(pszProvider
, &pProvider
, -1) )
539 CRYPT_Free(pContainer
);
540 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
544 ret
= CryptAcquireContextW(phProv
, pContainer
, pProvider
, dwProvType
, dwFlags
);
546 CRYPT_Free(pContainer
);
547 CRYPT_Free(pProvider
);
552 /******************************************************************************
553 * CryptContextAddRef (ADVAPI32.@)
555 * Increases reference count of a cryptographic service provider handle
559 * hProv [I] Handle to the CSP whose reference is being incremented.
560 * pdwReserved [IN] Reserved for future use and must be NULL.
561 * dwFlags [I] Reserved for future use and must be NULL.
567 BOOL WINAPI
CryptContextAddRef (HCRYPTPROV hProv
, DWORD
*pdwReserved
, DWORD dwFlags
)
569 PCRYPTPROV pProv
= (PCRYPTPROV
)hProv
;
571 TRACE("(0x%lx, %p, %08x)\n", hProv
, pdwReserved
, dwFlags
);
575 SetLastError(NTE_BAD_UID
);
579 if (pProv
->dwMagic
!= MAGIC_CRYPTPROV
)
581 SetLastError(ERROR_INVALID_PARAMETER
);
589 /******************************************************************************
590 * CryptReleaseContext (ADVAPI32.@)
592 * Releases the handle of a CSP. Reference count is decreased.
595 * hProv [I] Handle of a CSP.
596 * dwFlags [I] Reserved for future use and must be NULL.
602 BOOL WINAPI
CryptReleaseContext (HCRYPTPROV hProv
, DWORD dwFlags
)
604 PCRYPTPROV pProv
= (PCRYPTPROV
)hProv
;
607 TRACE("(0x%lx, %08lx)\n", hProv
, dwFlags
);
611 SetLastError(NTE_BAD_UID
);
615 if (pProv
->dwMagic
!= MAGIC_CRYPTPROV
)
617 SetLastError(ERROR_INVALID_PARAMETER
);
622 if (pProv
->refcount
<= 0)
624 ret
= pProv
->pFuncs
->pCPReleaseContext(pProv
->hPrivate
, dwFlags
);
626 FreeLibrary(pProv
->hModule
);
628 CRYPT_Free(pProv
->pVTable
->pContextInfo
);
630 CRYPT_Free(pProv
->pVTable
->pszProvName
);
631 CRYPT_Free(pProv
->pVTable
);
632 CRYPT_Free(pProv
->pFuncs
);
638 /******************************************************************************
639 * CryptGenRandom (ADVAPI32.@)
641 * Fills a buffer with cryptographically random bytes.
644 * hProv [I] Handle of a CSP.
645 * dwLen [I] Number of bytes to generate.
646 * pbBuffer [I/O] Buffer to contain random bytes.
653 * pdBuffer must be at least dwLen bytes long.
655 BOOL WINAPI
CryptGenRandom (HCRYPTPROV hProv
, DWORD dwLen
, BYTE
*pbBuffer
)
657 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
659 TRACE("(0x%lx, %d, %p)\n", hProv
, dwLen
, pbBuffer
);
663 SetLastError(ERROR_INVALID_HANDLE
);
667 if (prov
->dwMagic
!= MAGIC_CRYPTPROV
)
669 SetLastError(ERROR_INVALID_PARAMETER
);
673 return prov
->pFuncs
->pCPGenRandom(prov
->hPrivate
, dwLen
, pbBuffer
);
676 /******************************************************************************
677 * CryptCreateHash (ADVAPI32.@)
679 * Initiates the hashing of a stream of data.
682 * hProv [I] Handle of a CSP.
683 * Algid [I] Identifies the hash algorithm to use.
684 * hKey [I] Key for the hash (if required).
685 * dwFlags [I] Reserved for future use and must be NULL.
686 * phHash [O] Address of the future handle to the new hash object.
693 * If the algorithm is a keyed hash, hKey is the key.
695 BOOL WINAPI
CryptCreateHash (HCRYPTPROV hProv
, ALG_ID Algid
, HCRYPTKEY hKey
,
696 DWORD dwFlags
, HCRYPTHASH
*phHash
)
698 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
699 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
702 TRACE("(0x%lx, 0x%x, 0x%lx, %08x, %p)\n", hProv
, Algid
, hKey
, dwFlags
, phHash
);
704 if (!prov
|| !phHash
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
||
705 (key
&& key
->dwMagic
!= MAGIC_CRYPTKEY
))
707 SetLastError(ERROR_INVALID_PARAMETER
);
712 SetLastError(NTE_BAD_FLAGS
);
715 if ( !(hash
= CRYPT_Alloc(sizeof(CRYPTHASH
))) )
717 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
721 hash
->pProvider
= prov
;
722 hash
->dwMagic
= MAGIC_CRYPTHASH
;
723 if (prov
->pFuncs
->pCPCreateHash(prov
->hPrivate
, Algid
,
724 key
? key
->hPrivate
: 0, 0, &hash
->hPrivate
))
726 *phHash
= (HCRYPTHASH
)hash
;
737 /******************************************************************************
738 * CryptDecrypt (ADVAPI32.@)
740 * Decrypts data encrypted by CryptEncrypt.
743 * hKey [I] Handle to the decryption key.
744 * hHash [I] Handle to a hash object.
745 * Final [I] TRUE if this is the last section to be decrypted.
746 * dwFlags [I] Reserved for future use. Can be CRYPT_OAEP.
747 * pbData [I/O] Buffer that holds the encrypted data. Holds decrypted
749 * pdwDataLen [I/O] Length of pbData before and after the call.
755 BOOL WINAPI
CryptDecrypt (HCRYPTKEY hKey
, HCRYPTHASH hHash
, BOOL Final
,
756 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
)
759 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
760 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
762 TRACE("(0x%lx, 0x%lx, %d, %08x, %p, %p)\n", hKey
, hHash
, Final
, dwFlags
, pbData
, pdwDataLen
);
764 if (!key
|| !pbData
|| !pdwDataLen
||
765 !key
->pProvider
|| key
->dwMagic
!= MAGIC_CRYPTKEY
||
766 key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
768 SetLastError(ERROR_INVALID_PARAMETER
);
772 prov
= key
->pProvider
;
773 return prov
->pFuncs
->pCPDecrypt(prov
->hPrivate
, key
->hPrivate
, hash
? hash
->hPrivate
: 0,
774 Final
, dwFlags
, pbData
, pdwDataLen
);
777 /******************************************************************************
778 * CryptDeriveKey (ADVAPI32.@)
780 * Generates session keys derived from a base data value.
783 * hProv [I] Handle to a CSP.
784 * Algid [I] Identifies the symmetric encryption algorithm to use.
785 * hBaseData [I] Handle to a hash object.
786 * dwFlags [I] Type of key to generate.
787 * phKey [I/O] Address of the newly generated key.
793 BOOL WINAPI
CryptDeriveKey (HCRYPTPROV hProv
, ALG_ID Algid
, HCRYPTHASH hBaseData
,
794 DWORD dwFlags
, HCRYPTKEY
*phKey
)
796 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
797 PCRYPTHASH hash
= (PCRYPTHASH
)hBaseData
;
800 TRACE("(0x%lx, 0x%08x, 0x%lx, 0x%08x, %p)\n", hProv
, Algid
, hBaseData
, dwFlags
, phKey
);
804 SetLastError(ERROR_INVALID_HANDLE
);
807 if (!phKey
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
|| hash
->dwMagic
!= MAGIC_CRYPTHASH
)
809 SetLastError(ERROR_INVALID_PARAMETER
);
812 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
814 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
818 key
->pProvider
= prov
;
819 key
->dwMagic
= MAGIC_CRYPTKEY
;
820 if (prov
->pFuncs
->pCPDeriveKey(prov
->hPrivate
, Algid
, hash
->hPrivate
, dwFlags
, &key
->hPrivate
))
822 *phKey
= (HCRYPTKEY
)key
;
833 /******************************************************************************
834 * CryptDestroyHash (ADVAPI32.@)
836 * Destroys the hash object referenced by hHash.
839 * hHash [I] Handle of the hash object to be destroyed.
845 BOOL WINAPI
CryptDestroyHash (HCRYPTHASH hHash
)
847 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
851 TRACE("(0x%lx)\n", hHash
);
855 SetLastError(ERROR_INVALID_HANDLE
);
859 if (!hash
->pProvider
|| hash
->dwMagic
!= MAGIC_CRYPTHASH
||
860 hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
862 SetLastError(ERROR_INVALID_PARAMETER
);
866 prov
= hash
->pProvider
;
867 ret
= prov
->pFuncs
->pCPDestroyHash(prov
->hPrivate
, hash
->hPrivate
);
873 /******************************************************************************
874 * CryptDestroyKey (ADVAPI32.@)
876 * Releases the handle referenced by hKey.
879 * hKey [I] Handle of the key to be destroyed.
885 BOOL WINAPI
CryptDestroyKey (HCRYPTKEY hKey
)
887 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
891 TRACE("(0x%lx)\n", hKey
);
895 SetLastError(ERROR_INVALID_HANDLE
);
899 if (!key
->pProvider
|| key
->dwMagic
!= MAGIC_CRYPTKEY
||
900 key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
902 SetLastError(ERROR_INVALID_PARAMETER
);
906 prov
= key
->pProvider
;
907 ret
= prov
->pFuncs
->pCPDestroyKey(prov
->hPrivate
, key
->hPrivate
);
913 /******************************************************************************
914 * CryptDuplicateHash (ADVAPI32.@)
919 * hHash [I] Handle to the hash to be copied.
920 * pdwReserved [I] Reserved for future use and must be zero.
921 * dwFlags [I] Reserved for future use and must be zero.
922 * phHash [O] Address of the handle to receive the copy.
928 BOOL WINAPI
CryptDuplicateHash (HCRYPTHASH hHash
, DWORD
*pdwReserved
,
929 DWORD dwFlags
, HCRYPTHASH
*phHash
)
932 PCRYPTHASH orghash
, newhash
;
934 TRACE("(0x%lx, %p, %08x, %p)\n", hHash
, pdwReserved
, dwFlags
, phHash
);
936 orghash
= (PCRYPTHASH
)hHash
;
937 if (!orghash
|| pdwReserved
|| !phHash
|| !orghash
->pProvider
||
938 orghash
->dwMagic
!= MAGIC_CRYPTHASH
|| orghash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
940 SetLastError(ERROR_INVALID_PARAMETER
);
944 prov
= orghash
->pProvider
;
945 if (!prov
->pFuncs
->pCPDuplicateHash
)
947 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
951 if ( !(newhash
= CRYPT_Alloc(sizeof(CRYPTHASH
))) )
953 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
957 newhash
->pProvider
= prov
;
958 newhash
->dwMagic
= MAGIC_CRYPTHASH
;
959 if (prov
->pFuncs
->pCPDuplicateHash(prov
->hPrivate
, orghash
->hPrivate
, pdwReserved
, dwFlags
, &newhash
->hPrivate
))
961 *phHash
= (HCRYPTHASH
)newhash
;
964 newhash
->dwMagic
= 0;
969 /******************************************************************************
970 * CryptDuplicateKey (ADVAPI32.@)
972 * Duplicate a key and the key's state.
975 * hKey [I] Handle of the key to copy.
976 * pdwReserved [I] Reserved for future use and must be NULL.
977 * dwFlags [I] Reserved for future use and must be zero.
978 * phKey [I] Address of the handle to the duplicated key.
984 BOOL WINAPI
CryptDuplicateKey (HCRYPTKEY hKey
, DWORD
*pdwReserved
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
987 PCRYPTKEY orgkey
, newkey
;
989 TRACE("(0x%lx, %p, %08x, %p)\n", hKey
, pdwReserved
, dwFlags
, phKey
);
991 orgkey
= (PCRYPTKEY
)hKey
;
992 if (!orgkey
|| pdwReserved
|| !phKey
|| !orgkey
->pProvider
||
993 orgkey
->dwMagic
!= MAGIC_CRYPTKEY
||
994 orgkey
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
996 SetLastError(ERROR_INVALID_PARAMETER
);
1000 prov
= orgkey
->pProvider
;
1001 if (!prov
->pFuncs
->pCPDuplicateKey
)
1003 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1007 if ( !(newkey
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1009 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1013 newkey
->pProvider
= prov
;
1014 newkey
->dwMagic
= MAGIC_CRYPTKEY
;
1015 if (prov
->pFuncs
->pCPDuplicateKey(prov
->hPrivate
, orgkey
->hPrivate
, pdwReserved
, dwFlags
, &newkey
->hPrivate
))
1017 *phKey
= (HCRYPTKEY
)newkey
;
1020 newkey
->dwMagic
= 0;
1025 /******************************************************************************
1026 * CryptEncrypt (ADVAPI32.@)
1031 * hKey [I] Handle to the encryption key.
1032 * hHash [I] Handle to a hash object.
1033 * Final [I] TRUE if this is the last section to encrypt.
1034 * dwFlags [I] Can be CRYPT_OAEP.
1035 * pbData [I/O] Data to be encrypted. Contains encrypted data after call.
1036 * pdwDataLen [I/O] Length of the data to encrypt. Contains the length of the
1037 * encrypted data after call.
1038 * dwBufLen [I] Length of the input pbData buffer.
1045 * If pbData is NULL, CryptEncrypt determines stores the number of bytes
1046 * required for the returned data in pdwDataLen.
1048 BOOL WINAPI
CryptEncrypt (HCRYPTKEY hKey
, HCRYPTHASH hHash
, BOOL Final
,
1049 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
, DWORD dwBufLen
)
1052 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1053 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1055 TRACE("(0x%lx, 0x%lx, %d, %08x, %p, %p, %d)\n", hKey
, hHash
, Final
, dwFlags
, pbData
, pdwDataLen
, dwBufLen
);
1057 if (!key
|| !pdwDataLen
|| !key
->pProvider
||
1058 key
->dwMagic
!= MAGIC_CRYPTKEY
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1060 SetLastError(ERROR_INVALID_PARAMETER
);
1064 prov
= key
->pProvider
;
1065 return prov
->pFuncs
->pCPEncrypt(prov
->hPrivate
, key
->hPrivate
, hash
? hash
->hPrivate
: 0,
1066 Final
, dwFlags
, pbData
, pdwDataLen
, dwBufLen
);
1069 /******************************************************************************
1070 * CryptEnumProvidersW (ADVAPI32.@)
1072 * Returns the next available CSP.
1075 * dwIndex [I] Index of the next provider to be enumerated.
1076 * pdwReserved [I] Reserved for future use and must be NULL.
1077 * dwFlags [I] Reserved for future use and must be zero.
1078 * pdwProvType [O] DWORD designating the type of the provider.
1079 * pszProvName [O] Buffer that receives data from the provider.
1080 * pcbProvName [I/O] Specifies the size of pszProvName. Contains the number
1081 * of bytes stored in the buffer on return.
1088 * If pszProvName is NULL, CryptEnumProvidersW sets the size of the name
1089 * for memory allocation purposes.
1091 BOOL WINAPI
CryptEnumProvidersW (DWORD dwIndex
, DWORD
*pdwReserved
,
1092 DWORD dwFlags
, DWORD
*pdwProvType
, LPWSTR pszProvName
, DWORD
*pcbProvName
)
1095 static const WCHAR providerW
[] = {
1096 'S','o','f','t','w','a','r','e','\\',
1097 'M','i','c','r','o','s','o','f','t','\\',
1098 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
1099 'D','e','f','a','u','l','t','s','\\',
1100 'P','r','o','v','i','d','e','r',0
1102 static const WCHAR typeW
[] = {'T','y','p','e',0};
1105 TRACE("(%d, %p, %d, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
1106 pdwProvType
, pszProvName
, pcbProvName
);
1108 if (pdwReserved
|| !pcbProvName
)
1110 SetLastError(ERROR_INVALID_PARAMETER
);
1115 SetLastError(NTE_BAD_FLAGS
);
1119 if (RegOpenKeyW(HKEY_LOCAL_MACHINE
, providerW
, &hKey
))
1121 SetLastError(NTE_FAIL
);
1131 RegQueryInfoKeyW(hKey
, NULL
, NULL
, NULL
, &numkeys
, pcbProvName
,
1132 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
1134 if (!(provNameW
= CRYPT_Alloc(*pcbProvName
* sizeof(WCHAR
))))
1136 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1141 RegEnumKeyExW(hKey
, dwIndex
, provNameW
, pcbProvName
, NULL
, NULL
, NULL
, NULL
);
1142 CRYPT_Free(provNameW
);
1144 *pcbProvName
*= sizeof(WCHAR
);
1146 if (dwIndex
>= numkeys
)
1148 SetLastError(ERROR_NO_MORE_ITEMS
);
1152 DWORD size
= sizeof(DWORD
);
1156 result
= RegEnumKeyW(hKey
, dwIndex
, pszProvName
, *pcbProvName
/ sizeof(WCHAR
));
1159 SetLastError(result
);
1163 if (RegOpenKeyW(hKey
, pszProvName
, &subkey
))
1169 if (RegQueryValueExW(subkey
, typeW
, NULL
, NULL
, (BYTE
*)pdwProvType
, &size
))
1172 RegCloseKey(subkey
);
1178 /******************************************************************************
1179 * CryptEnumProvidersA (ADVAPI32.@)
1181 * See CryptEnumProvidersW.
1183 BOOL WINAPI
CryptEnumProvidersA (DWORD dwIndex
, DWORD
*pdwReserved
,
1184 DWORD dwFlags
, DWORD
*pdwProvType
, LPSTR pszProvName
, DWORD
*pcbProvName
)
1190 TRACE("(%d, %p, %08x, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
1191 pdwProvType
, pszProvName
, pcbProvName
);
1193 if(!CryptEnumProvidersW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, NULL
, &bufsize
))
1195 if ( pszProvName
&& !(str
= CRYPT_Alloc(bufsize
)) )
1197 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1200 ret
= CryptEnumProvidersW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, str
, &bufsize
);
1202 CRYPT_UnicodeToANSI(str
, &pszProvName
, *pcbProvName
);
1203 *pcbProvName
= bufsize
/ sizeof(WCHAR
); /* FIXME: not correct */
1207 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1209 SetLastError(ERROR_MORE_DATA
);
1216 /******************************************************************************
1217 * CryptEnumProviderTypesW (ADVAPI32.@)
1219 * Retrieves the next type of CSP supported.
1222 * dwIndex [I] Index of the next provider to be enumerated.
1223 * pdwReserved [I] Reserved for future use and must be NULL.
1224 * dwFlags [I] Reserved for future use and must be zero.
1225 * pdwProvType [O] DWORD designating the type of the provider.
1226 * pszTypeName [O] Buffer that receives data from the provider type.
1227 * pcbTypeName [I/O] Specifies the size of pszTypeName. Contains the number
1228 * of bytes stored in the buffer on return.
1235 * If pszTypeName is NULL, CryptEnumProviderTypesW sets the size of the name
1236 * for memory allocation purposes.
1238 BOOL WINAPI
CryptEnumProviderTypesW (DWORD dwIndex
, DWORD
*pdwReserved
,
1239 DWORD dwFlags
, DWORD
*pdwProvType
, LPWSTR pszTypeName
, DWORD
*pcbTypeName
)
1242 DWORD keylen
, numkeys
, dwType
;
1245 static const WCHAR KEYSTR
[] = {
1246 'S','o','f','t','w','a','r','e','\\',
1247 'M','i','c','r','o','s','o','f','t','\\',
1248 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
1249 'D','e','f','a','u','l','t','s','\\',
1250 'P','r','o','v','i','d','e','r',' ','T','y','p','e','s',0
1252 static const WCHAR typenameW
[] = {'T','y','p','e','N','a','m','e',0};
1254 TRACE("(%d, %p, %08x, %p, %p, %p)\n", dwIndex
, pdwReserved
,
1255 dwFlags
, pdwProvType
, pszTypeName
, pcbTypeName
);
1257 if (pdwReserved
|| !pdwProvType
|| !pcbTypeName
)
1259 SetLastError(ERROR_INVALID_PARAMETER
);
1264 SetLastError(NTE_BAD_FLAGS
);
1268 if (RegOpenKeyW(HKEY_LOCAL_MACHINE
, KEYSTR
, &hKey
))
1271 RegQueryInfoKeyW(hKey
, NULL
, NULL
, NULL
, &numkeys
, &keylen
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
1272 if (dwIndex
>= numkeys
)
1274 SetLastError(ERROR_NO_MORE_ITEMS
);
1279 if ( !(keyname
= CRYPT_Alloc(keylen
*sizeof(WCHAR
))) )
1281 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1285 if ( RegEnumKeyW(hKey
, dwIndex
, keyname
, keylen
) ) {
1286 CRYPT_Free(keyname
);
1290 RegOpenKeyW(hKey
, keyname
, &hSubkey
);
1293 ch
= keyname
+ strlenW(keyname
);
1294 /* Convert "Type 000" to 0, etc/ */
1295 *pdwProvType
= *(--ch
) - '0';
1296 *pdwProvType
+= (*(--ch
) - '0') * 10;
1297 *pdwProvType
+= (*(--ch
) - '0') * 100;
1298 CRYPT_Free(keyname
);
1300 result
= RegQueryValueExW(hSubkey
, typenameW
, NULL
, &dwType
, (LPBYTE
)pszTypeName
, pcbTypeName
);
1303 SetLastError(result
);
1304 RegCloseKey(hSubkey
);
1308 RegCloseKey(hSubkey
);
1312 /******************************************************************************
1313 * CryptEnumProviderTypesA (ADVAPI32.@)
1315 * See CryptEnumProviderTypesW.
1317 BOOL WINAPI
CryptEnumProviderTypesA (DWORD dwIndex
, DWORD
*pdwReserved
,
1318 DWORD dwFlags
, DWORD
*pdwProvType
, LPSTR pszTypeName
, DWORD
*pcbTypeName
)
1324 TRACE("(%d, %p, %08x, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
1325 pdwProvType
, pszTypeName
, pcbTypeName
);
1327 if(!CryptEnumProviderTypesW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, NULL
, &bufsize
))
1329 if ( pszTypeName
&& !(str
= CRYPT_Alloc(bufsize
)) )
1331 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1334 ret
= CryptEnumProviderTypesW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, str
, &bufsize
);
1336 CRYPT_UnicodeToANSI(str
, &pszTypeName
, *pcbTypeName
);
1337 *pcbTypeName
= bufsize
/ sizeof(WCHAR
);
1341 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1343 SetLastError(ERROR_MORE_DATA
);
1350 /******************************************************************************
1351 * CryptExportKey (ADVAPI32.@)
1353 * Exports a cryptographic key from a CSP.
1356 * hKey [I] Handle to the key to export.
1357 * hExpKey [I] Handle to a cryptographic key of the end user.
1358 * dwBlobType [I] Type of BLOB to be exported.
1359 * dwFlags [I] CRYPT_DESTROYKEY/SSL2_FALLBACK/OAEP.
1360 * pbData [O] Buffer to receive BLOB data.
1361 * pdwDataLen [I/O] Specifies the size of pbData.
1368 * if pbData is NULL, CryptExportKey sets pdwDataLen as the size of the
1369 * buffer needed to hold the BLOB.
1371 BOOL WINAPI
CryptExportKey (HCRYPTKEY hKey
, HCRYPTKEY hExpKey
, DWORD dwBlobType
,
1372 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
)
1375 PCRYPTKEY key
= (PCRYPTKEY
)hKey
, expkey
= (PCRYPTKEY
)hExpKey
;
1377 TRACE("(0x%lx, 0x%lx, %d, %08x, %p, %p)\n", hKey
, hExpKey
, dwBlobType
, dwFlags
, pbData
, pdwDataLen
);
1379 if (!key
|| !pdwDataLen
|| !key
->pProvider
||
1380 key
->dwMagic
!= MAGIC_CRYPTKEY
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1382 SetLastError(ERROR_INVALID_PARAMETER
);
1386 prov
= key
->pProvider
;
1387 return prov
->pFuncs
->pCPExportKey(prov
->hPrivate
, key
->hPrivate
, expkey
? expkey
->hPrivate
: 0,
1388 dwBlobType
, dwFlags
, pbData
, pdwDataLen
);
1391 /******************************************************************************
1392 * CryptGenKey (ADVAPI32.@)
1394 * Generates a random cryptographic session key or a pub/priv key pair.
1397 * hProv [I] Handle to a CSP.
1398 * Algid [I] Algorithm to use to make key.
1399 * dwFlags [I] Specifies type of key to make.
1400 * phKey [I] Address of the handle to which the new key is copied.
1406 BOOL WINAPI
CryptGenKey (HCRYPTPROV hProv
, ALG_ID Algid
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
1408 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1411 TRACE("(0x%lx, %d, %08x, %p)\n", hProv
, Algid
, dwFlags
, phKey
);
1413 if (!phKey
|| !prov
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1415 SetLastError(ERROR_INVALID_PARAMETER
);
1418 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1420 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1424 key
->pProvider
= prov
;
1425 key
->dwMagic
= MAGIC_CRYPTKEY
;
1426 if (prov
->pFuncs
->pCPGenKey(prov
->hPrivate
, Algid
, dwFlags
, &key
->hPrivate
))
1428 *phKey
= (HCRYPTKEY
)key
;
1438 /******************************************************************************
1439 * CryptGetDefaultProviderW (ADVAPI32.@)
1441 * Finds the default CSP of a certain provider type.
1444 * dwProvType [I] Provider type to look for.
1445 * pdwReserved [I] Reserved for future use and must be NULL.
1446 * dwFlags [I] CRYPT_MACHINE_DEFAULT/USER_DEFAULT
1447 * pszProvName [O] Name of the default CSP.
1448 * pcbProvName [I/O] Size of pszProvName
1455 * If pszProvName is NULL, pcbProvName will hold the size of the buffer for
1456 * memory allocation purposes on return.
1458 BOOL WINAPI
CryptGetDefaultProviderW (DWORD dwProvType
, DWORD
*pdwReserved
,
1459 DWORD dwFlags
, LPWSTR pszProvName
, DWORD
*pcbProvName
)
1464 static const WCHAR nameW
[] = {'N','a','m','e',0};
1466 if (pdwReserved
|| !pcbProvName
)
1468 SetLastError(ERROR_INVALID_PARAMETER
);
1471 if (dwFlags
& ~(CRYPT_USER_DEFAULT
| CRYPT_MACHINE_DEFAULT
))
1473 SetLastError(NTE_BAD_FLAGS
);
1476 if (dwProvType
> 999)
1478 SetLastError(NTE_BAD_PROV_TYPE
);
1481 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, dwFlags
& CRYPT_USER_DEFAULT
)) )
1483 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1486 if (RegOpenKeyW((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,keyname
, &hKey
))
1488 CRYPT_Free(keyname
);
1489 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
1492 CRYPT_Free(keyname
);
1494 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
);
1510 /******************************************************************************
1511 * CryptGetDefaultProviderA (ADVAPI32.@)
1513 * See CryptGetDefaultProviderW.
1515 BOOL WINAPI
CryptGetDefaultProviderA (DWORD dwProvType
, DWORD
*pdwReserved
,
1516 DWORD dwFlags
, LPSTR pszProvName
, DWORD
*pcbProvName
)
1522 TRACE("(%d, %p, %08x, %p, %p)\n", dwProvType
, pdwReserved
, dwFlags
, pszProvName
, pcbProvName
);
1524 CryptGetDefaultProviderW(dwProvType
, pdwReserved
, dwFlags
, NULL
, &bufsize
);
1525 if ( pszProvName
&& !(str
= CRYPT_Alloc(bufsize
)) )
1527 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1530 ret
= CryptGetDefaultProviderW(dwProvType
, pdwReserved
, dwFlags
, str
, &bufsize
);
1532 CRYPT_UnicodeToANSI(str
, &pszProvName
, *pcbProvName
);
1533 *pcbProvName
= bufsize
/ sizeof(WCHAR
);
1537 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1539 SetLastError(ERROR_MORE_DATA
);
1546 /******************************************************************************
1547 * CryptGetHashParam (ADVAPI32.@)
1549 * Retrieves data that controls the operations of a hash object.
1552 * hHash [I] Handle of the hash object to question.
1553 * dwParam [I] Query type.
1554 * pbData [O] Buffer that receives the value data.
1555 * pdwDataLen [I/O] Size of the pbData buffer.
1556 * dwFlags [I] Reserved for future use and must be zero.
1563 * If pbData is NULL, pdwDataLen will contain the length required.
1565 BOOL WINAPI
CryptGetHashParam (HCRYPTHASH hHash
, DWORD dwParam
, BYTE
*pbData
,
1566 DWORD
*pdwDataLen
, DWORD dwFlags
)
1569 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1571 TRACE("(0x%lx, %d, %p, %p, %08x)\n", hHash
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1573 if (!hash
|| !pdwDataLen
|| !hash
->pProvider
||
1574 hash
->dwMagic
!= MAGIC_CRYPTHASH
|| 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
||
1613 key
->dwMagic
!= MAGIC_CRYPTKEY
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1615 SetLastError(ERROR_INVALID_PARAMETER
);
1619 prov
= key
->pProvider
;
1620 return prov
->pFuncs
->pCPGetKeyParam(prov
->hPrivate
, key
->hPrivate
, dwParam
,
1621 pbData
, pdwDataLen
, dwFlags
);
1624 /******************************************************************************
1625 * CryptGetProvParam (ADVAPI32.@)
1627 * Retrieves parameters that control the operations of a CSP.
1630 * hProv [I] Handle of the CSP in question.
1631 * dwParam [I] Specifies query type.
1632 * pbData [O] Buffer to receive the data.
1633 * pdwDataLen [I/O] Size of pbData.
1634 * dwFlags [I] see MSDN Docs.
1641 * If pbData is NULL, pdwDataLen is set to the needed buffer length.
1643 BOOL WINAPI
CryptGetProvParam (HCRYPTPROV hProv
, DWORD dwParam
, BYTE
*pbData
,
1644 DWORD
*pdwDataLen
, DWORD dwFlags
)
1646 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1648 TRACE("(0x%lx, %d, %p, %p, %08x)\n", hProv
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1650 if (!prov
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1652 SetLastError(ERROR_INVALID_PARAMETER
);
1656 return prov
->pFuncs
->pCPGetProvParam(prov
->hPrivate
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1659 /******************************************************************************
1660 * CryptGetUserKey (ADVAPI32.@)
1662 * Gets a handle of one of a user's two public/private key pairs.
1665 * hProv [I] Handle of a CSP.
1666 * dwKeySpec [I] Private key to use.
1667 * phUserKey [O] Pointer to the handle of the retrieved keys.
1673 BOOL WINAPI
CryptGetUserKey (HCRYPTPROV hProv
, DWORD dwKeySpec
, HCRYPTKEY
*phUserKey
)
1675 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1678 TRACE("(0x%lx, %d, %p)\n", hProv
, dwKeySpec
, phUserKey
);
1682 SetLastError(ERROR_INVALID_HANDLE
);
1685 if (!phUserKey
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1687 SetLastError(ERROR_INVALID_PARAMETER
);
1690 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1692 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1696 key
->pProvider
= prov
;
1697 key
->dwMagic
= MAGIC_CRYPTKEY
;
1698 if (prov
->pFuncs
->pCPGetUserKey(prov
->hPrivate
, dwKeySpec
, &key
->hPrivate
))
1700 *phUserKey
= (HCRYPTKEY
)key
;
1711 /******************************************************************************
1712 * CryptHashData (ADVAPI32.@)
1714 * Adds data to a hash object.
1717 * hHash [I] Handle of the hash object.
1718 * pbData [I] Buffer of data to be hashed.
1719 * dwDataLen [I] Number of bytes to add.
1720 * dwFlags [I] Can be CRYPT_USERDATA
1726 BOOL WINAPI
CryptHashData (HCRYPTHASH hHash
, const BYTE
*pbData
, DWORD dwDataLen
, DWORD dwFlags
)
1728 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1731 TRACE("(0x%lx, %p, %d, %08x)\n", hHash
, pbData
, dwDataLen
, dwFlags
);
1735 SetLastError(ERROR_INVALID_HANDLE
);
1738 if (!hash
->pProvider
|| hash
->dwMagic
!= MAGIC_CRYPTHASH
||
1739 hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1741 SetLastError(ERROR_INVALID_PARAMETER
);
1745 prov
= hash
->pProvider
;
1746 return prov
->pFuncs
->pCPHashData(prov
->hPrivate
, hash
->hPrivate
, pbData
, dwDataLen
, dwFlags
);
1749 /******************************************************************************
1750 * CryptHashSessionKey (ADVAPI32.@)
1752 * Compute the cryptographic hash of a session key object.
1755 * hHash [I] Handle to the hash object.
1756 * hKey [I] Handle to the key to be hashed.
1757 * dwFlags [I] Can be CRYPT_LITTLE_ENDIAN.
1763 BOOL WINAPI
CryptHashSessionKey (HCRYPTHASH hHash
, HCRYPTKEY hKey
, DWORD dwFlags
)
1765 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1766 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1769 TRACE("(0x%lx, 0x%lx, %08x)\n", hHash
, hKey
, dwFlags
);
1773 SetLastError(ERROR_INVALID_HANDLE
);
1777 if (!hash
->pProvider
|| hash
->dwMagic
!= MAGIC_CRYPTHASH
||
1778 hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
|| key
->dwMagic
!= MAGIC_CRYPTKEY
)
1780 SetLastError(ERROR_INVALID_PARAMETER
);
1784 prov
= hash
->pProvider
;
1785 return prov
->pFuncs
->pCPHashSessionKey(prov
->hPrivate
, hash
->hPrivate
, key
->hPrivate
, dwFlags
);
1788 /******************************************************************************
1789 * CryptImportKey (ADVAPI32.@)
1791 * Transfer a cryptographic key from a key BLOB into a cryptographic service provider (CSP).
1794 * hProv [I] Handle of a CSP.
1795 * pbData [I] Contains the key to be imported.
1796 * dwDataLen [I] Length of the key.
1797 * hPubKey [I] Cryptographic key that decrypts pdData
1798 * dwFlags [I] Used only with a public/private key pair.
1799 * phKey [O] Imported key.
1805 BOOL WINAPI
CryptImportKey (HCRYPTPROV hProv
, const BYTE
*pbData
, DWORD dwDataLen
,
1806 HCRYPTKEY hPubKey
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
1808 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1809 PCRYPTKEY pubkey
= (PCRYPTKEY
)hPubKey
, importkey
;
1811 TRACE("(0x%lx, %p, %d, 0x%lx, %08x, %p)\n", hProv
, pbData
, dwDataLen
, hPubKey
, dwFlags
, phKey
);
1813 if (!prov
|| !pbData
|| !dwDataLen
|| !phKey
||
1814 prov
->dwMagic
!= MAGIC_CRYPTPROV
||
1815 (pubkey
&& pubkey
->dwMagic
!= MAGIC_CRYPTKEY
))
1817 SetLastError(ERROR_INVALID_PARAMETER
);
1821 if ( !(importkey
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1823 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1827 importkey
->pProvider
= prov
;
1828 importkey
->dwMagic
= MAGIC_CRYPTKEY
;
1829 if (prov
->pFuncs
->pCPImportKey(prov
->hPrivate
, pbData
, dwDataLen
,
1830 pubkey
? pubkey
->hPrivate
: 0, dwFlags
, &importkey
->hPrivate
))
1832 *phKey
= (HCRYPTKEY
)importkey
;
1836 importkey
->dwMagic
= 0;
1837 CRYPT_Free(importkey
);
1841 /******************************************************************************
1842 * CryptSignHashW (ADVAPI32.@)
1847 * hHash [I] Handle of the hash object to be signed.
1848 * dwKeySpec [I] Private key to use.
1849 * sDescription [I] Should be NULL.
1850 * dwFlags [I] CRYPT_NOHASHOID/X931_FORMAT.
1851 * pbSignature [O] Buffer of the signature data.
1852 * pdwSigLen [I/O] Size of the pbSignature buffer.
1859 * Because of security flaws sDescription should not be used and should thus be
1860 * NULL. It is supported only for compatibility with Microsoft's Cryptographic
1863 BOOL WINAPI
CryptSignHashW (HCRYPTHASH hHash
, DWORD dwKeySpec
, LPCWSTR sDescription
,
1864 DWORD dwFlags
, BYTE
*pbSignature
, DWORD
*pdwSigLen
)
1866 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1869 TRACE("(0x%lx, %d, %s, %08x, %p, %p)\n",
1870 hHash
, dwKeySpec
, debugstr_w(sDescription
), dwFlags
, pbSignature
, pdwSigLen
);
1874 SetLastError(ERROR_INVALID_HANDLE
);
1877 if (!pdwSigLen
|| !hash
->pProvider
|| hash
->dwMagic
!= MAGIC_CRYPTHASH
||
1878 hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1880 SetLastError(ERROR_INVALID_PARAMETER
);
1884 prov
= hash
->pProvider
;
1885 return prov
->pFuncs
->pCPSignHash(prov
->hPrivate
, hash
->hPrivate
, dwKeySpec
, sDescription
,
1886 dwFlags
, pbSignature
, pdwSigLen
);
1889 /******************************************************************************
1890 * CryptSignHashA (ADVAPI32.@)
1892 * See CryptSignHashW.
1894 BOOL WINAPI
CryptSignHashA (HCRYPTHASH hHash
, DWORD dwKeySpec
, LPCSTR sDescription
,
1895 DWORD dwFlags
, BYTE
*pbSignature
, DWORD
*pdwSigLen
)
1897 LPWSTR wsDescription
;
1900 TRACE("(0x%lx, %d, %s, %08x, %p, %p)\n",
1901 hHash
, dwKeySpec
, debugstr_a(sDescription
), dwFlags
, pbSignature
, pdwSigLen
);
1903 CRYPT_ANSIToUnicode(sDescription
, &wsDescription
, -1);
1904 result
= CryptSignHashW(hHash
, dwKeySpec
, wsDescription
, dwFlags
, pbSignature
, pdwSigLen
);
1905 CRYPT_Free(wsDescription
);
1910 /******************************************************************************
1911 * CryptSetHashParam (ADVAPI32.@)
1913 * Customizes the operations of a hash object.
1916 * hHash [I] Handle of the hash object to set parameters.
1917 * dwParam [I] HP_HMAC_INFO/HASHVAL.
1918 * pbData [I] Value data buffer.
1919 * dwFlags [I] Reserved for future use and must be zero.
1925 BOOL WINAPI
CryptSetHashParam (HCRYPTHASH hHash
, DWORD dwParam
, const BYTE
*pbData
, DWORD dwFlags
)
1928 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1930 TRACE("(0x%lx, %d, %p, %08x)\n", hHash
, dwParam
, pbData
, dwFlags
);
1932 if (!hash
|| !pbData
|| !hash
->pProvider
||
1933 hash
->dwMagic
!= MAGIC_CRYPTHASH
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1935 SetLastError(ERROR_INVALID_PARAMETER
);
1939 prov
= hash
->pProvider
;
1940 return prov
->pFuncs
->pCPSetHashParam(prov
->hPrivate
, hash
->hPrivate
,
1941 dwParam
, pbData
, dwFlags
);
1944 /******************************************************************************
1945 * CryptSetKeyParam (ADVAPI32.@)
1947 * Customizes a session key's operations.
1950 * hKey [I] Handle to the key to set values.
1951 * dwParam [I] See MSDN Doc.
1952 * pbData [I] Buffer of values to set.
1953 * dwFlags [I] Only used when dwParam == KP_ALGID.
1959 BOOL WINAPI
CryptSetKeyParam (HCRYPTKEY hKey
, DWORD dwParam
, const BYTE
*pbData
, DWORD dwFlags
)
1962 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1964 TRACE("(0x%lx, %d, %p, %08x)\n", hKey
, dwParam
, pbData
, dwFlags
);
1966 if (!key
|| !pbData
|| !key
->pProvider
||
1967 key
->dwMagic
!= MAGIC_CRYPTKEY
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1969 SetLastError(ERROR_INVALID_PARAMETER
);
1973 prov
= key
->pProvider
;
1974 return prov
->pFuncs
->pCPSetKeyParam(prov
->hPrivate
, key
->hPrivate
,
1975 dwParam
, pbData
, dwFlags
);
1978 /******************************************************************************
1979 * CryptSetProviderA (ADVAPI32.@)
1981 * Specifies the current user's default CSP.
1984 * pszProvName [I] Name of the new default CSP.
1985 * dwProvType [I] Provider type of the CSP.
1991 BOOL WINAPI
CryptSetProviderA (LPCSTR pszProvName
, DWORD dwProvType
)
1993 TRACE("(%s, %d)\n", pszProvName
, dwProvType
);
1994 return CryptSetProviderExA(pszProvName
, dwProvType
, NULL
, CRYPT_USER_DEFAULT
);
1997 /******************************************************************************
1998 * CryptSetProviderW (ADVAPI32.@)
2000 * See CryptSetProviderA.
2002 BOOL WINAPI
CryptSetProviderW (LPCWSTR pszProvName
, DWORD dwProvType
)
2004 TRACE("(%s, %d)\n", debugstr_w(pszProvName
), dwProvType
);
2005 return CryptSetProviderExW(pszProvName
, dwProvType
, NULL
, CRYPT_USER_DEFAULT
);
2008 /******************************************************************************
2009 * CryptSetProviderExW (ADVAPI32.@)
2011 * Specifies the default CSP.
2014 * pszProvName [I] Name of the new default CSP.
2015 * dwProvType [I] Provider type of the CSP.
2016 * pdwReserved [I] Reserved for future use and must be NULL.
2017 * dwFlags [I] See MSDN Doc.
2023 BOOL WINAPI
CryptSetProviderExW (LPCWSTR pszProvName
, DWORD dwProvType
, DWORD
*pdwReserved
, DWORD dwFlags
)
2025 HKEY hProvKey
, hTypeKey
;
2027 static const WCHAR nameW
[] = {'N','a','m','e',0};
2029 TRACE("(%s, %d, %p, %08x)\n", debugstr_w(pszProvName
), dwProvType
, pdwReserved
, dwFlags
);
2031 if (!pszProvName
|| pdwReserved
)
2033 SetLastError(ERROR_INVALID_PARAMETER
);
2036 if (dwProvType
> MAXPROVTYPES
)
2038 SetLastError(NTE_BAD_PROV_TYPE
);
2041 if (dwFlags
& ~(CRYPT_MACHINE_DEFAULT
| CRYPT_USER_DEFAULT
| CRYPT_DELETE_DEFAULT
)
2042 || dwFlags
== CRYPT_DELETE_DEFAULT
)
2044 SetLastError(NTE_BAD_FLAGS
);
2048 if (!(keyname
= CRYPT_GetTypeKeyName(dwProvType
, dwFlags
& CRYPT_USER_DEFAULT
)))
2050 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2053 if (RegOpenKeyW((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,
2054 keyname
, &hTypeKey
))
2056 CRYPT_Free(keyname
);
2057 SetLastError(NTE_BAD_PROVIDER
);
2060 CRYPT_Free(keyname
);
2062 if (dwFlags
& CRYPT_DELETE_DEFAULT
)
2064 RegDeleteValueW(hTypeKey
, nameW
);
2068 if (!(keyname
= CRYPT_GetProvKeyName(pszProvName
)))
2070 RegCloseKey(hTypeKey
);
2071 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2074 if (RegOpenKeyW((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,
2075 keyname
, &hProvKey
))
2077 CRYPT_Free(keyname
);
2078 RegCloseKey(hTypeKey
);
2079 SetLastError(NTE_BAD_PROVIDER
);
2082 CRYPT_Free(keyname
);
2084 if (RegSetValueExW(hTypeKey
, nameW
, 0, REG_SZ
, (const BYTE
*)pszProvName
,
2085 (strlenW(pszProvName
) + 1)*sizeof(WCHAR
)))
2087 RegCloseKey(hTypeKey
);
2088 RegCloseKey(hProvKey
);
2092 RegCloseKey(hProvKey
);
2094 RegCloseKey(hTypeKey
);
2099 /******************************************************************************
2100 * CryptSetProviderExA (ADVAPI32.@)
2102 * See CryptSetProviderExW.
2104 BOOL WINAPI
CryptSetProviderExA (LPCSTR pszProvName
, DWORD dwProvType
, DWORD
*pdwReserved
, DWORD dwFlags
)
2109 TRACE("(%s, %d, %p, %08x)\n", pszProvName
, dwProvType
, pdwReserved
, dwFlags
);
2111 if (CRYPT_ANSIToUnicode(pszProvName
, &str
, -1))
2113 ret
= CryptSetProviderExW(str
, dwProvType
, pdwReserved
, dwFlags
);
2119 /******************************************************************************
2120 * CryptSetProvParam (ADVAPI32.@)
2122 * Customizes the operations of a CSP.
2125 * hProv [I] Handle of a CSP.
2126 * dwParam [I] See MSDN Doc.
2127 * pbData [I] Buffer that contains a value to set as a parameter.
2128 * dwFlags [I] if dwParam is PP_USE_HARDWARE_RNG, dwFlags must be zero.
2134 BOOL WINAPI
CryptSetProvParam (HCRYPTPROV hProv
, DWORD dwParam
, const BYTE
*pbData
, DWORD dwFlags
)
2136 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
2138 TRACE("(0x%lx, %d, %p, %08x)\n", hProv
, dwParam
, pbData
, dwFlags
);
2142 SetLastError(ERROR_INVALID_HANDLE
);
2145 if (prov
->dwMagic
!= MAGIC_CRYPTPROV
)
2147 SetLastError(ERROR_INVALID_PARAMETER
);
2150 if (dwParam
== PP_USE_HARDWARE_RNG
)
2152 FIXME("PP_USE_HARDWARE_RNG: What do I do with this?\n");
2153 FIXME("\tLetting the CSP decide.\n");
2155 if (dwFlags
& PP_CLIENT_HWND
)
2157 /* FIXME: Should verify the parameter */
2158 if (pbData
/* && IsWindow((HWND)pbData) */)
2160 crypt_hWindow
= (HWND
)(pbData
);
2163 SetLastError(ERROR_INVALID_PARAMETER
);
2167 /* All other flags go to the CSP */
2168 return prov
->pFuncs
->pCPSetProvParam(prov
->hPrivate
, dwParam
, pbData
, dwFlags
);
2171 /******************************************************************************
2172 * CryptVerifySignatureW (ADVAPI32.@)
2174 * Verifies the signature of a hash object.
2177 * hHash [I] Handle of the hash object to verify.
2178 * pbSignature [I] Signature data to verify.
2179 * dwSigLen [I] Size of pbSignature.
2180 * hPubKey [I] Handle to the public key to authenticate signature.
2181 * sDescription [I] Should be NULL.
2182 * dwFlags [I] See MSDN doc.
2189 * Because of security flaws sDescription should not be used and should thus be
2190 * NULL. It is supported only for compatibility with Microsoft's Cryptographic
2193 BOOL WINAPI
CryptVerifySignatureW (HCRYPTHASH hHash
, const BYTE
*pbSignature
, DWORD dwSigLen
,
2194 HCRYPTKEY hPubKey
, LPCWSTR sDescription
, DWORD dwFlags
)
2196 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
2197 PCRYPTKEY key
= (PCRYPTKEY
)hPubKey
;
2200 TRACE("(0x%lx, %p, %d, 0x%lx, %s, %08x)\n", hHash
, pbSignature
,
2201 dwSigLen
, hPubKey
, debugstr_w(sDescription
), dwFlags
);
2203 if (!hash
|| !key
|| key
->dwMagic
!= MAGIC_CRYPTKEY
|| hash
->dwMagic
!= MAGIC_CRYPTHASH
||
2204 !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
||
2205 !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
2207 SetLastError(ERROR_INVALID_PARAMETER
);
2211 prov
= hash
->pProvider
;
2212 return prov
->pFuncs
->pCPVerifySignature(prov
->hPrivate
, hash
->hPrivate
, pbSignature
, dwSigLen
,
2213 key
->hPrivate
, sDescription
, dwFlags
);
2216 /******************************************************************************
2217 * CryptVerifySignatureA (ADVAPI32.@)
2219 * See CryptVerifySignatureW.
2221 BOOL WINAPI
CryptVerifySignatureA (HCRYPTHASH hHash
, const BYTE
*pbSignature
, DWORD dwSigLen
,
2222 HCRYPTKEY hPubKey
, LPCSTR sDescription
, DWORD dwFlags
)
2224 LPWSTR wsDescription
;
2227 TRACE("(0x%lx, %p, %d, 0x%lx, %s, %08x)\n", hHash
, pbSignature
,
2228 dwSigLen
, hPubKey
, debugstr_a(sDescription
), dwFlags
);
2230 CRYPT_ANSIToUnicode(sDescription
, &wsDescription
, -1);
2231 result
= CryptVerifySignatureW(hHash
, pbSignature
, dwSigLen
, hPubKey
, wsDescription
, dwFlags
);
2232 CRYPT_Free(wsDescription
);
2238 /******************************************************************************
2239 * SystemFunction030 (ADVAPI32.@)
2241 * Tests if two blocks of 16 bytes are equal
2244 * b1,b2 [I] block of 16 bytes
2247 * TRUE if blocks are the same
2248 * FALSE if blocks are different
2250 BOOL WINAPI
SystemFunction030(LPCVOID b1
, LPCVOID b2
)
2252 return !memcmp(b1
, b2
, 0x10);
2255 /******************************************************************************
2256 * SystemFunction035 (ADVAPI32.@)
2259 http://disc.server.com/discussion.cgi?disc=148775;article=942;title=Coding%2FASM%2FSystem
2262 * Stub, always return TRUE.
2264 BOOL WINAPI
SystemFunction035(LPCSTR lpszDllFilePath
)
2266 FIXME("%s: stub\n", debugstr_a(lpszDllFilePath
));
2270 /******************************************************************************
2271 * SystemFunction036 (ADVAPI32.@)
2273 * MSDN documents this function as RtlGenRandom and declares it in ntsecapi.h
2276 * pbBufer [O] Pointer to memory to receive random bytes.
2277 * dwLen [I] Number of random bytes to fetch.
2284 BOOLEAN WINAPI
SystemFunction036(PVOID pbBuffer
, ULONG dwLen
)
2288 dev_random
= open("/dev/urandom", O_RDONLY
);
2289 if (dev_random
!= -1)
2291 if (read(dev_random
, pbBuffer
, dwLen
) == (ssize_t
)dwLen
)
2299 FIXME("couldn't open /dev/urandom\n");
2300 SetLastError(NTE_FAIL
);
2305 These functions have nearly identical prototypes to CryptProtectMemory and CryptUnprotectMemory,
2309 /******************************************************************************
2310 * SystemFunction040 (ADVAPI32.@)
2312 * MSDN documents this function as RtlEncryptMemory and declares it in ntsecapi.h.
2315 * memory [I/O] Pointer to memory to encrypt.
2316 * length [I] Length of region to encrypt in bytes.
2317 * flags [I] Control whether other processes are able to decrypt the memory.
2318 * RTL_ENCRYPT_OPTION_SAME_PROCESS
2319 * RTL_ENCRYPT_OPTION_CROSS_PROCESS
2320 * RTL_ENCRYPT_OPTION_SAME_LOGON
2323 * Success: STATUS_SUCCESS
2324 * Failure: NTSTATUS error code
2327 * length must be a multiple of RTL_ENCRYPT_MEMORY_SIZE.
2328 * If flags are specified when encrypting, the same flag value must be given
2329 * when decrypting the memory.
2331 NTSTATUS WINAPI
SystemFunction040(PVOID memory
, ULONG length
, ULONG flags
)
2333 FIXME("(%p, %x, %x): stub [RtlEncryptMemory]\n", memory
, length
, flags
);
2334 return STATUS_SUCCESS
;
2337 /******************************************************************************
2338 * SystemFunction041 (ADVAPI32.@)
2340 * MSDN documents this function as RtlDecryptMemory and declares it in ntsecapi.h.
2343 * memory [I/O] Pointer to memory to decrypt.
2344 * length [I] Length of region to decrypt in bytes.
2345 * flags [I] Control whether other processes are able to decrypt the memory.
2346 * RTL_ENCRYPT_OPTION_SAME_PROCESS
2347 * RTL_ENCRYPT_OPTION_CROSS_PROCESS
2348 * RTL_ENCRYPT_OPTION_SAME_LOGON
2351 * Success: STATUS_SUCCESS
2352 * Failure: NTSTATUS error code
2355 * length must be a multiple of RTL_ENCRYPT_MEMORY_SIZE.
2356 * If flags are specified when encrypting, the same flag value must be given
2357 * when decrypting the memory.
2359 NTSTATUS WINAPI
SystemFunction041(PVOID memory
, ULONG length
, ULONG flags
)
2361 FIXME("(%p, %x, %x): stub [RtlDecryptMemory]\n", memory
, length
, flags
);
2362 return STATUS_SUCCESS
;
2364 #endif /* !__REACTOS __ */
2366 /******************************************************************************
2367 * WriteEncryptedFileRaw (ADVAPI32.@)
2369 * Import encrypted files
2372 * import [I] pointer to the import callback function
2373 * callback [I] pointer to the application defined context
2374 * context [I] pointer to the system context
2376 * Success: ERROR_SUCCESS
2377 * Failure: NTSTATUS error code
2379 DWORD WINAPI
WriteEncryptedFileRaw(PFE_IMPORT_FUNC import
, PVOID callback
, PVOID context
)
2381 FIXME("(%p, %p, %p): stub\n", import
, callback
, context
);
2382 return ERROR_CALL_NOT_IMPLEMENTED
;