2 * Copyright 1999 Ian Schmidt
3 * Copyright 2001 Travis Michielsen
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 /***********************************************************************
23 * - Reference counting
28 #include "wine/port.h"
33 #include <sys/types.h>
34 #ifdef HAVE_SYS_STAT_H
35 # include <sys/stat.h>
45 #include "wine/debug.h"
46 #include "wine/unicode.h"
50 WINE_DEFAULT_DEBUG_CHANNEL(crypt
);
52 HWND crypt_hWindow
= 0;
54 #define CRYPT_ReturnLastError(err) do {SetLastError(err); return FALSE;} while(0)
56 #define CRYPT_Alloc(size) ((LPVOID)LocalAlloc(LMEM_ZEROINIT, size))
57 #define CRYPT_Free(buffer) (LocalFree((HLOCAL)buffer))
59 static inline PWSTR
CRYPT_GetProvKeyName(PCWSTR pProvName
)
61 static const WCHAR KEYSTR
[] = {
62 'S','o','f','t','w','a','r','e','\\',
63 'M','i','c','r','o','s','o','f','t','\\',
64 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
65 'D','e','f','a','u','l','t','s','\\',
66 'P','r','o','v','i','d','e','r','\\',0
70 keyname
= CRYPT_Alloc((strlenW(KEYSTR
) + strlenW(pProvName
) +1)*sizeof(WCHAR
));
73 strcpyW(keyname
, KEYSTR
);
74 strcpyW(keyname
+ strlenW(KEYSTR
), pProvName
);
76 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
80 static inline PWSTR
CRYPT_GetTypeKeyName(DWORD dwType
, BOOL user
)
82 static const WCHAR MACHINESTR
[] = {
83 'S','o','f','t','w','a','r','e','\\',
84 'M','i','c','r','o','s','o','f','t','\\',
85 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
86 'D','e','f','a','u','l','t','s','\\',
87 'P','r','o','v','i','d','e','r',' ','T','y','p','e','s','\\',
88 'T','y','p','e',' ','X','X','X',0
90 static const WCHAR USERSTR
[] = {
91 'S','o','f','t','w','a','r','e','\\',
92 'M','i','c','r','o','s','o','f','t','\\',
93 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
94 'P','r','o','v','i','d','e','r',' ','T','y','p','e',' ','X','X','X',0
99 keyname
= CRYPT_Alloc( ((user
? strlenW(USERSTR
) : strlenW(MACHINESTR
)) +1)*sizeof(WCHAR
));
102 user
? strcpyW(keyname
, USERSTR
) : strcpyW(keyname
, MACHINESTR
);
103 ptr
= keyname
+ strlenW(keyname
);
104 *(--ptr
) = (dwType
% 10) + '0';
105 *(--ptr
) = ((dwType
/ 10) % 10) + '0';
106 *(--ptr
) = (dwType
/ 100) + '0';
108 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
112 /* CRYPT_UnicodeTOANSI
113 * wstr - unicode string
114 * str - pointer to ANSI string
115 * strsize - size of buffer pointed to by str or -1 if we have to do the allocation
117 * returns TRUE if unsuccessfull, FALSE otherwise.
118 * if wstr is NULL, returns TRUE and sets str to NULL! Value of str should be checked after call
120 static inline BOOL
CRYPT_UnicodeToANSI(LPCWSTR wstr
, LPSTR
* str
, int strsize
)
129 count
= WideCharToMultiByte(CP_ACP
, 0, wstr
, -1, NULL
, 0, NULL
, NULL
);
131 *str
= CRYPT_Alloc(count
* sizeof(CHAR
));
133 count
= min( count
, strsize
);
136 WideCharToMultiByte(CP_ACP
, 0, wstr
, -1, *str
, count
, NULL
, NULL
);
139 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
143 /* CRYPT_ANSITOUnicode
145 * wstr - pointer to unicode string
146 * wstrsize - size of buffer pointed to by wstr or -1 if we have to do the allocation
148 static inline BOOL
CRYPT_ANSIToUnicode(LPCSTR str
, LPWSTR
* wstr
, int wstrsize
)
157 wcount
= MultiByteToWideChar(CP_ACP
, 0, str
, -1, NULL
, 0);
159 *wstr
= CRYPT_Alloc(wcount
* sizeof(WCHAR
));
161 wcount
= min( wcount
, wstrsize
/sizeof(WCHAR
) );
164 MultiByteToWideChar(CP_ACP
, 0, str
, -1, *wstr
, wcount
);
167 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
171 /* These next 2 functions are used by the VTableProvStruc structure */
172 static BOOL CALLBACK
CRYPT_VerifyImage(LPCSTR lpszImage
, BYTE
* pData
)
174 if (!lpszImage
|| !pData
)
176 SetLastError(ERROR_INVALID_PARAMETER
);
180 FIXME("(%s, %p): not verifying image\n", lpszImage
, pData
);
185 static BOOL CALLBACK
CRYPT_ReturnhWnd(HWND
*phWnd
)
189 *phWnd
= crypt_hWindow
;
193 #define CRYPT_GetProvFunc(name) \
194 if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error
195 #define CRYPT_GetProvFuncOpt(name) \
196 provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)
197 static PCRYPTPROV
CRYPT_LoadProvider(PWSTR pImage
)
200 DWORD errorcode
= ERROR_NOT_ENOUGH_MEMORY
;
202 if ( !(provider
= CRYPT_Alloc(sizeof(CRYPTPROV
))) ) goto error
;
203 if ( !(provider
->pFuncs
= CRYPT_Alloc(sizeof(PROVFUNCS
))) ) goto error
;
204 if ( !(provider
->pVTable
= CRYPT_Alloc(sizeof(VTableProvStruc
))) ) goto error
;
205 if ( !(provider
->hModule
= LoadLibraryW(pImage
)) )
207 errorcode
= (GetLastError() == ERROR_FILE_NOT_FOUND
) ? NTE_PROV_DLL_NOT_FOUND
: NTE_PROVIDER_DLL_FAIL
;
208 FIXME("Failed to load dll %s\n", debugstr_w(pImage
));
211 provider
->dwMagic
= MAGIC_CRYPTPROV
;
212 provider
->refcount
= 1;
214 errorcode
= NTE_PROVIDER_DLL_FAIL
;
215 CRYPT_GetProvFunc(CPAcquireContext
);
216 CRYPT_GetProvFunc(CPCreateHash
);
217 CRYPT_GetProvFunc(CPDecrypt
);
218 CRYPT_GetProvFunc(CPDeriveKey
);
219 CRYPT_GetProvFunc(CPDestroyHash
);
220 CRYPT_GetProvFunc(CPDestroyKey
);
221 CRYPT_GetProvFuncOpt(CPDuplicateHash
);
222 CRYPT_GetProvFuncOpt(CPDuplicateKey
);
223 CRYPT_GetProvFunc(CPEncrypt
);
224 CRYPT_GetProvFunc(CPExportKey
);
225 CRYPT_GetProvFunc(CPGenKey
);
226 CRYPT_GetProvFunc(CPGenRandom
);
227 CRYPT_GetProvFunc(CPGetHashParam
);
228 CRYPT_GetProvFunc(CPGetKeyParam
);
229 CRYPT_GetProvFunc(CPGetProvParam
);
230 CRYPT_GetProvFunc(CPGetUserKey
);
231 CRYPT_GetProvFunc(CPHashData
);
232 CRYPT_GetProvFunc(CPHashSessionKey
);
233 CRYPT_GetProvFunc(CPImportKey
);
234 CRYPT_GetProvFunc(CPReleaseContext
);
235 CRYPT_GetProvFunc(CPSetHashParam
);
236 CRYPT_GetProvFunc(CPSetKeyParam
);
237 CRYPT_GetProvFunc(CPSetProvParam
);
238 CRYPT_GetProvFunc(CPSignHash
);
239 CRYPT_GetProvFunc(CPVerifySignature
);
241 /* FIXME: Not sure what the pbContextInfo field is for.
242 * Does it need memory allocation?
244 provider
->pVTable
->Version
= 3;
245 provider
->pVTable
->pFuncVerifyImage
= (FARPROC
)CRYPT_VerifyImage
;
246 provider
->pVTable
->pFuncReturnhWnd
= (FARPROC
)CRYPT_ReturnhWnd
;
247 provider
->pVTable
->dwProvType
= 0;
248 provider
->pVTable
->pbContextInfo
= NULL
;
249 provider
->pVTable
->cbContextInfo
= 0;
250 provider
->pVTable
->pszProvName
= NULL
;
254 SetLastError(errorcode
);
257 provider
->dwMagic
= 0;
258 if (provider
->hModule
)
259 FreeLibrary(provider
->hModule
);
260 CRYPT_Free(provider
->pVTable
);
261 CRYPT_Free(provider
->pFuncs
);
262 CRYPT_Free(provider
);
266 #undef CRYPT_GetProvFunc
267 #undef CRYPT_GetProvFuncOpt
270 /******************************************************************************
271 * CryptAcquireContextW (ADVAPI32.@)
273 * Acquire a crypto provider context handle.
276 * phProv [O] Pointer to HCRYPTPROV for the output.
277 * pszContainer [I] Key Container Name
278 * pszProvider [I] Cryptographic Service Provider Name
279 * dwProvType [I] Crypto provider type to get a handle.
280 * dwFlags [I] flags for the operation
283 * TRUE on success, FALSE on failure.
285 BOOL WINAPI
CryptAcquireContextW (HCRYPTPROV
*phProv
, LPCWSTR pszContainer
,
286 LPCWSTR pszProvider
, DWORD dwProvType
, DWORD dwFlags
)
288 PCRYPTPROV pProv
= NULL
;
290 PWSTR imagepath
= NULL
, keyname
= NULL
, provname
= NULL
, temp
= NULL
;
291 PSTR provnameA
= NULL
, pszContainerA
= NULL
;
292 DWORD keytype
, type
, len
;
294 static const WCHAR nameW
[] = {'N','a','m','e',0};
295 static const WCHAR typeW
[] = {'T','y','p','e',0};
296 static const WCHAR imagepathW
[] = {'I','m','a','g','e',' ','P','a','t','h',0};
298 TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv
, debugstr_w(pszContainer
),
299 debugstr_w(pszProvider
), dwProvType
, dwFlags
);
301 if (dwProvType
< 1 || dwProvType
> MAXPROVTYPES
)
303 SetLastError(NTE_BAD_PROV_TYPE
);
309 SetLastError(ERROR_INVALID_PARAMETER
);
313 if (!pszProvider
|| !*pszProvider
)
315 /* No CSP name specified so try the user default CSP first
316 * then try the machine default CSP
318 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, TRUE
)) ) {
319 TRACE("No provider registered for crypto provider type %ld.\n", dwProvType
);
320 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
323 if (RegOpenKeyW(HKEY_CURRENT_USER
, keyname
, &key
))
326 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, FALSE
)) ) {
327 TRACE("No type registered for crypto provider type %ld.\n", dwProvType
);
329 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
332 if (RegOpenKeyW(HKEY_LOCAL_MACHINE
, keyname
, &key
)) {
333 TRACE("Did not find registry entry of crypto provider for %s.\n", debugstr_w(keyname
));
336 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
341 r
= RegQueryValueExW(key
, nameW
, NULL
, &keytype
, NULL
, &len
);
342 if( r
!= ERROR_SUCCESS
|| !len
|| keytype
!= REG_SZ
)
344 TRACE("error %ld reading size of 'Name' from registry\n", r
);
346 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
349 if(!(provname
= CRYPT_Alloc(len
)))
352 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
355 r
= RegQueryValueExW(key
, nameW
, NULL
, NULL
, (LPBYTE
)provname
, &len
);
356 if( r
!= ERROR_SUCCESS
)
358 TRACE("error %ld reading 'Name' from registry\n", r
);
360 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
365 if ( !(provname
= CRYPT_Alloc((strlenW(pszProvider
) +1)*sizeof(WCHAR
))) )
367 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
370 strcpyW(provname
, pszProvider
);
373 keyname
= CRYPT_GetProvKeyName(provname
);
374 r
= RegOpenKeyW(HKEY_LOCAL_MACHINE
, keyname
, &key
);
376 if (r
!= ERROR_SUCCESS
)
378 SetLastError(NTE_KEYSET_NOT_DEF
);
382 r
= RegQueryValueExW(key
, typeW
, NULL
, NULL
, (BYTE
*)&type
, &len
);
383 if (r
!= ERROR_SUCCESS
)
385 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
388 if (type
!= dwProvType
)
390 TRACE("Crypto provider has wrong type (%ld vs expected %ld).\n", type
, dwProvType
);
391 SetLastError(NTE_PROV_TYPE_NO_MATCH
);
395 r
= RegQueryValueExW(key
, imagepathW
, NULL
, &keytype
, NULL
, &len
);
396 if ( r
!= ERROR_SUCCESS
|| keytype
!= REG_SZ
)
398 TRACE("error %ld reading size of 'Image Path' from registry\n", r
);
400 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
403 if (!(temp
= CRYPT_Alloc(len
)))
406 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
409 r
= RegQueryValueExW(key
, imagepathW
, NULL
, NULL
, (LPBYTE
)temp
, &len
);
410 if( r
!= ERROR_SUCCESS
)
412 TRACE("error %ld reading 'Image Path' from registry\n", r
);
414 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
418 len
= ExpandEnvironmentStringsW(temp
, NULL
, 0);
419 if ( !(imagepath
= CRYPT_Alloc(len
*sizeof(WCHAR
))) )
421 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
424 if (!ExpandEnvironmentStringsW(temp
, imagepath
, len
))
426 /* ExpandEnvironmentStrings will call SetLastError */
429 pProv
= CRYPT_LoadProvider(imagepath
);
431 /* CRYPT_LoadProvider calls SetLastError */
434 pProv
->pVTable
->dwProvType
= dwProvType
;
435 if(!CRYPT_UnicodeToANSI(provname
, &provnameA
, -1))
437 /* CRYPT_UnicodeToANSI calls SetLastError */
440 pProv
->pVTable
->pszProvName
= provnameA
;
441 if(!CRYPT_UnicodeToANSI(pszContainer
, &pszContainerA
, -1))
443 /* CRYPT_UnicodeToANSI calls SetLastError */
446 if (pProv
->pFuncs
->pCPAcquireContext(&pProv
->hPrivate
, pszContainerA
, dwFlags
, pProv
->pVTable
))
448 /* MSDN: When this flag is set, the value returned in phProv is undefined,
449 * and thus, the CryptReleaseContext function need not be called afterwards.
450 * Therefore, we must clean up everything now.
452 if (dwFlags
& CRYPT_DELETEKEYSET
)
455 FreeLibrary(pProv
->hModule
);
456 CRYPT_Free(provnameA
);
457 CRYPT_Free(pProv
->pVTable
);
458 CRYPT_Free(pProv
->pFuncs
);
461 *phProv
= (HCRYPTPROV
)pProv
;
463 CRYPT_Free(pszContainerA
);
464 CRYPT_Free(provname
);
466 CRYPT_Free(imagepath
);
469 /* FALLTHROUGH TO ERROR IF FALSE - CSP internal error! */
475 FreeLibrary(pProv
->hModule
);
477 CRYPT_Free(pProv
->pVTable
);
479 CRYPT_Free(pProv
->pFuncs
);
483 CRYPT_Free(pszContainerA
);
485 CRYPT_Free(provnameA
);
487 CRYPT_Free(provname
);
491 CRYPT_Free(imagepath
);
495 /******************************************************************************
496 * CryptAcquireContextA (ADVAPI32.@)
498 * See CryptAcquireContextW.
500 BOOL WINAPI
CryptAcquireContextA (HCRYPTPROV
*phProv
, LPCSTR pszContainer
,
501 LPCSTR pszProvider
, DWORD dwProvType
, DWORD dwFlags
)
503 PWSTR pProvider
= NULL
, pContainer
= NULL
;
506 TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv
, pszContainer
,
507 pszProvider
, dwProvType
, dwFlags
);
509 if ( !CRYPT_ANSIToUnicode(pszContainer
, &pContainer
, -1) )
510 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
511 if ( !CRYPT_ANSIToUnicode(pszProvider
, &pProvider
, -1) )
513 CRYPT_Free(pContainer
);
514 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
517 ret
= CryptAcquireContextW(phProv
, pContainer
, pProvider
, dwProvType
, dwFlags
);
520 CRYPT_Free(pContainer
);
522 CRYPT_Free(pProvider
);
527 /******************************************************************************
528 * CryptContextAddRef (ADVAPI32.@)
530 * Increases reference count of a cryptographic service provider handle
534 * hProv [I] Handle to the CSP whose reference is being incremented.
535 * pdwReserved [IN] Reserved for future use and must be NULL.
536 * dwFlags [I] Reserved for future use and must be NULL.
542 BOOL WINAPI
CryptContextAddRef (HCRYPTPROV hProv
, DWORD
*pdwReserved
, DWORD dwFlags
)
544 PCRYPTPROV pProv
= (PCRYPTPROV
)hProv
;
546 TRACE("(0x%lx, %p, %08lx)\n", hProv
, pdwReserved
, dwFlags
);
550 SetLastError(NTE_BAD_UID
);
554 if (pProv
->dwMagic
!= MAGIC_CRYPTPROV
)
556 SetLastError(ERROR_INVALID_PARAMETER
);
564 /******************************************************************************
565 * CryptReleaseContext (ADVAPI32.@)
567 * Releases the handle of a CSP. Reference count is decreased.
570 * hProv [I] Handle of a CSP.
571 * dwFlags [I] Reserved for future use and must be NULL.
577 BOOL WINAPI
CryptReleaseContext (HCRYPTPROV hProv
, DWORD dwFlags
)
579 PCRYPTPROV pProv
= (PCRYPTPROV
)hProv
;
582 TRACE("(0x%lx, %08lx)\n", hProv
, dwFlags
);
586 SetLastError(NTE_BAD_UID
);
590 if (pProv
->dwMagic
!= MAGIC_CRYPTPROV
)
592 SetLastError(ERROR_INVALID_PARAMETER
);
597 if (pProv
->refcount
<= 0)
599 ret
= pProv
->pFuncs
->pCPReleaseContext(pProv
->hPrivate
, dwFlags
);
601 FreeLibrary(pProv
->hModule
);
603 CRYPT_Free(pProv
->pVTable
->pContextInfo
);
605 CRYPT_Free(pProv
->pVTable
->pszProvName
);
606 CRYPT_Free(pProv
->pVTable
);
607 CRYPT_Free(pProv
->pFuncs
);
613 /******************************************************************************
614 * CryptGenRandom (ADVAPI32.@)
616 * Fills a buffer with cryptographically random bytes.
619 * hProv [I] Handle of a CSP.
620 * dwLen [I] Number of bytes to generate.
621 * pbBuffer [I/O] Buffer to contain random bytes.
628 * pdBuffer must be at least dwLen bytes long.
630 BOOL WINAPI
CryptGenRandom (HCRYPTPROV hProv
, DWORD dwLen
, BYTE
*pbBuffer
)
632 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
634 TRACE("(0x%lx, %ld, %p)\n", hProv
, dwLen
, pbBuffer
);
637 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
639 if (prov
->dwMagic
!= MAGIC_CRYPTPROV
)
640 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
642 return prov
->pFuncs
->pCPGenRandom(prov
->hPrivate
, dwLen
, pbBuffer
);
645 /******************************************************************************
646 * CryptCreateHash (ADVAPI32.@)
648 * Initiates the hashing of a stream of data.
651 * hProv [I] Handle of a CSP.
652 * Algid [I] Identifies the hash algorithm to use.
653 * hKey [I] Key for the hash (if required).
654 * dwFlags [I] Reserved for future use and must be NULL.
655 * phHash [O] Address of the future handle to the new hash object.
662 * If the algorithm is a keyed hash, hKey is the key.
664 BOOL WINAPI
CryptCreateHash (HCRYPTPROV hProv
, ALG_ID Algid
, HCRYPTKEY hKey
,
665 DWORD dwFlags
, HCRYPTHASH
*phHash
)
667 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
668 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
671 TRACE("(0x%lx, 0x%x, 0x%lx, %08lx, %p)\n", hProv
, Algid
, hKey
, dwFlags
, phHash
);
674 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
675 if (!phHash
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
676 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
678 CRYPT_ReturnLastError(NTE_BAD_FLAGS
);
679 if ( !(hash
= CRYPT_Alloc(sizeof(CRYPTHASH
))) )
680 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
682 hash
->pProvider
= prov
;
684 if (prov
->pFuncs
->pCPCreateHash(prov
->hPrivate
, Algid
,
685 key
? key
->hPrivate
: 0, 0, &hash
->hPrivate
))
687 *phHash
= (HCRYPTHASH
)hash
;
697 /******************************************************************************
698 * CryptDecrypt (ADVAPI32.@)
700 * Decrypts data encrypted by CryptEncrypt.
703 * hKey [I] Handle to the decryption key.
704 * hHash [I] Handle to a hash object.
705 * Final [I] TRUE if this is the last section to be decrypted.
706 * dwFlags [I] Reserved for future use. Can be CRYPT_OAEP.
707 * pbData [I/O] Buffer that holds the encrypted data. Holds decrypted
709 * pdwDataLen [I/O] Length of pbData before and after the call.
715 BOOL WINAPI
CryptDecrypt (HCRYPTKEY hKey
, HCRYPTHASH hHash
, BOOL Final
,
716 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
)
719 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
720 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
722 TRACE("(0x%lx, 0x%lx, %d, %08lx, %p, %p)\n", hKey
, hHash
, Final
, dwFlags
, pbData
, pdwDataLen
);
724 if (!key
|| !pbData
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
725 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
727 prov
= key
->pProvider
;
728 return prov
->pFuncs
->pCPDecrypt(prov
->hPrivate
, key
->hPrivate
, hash
? hash
->hPrivate
: 0,
729 Final
, dwFlags
, pbData
, pdwDataLen
);
732 /******************************************************************************
733 * CryptDeriveKey (ADVAPI32.@)
735 * Generates session keys derived from a base data value.
738 * hProv [I] Handle to a CSP.
739 * Algid [I] Identifies the symmetric encryption algorithm to use.
740 * hBaseData [I] Handle to a hash object.
741 * dwFlags [I] Type of key to generate.
742 * phKey [I/O] Address of the newly generated key.
748 BOOL WINAPI
CryptDeriveKey (HCRYPTPROV hProv
, ALG_ID Algid
, HCRYPTHASH hBaseData
,
749 DWORD dwFlags
, HCRYPTKEY
*phKey
)
751 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
752 PCRYPTHASH hash
= (PCRYPTHASH
)hBaseData
;
755 TRACE("(0x%lx, 0x%08x, 0x%lx, 0x%08lx, %p)\n", hProv
, Algid
, hBaseData
, dwFlags
, phKey
);
758 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
759 if (!phKey
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
760 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
761 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
762 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
764 key
->pProvider
= prov
;
765 if (prov
->pFuncs
->pCPDeriveKey(prov
->hPrivate
, Algid
, hash
->hPrivate
, dwFlags
, &key
->hPrivate
))
767 *phKey
= (HCRYPTKEY
)key
;
777 /******************************************************************************
778 * CryptDestroyHash (ADVAPI32.@)
780 * Destroys the hash object referenced by hHash.
783 * hHash [I] Handle of the hash object to be destroyed.
789 BOOL WINAPI
CryptDestroyHash (HCRYPTHASH hHash
)
791 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
795 TRACE("(0x%lx)\n", hHash
);
798 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
800 if (!hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
801 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
803 prov
= hash
->pProvider
;
804 ret
= prov
->pFuncs
->pCPDestroyHash(prov
->hPrivate
, hash
->hPrivate
);
809 /******************************************************************************
810 * CryptDestroyKey (ADVAPI32.@)
812 * Releases the handle referenced by hKey.
815 * hKey [I] Handle of the key to be destroyed.
821 BOOL WINAPI
CryptDestroyKey (HCRYPTKEY hKey
)
823 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
827 TRACE("(0x%lx)\n", hKey
);
830 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
832 if (!key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
833 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
835 prov
= key
->pProvider
;
836 ret
= prov
->pFuncs
->pCPDestroyKey(prov
->hPrivate
, key
->hPrivate
);
841 /******************************************************************************
842 * CryptDuplicateHash (ADVAPI32.@)
847 * hHash [I] Handle to the hash to be copied.
848 * pdwReserved [I] Reserved for future use and must be zero.
849 * dwFlags [I] Reserved for future use and must be zero.
850 * phHash [O] Address of the handle to receive the copy.
856 BOOL WINAPI
CryptDuplicateHash (HCRYPTHASH hHash
, DWORD
*pdwReserved
,
857 DWORD dwFlags
, HCRYPTHASH
*phHash
)
860 PCRYPTHASH orghash
, newhash
;
862 TRACE("(0x%lx, %p, %08lx, %p)\n", hHash
, pdwReserved
, dwFlags
, phHash
);
864 orghash
= (PCRYPTHASH
)hHash
;
865 if (!orghash
|| pdwReserved
|| !phHash
|| !orghash
->pProvider
||
866 orghash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
868 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
871 prov
= orghash
->pProvider
;
872 if (!prov
->pFuncs
->pCPDuplicateHash
)
873 CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED
);
875 if ( !(newhash
= CRYPT_Alloc(sizeof(CRYPTHASH
))) )
876 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
878 newhash
->pProvider
= prov
;
879 if (prov
->pFuncs
->pCPDuplicateHash(prov
->hPrivate
, orghash
->hPrivate
, pdwReserved
, dwFlags
, &newhash
->hPrivate
))
881 *phHash
= (HCRYPTHASH
)newhash
;
888 /******************************************************************************
889 * CryptDuplicateKey (ADVAPI32.@)
891 * Duplicate a key and the key's state.
894 * hKey [I] Handle of the key to copy.
895 * pdwReserved [I] Reserved for future use and must be NULL.
896 * dwFlags [I] Reserved for future use and must be zero.
897 * phKey [I] Address of the handle to the duplicated key.
903 BOOL WINAPI
CryptDuplicateKey (HCRYPTKEY hKey
, DWORD
*pdwReserved
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
906 PCRYPTKEY orgkey
, newkey
;
908 TRACE("(0x%lx, %p, %08lx, %p)\n", hKey
, pdwReserved
, dwFlags
, phKey
);
910 orgkey
= (PCRYPTKEY
)hKey
;
911 if (!orgkey
|| pdwReserved
|| !phKey
|| !orgkey
->pProvider
||
912 orgkey
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
914 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
917 prov
= orgkey
->pProvider
;
918 if (!prov
->pFuncs
->pCPDuplicateKey
)
919 CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED
);
921 if ( !(newkey
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
922 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
924 newkey
->pProvider
= prov
;
925 if (prov
->pFuncs
->pCPDuplicateKey(prov
->hPrivate
, orgkey
->hPrivate
, pdwReserved
, dwFlags
, &newkey
->hPrivate
))
927 *phKey
= (HCRYPTKEY
)newkey
;
934 /******************************************************************************
935 * CryptEncrypt (ADVAPI32.@)
940 * hKey [I] Handle to the enryption key.
941 * hHash [I] Handle to a hash object.
942 * Final [I] TRUE if this is the last section to encrypt.
943 * dwFlags [I] Can be CRYPT_OAEP.
944 * pbData [I/O] Data to be encrypted. Contains encrypted data after call.
945 * pdwDataLen [I/O] Length of the data to encrypt. Contains the length of the
946 * encrypted data after call.
947 * dwBufLen [I] Length of the input pbData buffer.
954 * If pbData is NULL, CryptEncrypt determines stores the number of bytes
955 * required for the returned data in pdwDataLen.
957 BOOL WINAPI
CryptEncrypt (HCRYPTKEY hKey
, HCRYPTHASH hHash
, BOOL Final
,
958 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
, DWORD dwBufLen
)
961 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
962 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
964 TRACE("(0x%lx, 0x%lx, %d, %08lx, %p, %p, %ld)\n", hKey
, hHash
, Final
, dwFlags
, pbData
, pdwDataLen
, dwBufLen
);
966 if (!key
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
967 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
969 prov
= key
->pProvider
;
970 return prov
->pFuncs
->pCPEncrypt(prov
->hPrivate
, key
->hPrivate
, hash
? hash
->hPrivate
: 0,
971 Final
, dwFlags
, pbData
, pdwDataLen
, dwBufLen
);
974 /******************************************************************************
975 * CryptEnumProvidersW (ADVAPI32.@)
977 * Returns the next availabe CSP.
980 * dwIndex [I] Index of the next provider to be enumerated.
981 * pdwReserved [I] Reserved for future use and must be NULL.
982 * dwFlags [I] Reserved for future use and must be zero.
983 * pdwProvType [O] DWORD designating the type of the provider.
984 * pszProvName [O] Buffer that receives data from the provider.
985 * pcbProvName [I/O] Specifies the size of pszProvName. Contains the number
986 * of bytes stored in the buffer on return.
993 * If pszProvName is NULL, CryptEnumProvidersW sets the size of the name
994 * for memory allocation purposes.
996 BOOL WINAPI
CryptEnumProvidersW (DWORD dwIndex
, DWORD
*pdwReserved
,
997 DWORD dwFlags
, DWORD
*pdwProvType
, LPWSTR pszProvName
, DWORD
*pcbProvName
)
1000 static const WCHAR providerW
[] = {
1001 'S','o','f','t','w','a','r','e','\\',
1002 'M','i','c','r','o','s','o','f','t','\\',
1003 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
1004 'D','e','f','a','u','l','t','s','\\',
1005 'P','r','o','v','i','d','e','r',0
1007 static const WCHAR typeW
[] = {'T','y','p','e',0};
1009 TRACE("(%ld, %p, %ld, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
1010 pdwProvType
, pszProvName
, pcbProvName
);
1012 if (pdwReserved
|| !pcbProvName
) CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1013 if (dwFlags
) CRYPT_ReturnLastError(NTE_BAD_FLAGS
);
1015 if (RegOpenKeyW(HKEY_LOCAL_MACHINE
, providerW
, &hKey
))
1016 CRYPT_ReturnLastError(NTE_FAIL
);
1023 RegQueryInfoKeyW(hKey
, NULL
, NULL
, NULL
, &numkeys
, pcbProvName
,
1024 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
1026 if (!(provNameW
= CRYPT_Alloc(*pcbProvName
* sizeof(WCHAR
))))
1027 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1029 RegEnumKeyExW(hKey
, dwIndex
, provNameW
, pcbProvName
, NULL
, NULL
, NULL
, NULL
);
1030 CRYPT_Free(provNameW
);
1032 *pcbProvName
*= sizeof(WCHAR
);
1034 if (dwIndex
>= numkeys
)
1035 CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS
);
1037 DWORD size
= sizeof(DWORD
);
1041 result
= RegEnumKeyW(hKey
, dwIndex
, pszProvName
, *pcbProvName
/ sizeof(WCHAR
));
1043 CRYPT_ReturnLastError(result
);
1044 if (RegOpenKeyW(hKey
, pszProvName
, &subkey
))
1046 if (RegQueryValueExW(subkey
, typeW
, NULL
, NULL
, (BYTE
*)pdwProvType
, &size
))
1048 RegCloseKey(subkey
);
1054 /******************************************************************************
1055 * CryptEnumProvidersA (ADVAPI32.@)
1057 * See CryptEnumProvidersW.
1059 BOOL WINAPI
CryptEnumProvidersA (DWORD dwIndex
, DWORD
*pdwReserved
,
1060 DWORD dwFlags
, DWORD
*pdwProvType
, LPSTR pszProvName
, DWORD
*pcbProvName
)
1064 BOOL ret
; /* = FALSE; */
1066 TRACE("(%ld, %p, %08lx, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
1067 pdwProvType
, pszProvName
, pcbProvName
);
1069 CryptEnumProvidersW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, NULL
, &strlen
);
1070 if ( pszProvName
&& !(str
= CRYPT_Alloc(strlen
)) )
1071 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1072 ret
= CryptEnumProvidersW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, str
, &strlen
);
1074 CRYPT_UnicodeToANSI(str
, &pszProvName
, *pcbProvName
);
1075 *pcbProvName
= strlen
/ sizeof(WCHAR
); /* FIXME: not correct */
1079 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1080 CRYPT_ReturnLastError(ERROR_MORE_DATA
);
1085 /******************************************************************************
1086 * CryptEnumProviderTypesW (ADVAPI32.@)
1088 * Retrieves the next type of CSP supported.
1091 * dwIndex [I] Index of the next provider to be enumerated.
1092 * pdwReserved [I] Reserved for future use and must be NULL.
1093 * dwFlags [I] Reserved for future use and must be zero.
1094 * pdwProvType [O] DWORD designating the type of the provider.
1095 * pszTypeName [O] Buffer that receives data from the provider type.
1096 * pcbTypeName [I/O] Specifies the size of pszTypeName. Contains the number
1097 * of bytes stored in the buffer on return.
1104 * If pszTypeName is NULL, CryptEnumProviderTypesW sets the size of the name
1105 * for memory allocation purposes.
1107 BOOL WINAPI
CryptEnumProviderTypesW (DWORD dwIndex
, DWORD
*pdwReserved
,
1108 DWORD dwFlags
, DWORD
*pdwProvType
, LPWSTR pszTypeName
, DWORD
*pcbTypeName
)
1111 DWORD keylen
, numkeys
, dwType
;
1114 static const WCHAR KEYSTR
[] = {
1115 'S','o','f','t','w','a','r','e','\\',
1116 'M','i','c','r','o','s','o','f','t','\\',
1117 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
1118 'D','e','f','a','u','l','t','s','\\',
1119 'P','r','o','v','i','d','e','r',' ','T','y','p','e','s',0
1121 static const WCHAR typenameW
[] = {'T','y','p','e','N','a','m','e',0};
1123 TRACE("(%ld, %p, %08lx, %p, %p, %p)\n", dwIndex
, pdwReserved
,
1124 dwFlags
, pdwProvType
, pszTypeName
, pcbTypeName
);
1126 if (pdwReserved
|| !pdwProvType
|| !pcbTypeName
)
1127 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1128 if (dwFlags
) CRYPT_ReturnLastError(NTE_BAD_FLAGS
);
1130 if (RegOpenKeyW(HKEY_LOCAL_MACHINE
, KEYSTR
, &hKey
))
1133 RegQueryInfoKeyW(hKey
, NULL
, NULL
, NULL
, &numkeys
, &keylen
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
1134 if (dwIndex
>= numkeys
)
1135 CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS
);
1137 if ( !(keyname
= CRYPT_Alloc(keylen
*sizeof(WCHAR
))) )
1138 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1139 if ( RegEnumKeyW(hKey
, dwIndex
, keyname
, keylen
) ) {
1140 CRYPT_Free(keyname
);
1143 RegOpenKeyW(hKey
, keyname
, &hSubkey
);
1144 ch
= keyname
+ strlenW(keyname
);
1145 /* Convert "Type 000" to 0, etc/ */
1146 *pdwProvType
= *(--ch
) - '0';
1147 *pdwProvType
+= (*(--ch
) - '0') * 10;
1148 *pdwProvType
+= (*(--ch
) - '0') * 100;
1149 CRYPT_Free(keyname
);
1151 result
= RegQueryValueExW(hSubkey
, typenameW
, NULL
, &dwType
, (LPBYTE
)pszTypeName
, pcbTypeName
);
1153 CRYPT_ReturnLastError(result
);
1155 RegCloseKey(hSubkey
);
1160 /******************************************************************************
1161 * CryptEnumProviderTypesA (ADVAPI32.@)
1163 * See CryptEnumProviderTypesW.
1165 BOOL WINAPI
CryptEnumProviderTypesA (DWORD dwIndex
, DWORD
*pdwReserved
,
1166 DWORD dwFlags
, DWORD
*pdwProvType
, LPSTR pszTypeName
, DWORD
*pcbTypeName
)
1172 TRACE("(%ld, %p, %08lx, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
1173 pdwProvType
, pszTypeName
, pcbTypeName
);
1175 CryptEnumProviderTypesW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, NULL
, &strlen
);
1176 if ( pszTypeName
&& !(str
= CRYPT_Alloc(strlen
)) )
1177 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1178 ret
= CryptEnumProviderTypesW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, str
, &strlen
);
1180 CRYPT_UnicodeToANSI(str
, &pszTypeName
, *pcbTypeName
);
1181 *pcbTypeName
= strlen
/ sizeof(WCHAR
);
1185 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1186 CRYPT_ReturnLastError(ERROR_MORE_DATA
);
1191 /******************************************************************************
1192 * CryptExportKey (ADVAPI32.@)
1194 * Exports a cryptographic key from a CSP.
1197 * hKey [I] Handle to the key to export.
1198 * hExpKey [I] Handle to a cryptographic key of the end user.
1199 * dwBlobType [I] Type of BLOB to be exported.
1200 * dwFlags [I] CRYPT_DESTROYKEY/SSL2_FALLBACK/OAEP.
1201 * pbData [O] Buffer to receive BLOB data.
1202 * pdwDataLen [I/O] Specifies the size of pbData.
1209 * if pbData is NULL, CryptExportKey sets pdwDataLen as the size of the
1210 * buffer needed to hold the BLOB.
1212 BOOL WINAPI
CryptExportKey (HCRYPTKEY hKey
, HCRYPTKEY hExpKey
, DWORD dwBlobType
,
1213 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
)
1216 PCRYPTKEY key
= (PCRYPTKEY
)hKey
, expkey
= (PCRYPTKEY
)hExpKey
;
1218 TRACE("(0x%lx, 0x%lx, %ld, %08lx, %p, %p)\n", hKey
, hExpKey
, dwBlobType
, dwFlags
, pbData
, pdwDataLen
);
1220 if (!key
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1221 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1223 prov
= key
->pProvider
;
1224 return prov
->pFuncs
->pCPExportKey(prov
->hPrivate
, key
->hPrivate
, expkey
? expkey
->hPrivate
: 0,
1225 dwBlobType
, dwFlags
, pbData
, pdwDataLen
);
1228 /******************************************************************************
1229 * CryptGenKey (ADVAPI32.@)
1231 * Generates a random cryptographic session key or a pub/priv key pair.
1234 * hProv [I] Handle to a CSP.
1235 * Algid [I] Algorithm to use to make key.
1236 * dwFlags [I] Specifies type of key to make.
1237 * phKey [I] Address of the handle to which the new key is copied.
1243 BOOL WINAPI
CryptGenKey (HCRYPTPROV hProv
, ALG_ID Algid
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
1245 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1248 TRACE("(0x%lx, %d, %08lx, %p)\n", hProv
, Algid
, dwFlags
, phKey
);
1251 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1252 if (!phKey
|| !prov
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1253 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1254 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1255 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1257 key
->pProvider
= prov
;
1259 if (prov
->pFuncs
->pCPGenKey(prov
->hPrivate
, Algid
, dwFlags
, &key
->hPrivate
))
1261 *phKey
= (HCRYPTKEY
)key
;
1270 /******************************************************************************
1271 * CryptGetDefaultProviderW (ADVAPI32.@)
1273 * Finds the default CSP of a certain provider type.
1276 * dwProvType [I] Provider type to look for.
1277 * pdwReserved [I] Reserved for future use and must be NULL.
1278 * dwFlags [I] CRYPT_MACHINE_DEFAULT/USER_DEFAULT
1279 * pszProvName [O] Name of the default CSP.
1280 * pcbProvName [I/O] Size of pszProvName
1287 * If pszProvName is NULL, pcbProvName will hold the size of the buffer for
1288 * memory allocation purposes on return.
1290 BOOL WINAPI
CryptGetDefaultProviderW (DWORD dwProvType
, DWORD
*pdwReserved
,
1291 DWORD dwFlags
, LPWSTR pszProvName
, DWORD
*pcbProvName
)
1296 static const WCHAR nameW
[] = {'N','a','m','e',0};
1298 if (pdwReserved
|| !pcbProvName
)
1299 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1300 if (dwFlags
& ~(CRYPT_USER_DEFAULT
| CRYPT_MACHINE_DEFAULT
))
1301 CRYPT_ReturnLastError(NTE_BAD_FLAGS
);
1302 if (dwProvType
> 999)
1303 CRYPT_ReturnLastError(NTE_BAD_PROV_TYPE
);
1304 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, dwFlags
& CRYPT_USER_DEFAULT
)) )
1305 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1306 if (RegOpenKeyW((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,keyname
, &hKey
))
1308 CRYPT_Free(keyname
);
1309 CRYPT_ReturnLastError(NTE_PROV_TYPE_NOT_DEF
);
1311 CRYPT_Free(keyname
);
1313 result
= RegQueryValueExW(hKey
, nameW
, NULL
, NULL
, (LPBYTE
)pszProvName
, pcbProvName
);
1316 if (result
!= ERROR_MORE_DATA
)
1317 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
1319 SetLastError(result
);
1328 /******************************************************************************
1329 * CryptGetDefaultProviderA (ADVAPI32.@)
1331 * See CryptGetDefaultProviderW.
1333 BOOL WINAPI
CryptGetDefaultProviderA (DWORD dwProvType
, DWORD
*pdwReserved
,
1334 DWORD dwFlags
, LPSTR pszProvName
, DWORD
*pcbProvName
)
1340 TRACE("(%ld, %p, %08lx, %p, %p)\n", dwProvType
, pdwReserved
, dwFlags
, pszProvName
, pcbProvName
);
1342 CryptGetDefaultProviderW(dwProvType
, pdwReserved
, dwFlags
, NULL
, &strlen
);
1343 if ( pszProvName
&& !(str
= CRYPT_Alloc(strlen
)) )
1344 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1345 ret
= CryptGetDefaultProviderW(dwProvType
, pdwReserved
, dwFlags
, str
, &strlen
);
1347 CRYPT_UnicodeToANSI(str
, &pszProvName
, *pcbProvName
);
1348 *pcbProvName
= strlen
/ sizeof(WCHAR
);
1352 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1353 CRYPT_ReturnLastError(ERROR_MORE_DATA
);
1358 /******************************************************************************
1359 * CryptGetHashParam (ADVAPI32.@)
1361 * Retrieves data that controls the operations of a hash object.
1364 * hHash [I] Handle of the hash object to question.
1365 * dwParam [I] Query type.
1366 * pbData [O] Buffer that receives the value data.
1367 * pdwDataLen [I/O] Size of the pbData buffer.
1368 * dwFlags [I] Reserved for future use and must be zero.
1375 * If pbData is NULL, pdwDataLen will contain the length required.
1377 BOOL WINAPI
CryptGetHashParam (HCRYPTHASH hHash
, DWORD dwParam
, BYTE
*pbData
,
1378 DWORD
*pdwDataLen
, DWORD dwFlags
)
1381 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1383 TRACE("(0x%lx, %ld, %p, %p, %08lx)\n", hHash
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1385 if (!hash
|| !pdwDataLen
|| !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1386 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1388 prov
= hash
->pProvider
;
1389 return prov
->pFuncs
->pCPGetHashParam(prov
->hPrivate
, hash
->hPrivate
, dwParam
,
1390 pbData
, pdwDataLen
, dwFlags
);
1393 /******************************************************************************
1394 * CryptGetKeyParam (ADVAPI32.@)
1396 * Retrieves data that controls the operations of a key.
1399 * hKey [I] Handle to they key in question.
1400 * dwParam [I] Specifies query type.
1401 * pbData [O] Sequence of bytes to receive data.
1402 * pdwDataLen [I/O] Size of pbData.
1403 * dwFlags [I] Reserved for future use and must be zero.
1410 * If pbData is NULL, pdwDataLen is set to the needed length of the buffer.
1412 BOOL WINAPI
CryptGetKeyParam (HCRYPTKEY hKey
, DWORD dwParam
, BYTE
*pbData
,
1413 DWORD
*pdwDataLen
, DWORD dwFlags
)
1416 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1418 TRACE("(0x%lx, %ld, %p, %p, %08lx)\n", hKey
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1420 if (!key
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1421 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1423 prov
= key
->pProvider
;
1424 return prov
->pFuncs
->pCPGetKeyParam(prov
->hPrivate
, key
->hPrivate
, dwParam
,
1425 pbData
, pdwDataLen
, dwFlags
);
1428 /******************************************************************************
1429 * CryptGetProvParam (ADVAPI32.@)
1431 * Retrieves parameters that control the operations of a CSP.
1434 * hProv [I] Handle of the CSP in question.
1435 * dwParam [I] Specifies query type.
1436 * pbData [O] Buffer to receive the data.
1437 * pdwDataLen [I/O] Size of pbData.
1438 * dwFlags [I] see MSDN Docs.
1445 * If pbData is NULL, pdwDataLen is set to the needed buffer length.
1447 BOOL WINAPI
CryptGetProvParam (HCRYPTPROV hProv
, DWORD dwParam
, BYTE
*pbData
,
1448 DWORD
*pdwDataLen
, DWORD dwFlags
)
1450 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1452 TRACE("(0x%lx, %ld, %p, %p, %08lx)\n", hProv
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1454 if (!prov
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1455 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1457 return prov
->pFuncs
->pCPGetProvParam(prov
->hPrivate
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1460 /******************************************************************************
1461 * CryptGetUserKey (ADVAPI32.@)
1463 * Gets a handle of one of a user's two public/private key pairs.
1466 * hProv [I] Handle of a CSP.
1467 * dwKeySpec [I] Private key to use.
1468 * phUserKey [O] Pointer to the handle of the retrieved keys.
1474 BOOL WINAPI
CryptGetUserKey (HCRYPTPROV hProv
, DWORD dwKeySpec
, HCRYPTKEY
*phUserKey
)
1476 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1479 TRACE("(0x%lx, %ld, %p)\n", hProv
, dwKeySpec
, phUserKey
);
1482 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1483 if (!phUserKey
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1484 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1485 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1486 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1488 key
->pProvider
= prov
;
1490 if (prov
->pFuncs
->pCPGetUserKey(prov
->hPrivate
, dwKeySpec
, &key
->hPrivate
))
1492 *phUserKey
= (HCRYPTKEY
)key
;
1502 /******************************************************************************
1503 * CryptHashData (ADVAPI32.@)
1505 * Adds data to a hash object.
1508 * hHash [I] Handle of the hash object.
1509 * pbData [I] Buffer of data to be hashed.
1510 * dwDataLen [I] Number of bytes to add.
1511 * dwFlags [I] Can be CRYPT_USERDATA
1517 BOOL WINAPI
CryptHashData (HCRYPTHASH hHash
, const BYTE
*pbData
, DWORD dwDataLen
, DWORD dwFlags
)
1519 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1522 TRACE("(0x%lx, %p, %ld, %08lx)\n", hHash
, pbData
, dwDataLen
, dwFlags
);
1525 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1526 if (!hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1527 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1529 prov
= hash
->pProvider
;
1530 return prov
->pFuncs
->pCPHashData(prov
->hPrivate
, hash
->hPrivate
, pbData
, dwDataLen
, dwFlags
);
1533 /******************************************************************************
1534 * CryptHashSessionKey (ADVAPI32.@)
1537 * hHash [I] Handle to the hash object.
1538 * hKey [I] Handle to the key to be hashed.
1539 * dwFlags [I] Can be CRYPT_LITTLE_ENDIAN.
1545 BOOL WINAPI
CryptHashSessionKey (HCRYPTHASH hHash
, HCRYPTKEY hKey
, DWORD dwFlags
)
1547 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1548 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1551 TRACE("(0x%lx, 0x%lx, %08lx)\n", hHash
, hKey
, dwFlags
);
1554 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1556 if (!hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1557 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1559 prov
= hash
->pProvider
;
1560 return prov
->pFuncs
->pCPHashSessionKey(prov
->hPrivate
, hash
->hPrivate
, key
->hPrivate
, dwFlags
);
1563 /******************************************************************************
1564 * CryptImportKey (ADVAPI32.@)
1567 * hProv [I] Handle of a CSP.
1568 * pbData [I] Contains the key to be imported.
1569 * dwDataLen [I] Length of the key.
1570 * hPubKey [I] Cryptographic key that decrypts pdData
1571 * dwFlags [I] Used only with a public/private key pair.
1572 * phKey [O] Imported key.
1578 BOOL WINAPI
CryptImportKey (HCRYPTPROV hProv
, BYTE
*pbData
, DWORD dwDataLen
,
1579 HCRYPTKEY hPubKey
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
1581 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1582 PCRYPTKEY pubkey
= (PCRYPTKEY
)hPubKey
, importkey
;
1584 TRACE("(0x%lx, %p, %ld, 0x%lx, %08lx, %p)\n", hProv
, pbData
, dwDataLen
, hPubKey
, dwFlags
, phKey
);
1586 if (!prov
|| !pbData
|| !dwDataLen
|| !phKey
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1587 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1589 if ( !(importkey
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1590 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1592 importkey
->pProvider
= prov
;
1593 if (prov
->pFuncs
->pCPImportKey(prov
->hPrivate
, pbData
, dwDataLen
,
1594 pubkey
? pubkey
->hPrivate
: 0, dwFlags
, &importkey
->hPrivate
))
1596 *phKey
= (HCRYPTKEY
)importkey
;
1600 CRYPT_Free(importkey
);
1604 /******************************************************************************
1605 * CryptSignHashW (ADVAPI32.@)
1610 * hHash [I] Handle of the hash object to be signed.
1611 * dwKeySpec [I] Private key to use.
1612 * sDescription [I] Should be NULL.
1613 * dwFlags [I] CRYPT_NOHASHOID/X931_FORMAT.
1614 * pbSignature [O] Buffer of the signature data.
1615 * pdwSigLen [I/O] Size of the pbSignature buffer.
1622 * Because of security flaws sDescription should not be used and should thus be
1623 * NULL. It is supported only for compatibility with Microsoft's Cryptographic
1626 BOOL WINAPI
CryptSignHashW (HCRYPTHASH hHash
, DWORD dwKeySpec
, LPCWSTR sDescription
,
1627 DWORD dwFlags
, BYTE
*pbSignature
, DWORD
*pdwSigLen
)
1629 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1632 TRACE("(0x%lx, %ld, %s, %08lx, %p, %p)\n",
1633 hHash
, dwKeySpec
, debugstr_w(sDescription
), dwFlags
, pbSignature
, pdwSigLen
);
1636 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1637 if (!pdwSigLen
|| !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1638 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1640 prov
= hash
->pProvider
;
1641 return prov
->pFuncs
->pCPSignHash(prov
->hPrivate
, hash
->hPrivate
, dwKeySpec
, sDescription
,
1642 dwFlags
, pbSignature
, pdwSigLen
);
1645 /******************************************************************************
1646 * CryptSignHashA (ADVAPI32.@)
1648 * See CryptSignHashW.
1650 BOOL WINAPI
CryptSignHashA (HCRYPTHASH hHash
, DWORD dwKeySpec
, LPCSTR sDescription
,
1651 DWORD dwFlags
, BYTE
*pbSignature
, DWORD
*pdwSigLen
)
1653 LPWSTR wsDescription
;
1656 TRACE("(0x%lx, %ld, %s, %08lx, %p, %p)\n",
1657 hHash
, dwKeySpec
, debugstr_a(sDescription
), dwFlags
, pbSignature
, pdwSigLen
);
1659 CRYPT_ANSIToUnicode(sDescription
, &wsDescription
, -1);
1660 result
= CryptSignHashW(hHash
, dwKeySpec
, wsDescription
, dwFlags
, pbSignature
, pdwSigLen
);
1661 if (wsDescription
) CRYPT_Free(wsDescription
);
1666 /******************************************************************************
1667 * CryptSetHashParam (ADVAPI32.@)
1669 * Customizes the operations of a hash object.
1672 * hHash [I] Handle of the hash object to set parameters.
1673 * dwParam [I] HP_HMAC_INFO/HASHVAL.
1674 * pbData [I] Value data buffer.
1675 * dwFlags [I] Reserved for future use and must be zero.
1681 BOOL WINAPI
CryptSetHashParam (HCRYPTHASH hHash
, DWORD dwParam
, BYTE
*pbData
, DWORD dwFlags
)
1684 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1686 TRACE("(0x%lx, %ld, %p, %08lx)\n", hHash
, dwParam
, pbData
, dwFlags
);
1688 if (!hash
|| !pbData
|| !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1689 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1691 prov
= hash
->pProvider
;
1692 return prov
->pFuncs
->pCPSetHashParam(prov
->hPrivate
, hash
->hPrivate
,
1693 dwParam
, pbData
, dwFlags
);
1696 /******************************************************************************
1697 * CryptSetKeyParam (ADVAPI32.@)
1699 * Customizes a session key's operations.
1702 * hKey [I] Handle to the key to set values.
1703 * dwParam [I] See MSDN Doc.
1704 * pbData [I] Buffer of values to set.
1705 * dwFlags [I] Only used when dwParam == KP_ALGID.
1711 BOOL WINAPI
CryptSetKeyParam (HCRYPTKEY hKey
, DWORD dwParam
, BYTE
*pbData
, DWORD dwFlags
)
1714 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1716 TRACE("(0x%lx, %ld, %p, %08lx)\n", hKey
, dwParam
, pbData
, dwFlags
);
1718 if (!key
|| !pbData
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1719 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1721 prov
= key
->pProvider
;
1722 return prov
->pFuncs
->pCPSetKeyParam(prov
->hPrivate
, key
->hPrivate
,
1723 dwParam
, pbData
, dwFlags
);
1726 /******************************************************************************
1727 * CryptSetProviderA (ADVAPI32.@)
1729 * Specifies the current user's default CSP.
1732 * pszProvName [I] Name of the new default CSP.
1733 * dwProvType [I] Provider type of the CSP.
1739 BOOL WINAPI
CryptSetProviderA (LPCSTR pszProvName
, DWORD dwProvType
)
1741 TRACE("(%s, %ld)\n", pszProvName
, dwProvType
);
1742 return CryptSetProviderExA(pszProvName
, dwProvType
, NULL
, CRYPT_USER_DEFAULT
);
1745 /******************************************************************************
1746 * CryptSetProviderW (ADVAPI32.@)
1748 * See CryptSetProviderA.
1750 BOOL WINAPI
CryptSetProviderW (LPCWSTR pszProvName
, DWORD dwProvType
)
1752 TRACE("(%s, %ld)\n", debugstr_w(pszProvName
), dwProvType
);
1753 return CryptSetProviderExW(pszProvName
, dwProvType
, NULL
, CRYPT_USER_DEFAULT
);
1756 /******************************************************************************
1757 * CryptSetProviderExW (ADVAPI32.@)
1759 * Specifies the default CSP.
1762 * pszProvName [I] Name of the new default CSP.
1763 * dwProvType [I] Provider type of the CSP.
1764 * pdwReserved [I] Reserved for future use and must be NULL.
1765 * dwFlags [I] See MSDN Doc.
1771 BOOL WINAPI
CryptSetProviderExW (LPCWSTR pszProvName
, DWORD dwProvType
, DWORD
*pdwReserved
, DWORD dwFlags
)
1773 HKEY hProvKey
, hTypeKey
;
1775 static const WCHAR nameW
[] = {'N','a','m','e',0};
1777 TRACE("(%s, %ld, %p, %08lx)\n", debugstr_w(pszProvName
), dwProvType
, pdwReserved
, dwFlags
);
1779 if (!pszProvName
|| pdwReserved
)
1780 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1781 if (dwProvType
> MAXPROVTYPES
)
1782 CRYPT_ReturnLastError(NTE_BAD_PROV_TYPE
);
1783 if (dwFlags
& ~(CRYPT_MACHINE_DEFAULT
| CRYPT_USER_DEFAULT
| CRYPT_DELETE_DEFAULT
)
1784 || dwFlags
== CRYPT_DELETE_DEFAULT
)
1785 CRYPT_ReturnLastError(NTE_BAD_FLAGS
);
1787 if (!(keyname
= CRYPT_GetTypeKeyName(dwProvType
, dwFlags
& CRYPT_USER_DEFAULT
)))
1788 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1789 if (RegOpenKeyW((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,
1790 keyname
, &hTypeKey
))
1792 CRYPT_Free(keyname
);
1793 CRYPT_ReturnLastError(NTE_BAD_PROVIDER
);
1795 CRYPT_Free(keyname
);
1797 if (dwFlags
& CRYPT_DELETE_DEFAULT
)
1799 RegDeleteValueW(hTypeKey
, nameW
);
1803 if (!(keyname
= CRYPT_GetProvKeyName(pszProvName
)))
1805 RegCloseKey(hTypeKey
);
1806 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1808 if (RegOpenKeyW((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,
1809 keyname
, &hProvKey
))
1811 CRYPT_Free(keyname
);
1812 RegCloseKey(hTypeKey
);
1813 CRYPT_ReturnLastError(NTE_BAD_PROVIDER
);
1815 CRYPT_Free(keyname
);
1817 if (RegSetValueExW(hTypeKey
, nameW
, 0, REG_SZ
, (LPBYTE
)pszProvName
, (strlenW(pszProvName
) + 1)*sizeof(WCHAR
)))
1819 RegCloseKey(hTypeKey
);
1820 RegCloseKey(hProvKey
);
1824 RegCloseKey(hProvKey
);
1826 RegCloseKey(hTypeKey
);
1831 /******************************************************************************
1832 * CryptSetProviderExA (ADVAPI32.@)
1834 * See CryptSetProviderExW.
1836 BOOL WINAPI
CryptSetProviderExA (LPCSTR pszProvName
, DWORD dwProvType
, DWORD
*pdwReserved
, DWORD dwFlags
)
1841 TRACE("(%s, %ld, %p, %08lx)\n", pszProvName
, dwProvType
, pdwReserved
, dwFlags
);
1843 if (CRYPT_ANSIToUnicode(pszProvName
, &str
, -1))
1845 ret
= CryptSetProviderExW(str
, dwProvType
, pdwReserved
, dwFlags
);
1851 /******************************************************************************
1852 * CryptSetProvParam (ADVAPI32.@)
1854 * Customizes the operations of a CSP.
1857 * hProv [I] Handle of a CSP.
1858 * dwParam [I] See MSDN Doc.
1859 * pbData [I] Buffer that contains a value to set as a parameter.
1860 * dwFlags [I] if dwParam is PP_USE_HARDWARE_RNG, dwFlags must be zero.
1866 BOOL WINAPI
CryptSetProvParam (HCRYPTPROV hProv
, DWORD dwParam
, BYTE
*pbData
, DWORD dwFlags
)
1868 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1870 TRACE("(0x%lx, %ld, %p, %08lx)\n", hProv
, dwParam
, pbData
, dwFlags
);
1873 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1874 if (prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1875 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1876 if (dwFlags
& PP_USE_HARDWARE_RNG
)
1878 FIXME("PP_USE_HARDWARE_RNG: What do I do with this?\n");
1879 FIXME("\tLetting the CSP decide.\n");
1881 if (dwFlags
& PP_CLIENT_HWND
)
1883 /* FIXME: Should verify the parameter */
1884 if (pbData
/* && IsWindow((HWND)pbData) */)
1886 crypt_hWindow
= (HWND
)(pbData
);
1889 SetLastError(ERROR_INVALID_PARAMETER
);
1893 /* All other flags go to the CSP */
1894 return prov
->pFuncs
->pCPSetProvParam(prov
->hPrivate
, dwParam
, pbData
, dwFlags
);
1897 /******************************************************************************
1898 * CryptVerifySignatureW (ADVAPI32.@)
1900 * Verifies the signature of a hash object.
1903 * hHash [I] Handle of the hash object to verify.
1904 * pbSignature [I] Signature data to verify.
1905 * dwSigLen [I] Size of pbSignature.
1906 * hPubKey [I] Handle to the public key to authenticate signature.
1907 * sDescription [I] Should be NULL.
1908 * dwFlags [I] See MSDN doc.
1915 * Because of security flaws sDescription should not be used and should thus be
1916 * NULL. It is supported only for compatibility with Microsoft's Cryptographic
1919 BOOL WINAPI
CryptVerifySignatureW (HCRYPTHASH hHash
, BYTE
*pbSignature
, DWORD dwSigLen
,
1920 HCRYPTKEY hPubKey
, LPCWSTR sDescription
, DWORD dwFlags
)
1922 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1923 PCRYPTKEY key
= (PCRYPTKEY
)hPubKey
;
1926 TRACE("(0x%lx, %p, %ld, 0x%lx, %s, %08lx)\n", hHash
, pbSignature
,
1927 dwSigLen
, hPubKey
, debugstr_w(sDescription
), dwFlags
);
1930 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1931 if (!pbSignature
|| !dwSigLen
||
1932 !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
||
1933 !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1935 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1938 prov
= hash
->pProvider
;
1939 return prov
->pFuncs
->pCPVerifySignature(prov
->hPrivate
, hash
->hPrivate
, pbSignature
, dwSigLen
,
1940 key
->hPrivate
, sDescription
, dwFlags
);
1943 /******************************************************************************
1944 * CryptVerifySignatureA (ADVAPI32.@)
1946 * See CryptVerifySignatureW.
1948 BOOL WINAPI
CryptVerifySignatureA (HCRYPTHASH hHash
, BYTE
*pbSignature
, DWORD dwSigLen
,
1949 HCRYPTKEY hPubKey
, LPCSTR sDescription
, DWORD dwFlags
)
1951 LPWSTR wsDescription
;
1954 TRACE("(0x%lx, %p, %ld, 0x%lx, %s, %08lx)\n", hHash
, pbSignature
,
1955 dwSigLen
, hPubKey
, debugstr_a(sDescription
), dwFlags
);
1957 CRYPT_ANSIToUnicode(sDescription
, &wsDescription
, -1);
1958 result
= CryptVerifySignatureW(hHash
, pbSignature
, dwSigLen
, hPubKey
, wsDescription
, dwFlags
);
1959 if (wsDescription
) CRYPT_Free(wsDescription
);
1964 /******************************************************************************
1965 * SystemFunction036 (ADVAPI32.@)
1967 * MSDN documents this function as RtlGenRandom and declares it in ntsecapi.h
1970 * pbBufer [O] Pointer to memory to receive random bytes.
1971 * dwLen [I] Number of random bytes to fetch.
1978 BOOL WINAPI
SystemFunction036(PVOID pbBuffer
, ULONG dwLen
)
1982 /* FIXME: /dev/urandom does not provide random numbers of a sufficient
1983 * quality for cryptographic applications. /dev/random is much better,
1984 * but it blocks if the kernel has not yet collected enough entropy for
1985 * the request, which will suspend the calling thread for an indefinite
1986 * amount of time. */
1987 dev_random
= open("/dev/urandom", O_RDONLY
);
1988 if (dev_random
!= -1)
1990 if (read(dev_random
, pbBuffer
, dwLen
) == (ssize_t
)dwLen
)
1997 SetLastError(NTE_FAIL
);
2002 These functions have nearly identical prototypes to CryptProtectMemory and CryptUnprotectMemory,
2006 /******************************************************************************
2007 * SystemFunction040 (ADVAPI32.@)
2009 * MSDN documents this function as RtlEncryptMemory.
2012 * memory [I/O] Pointer to memory to encrypt.
2013 * length [I] Length of region to encrypt in bytes.
2014 * flags [I] Control whether other processes are able to decrypt the memory.
2015 * RTL_ENCRYPT_OPTION_SAME_PROCESS
2016 * RTL_ENCRYPT_OPTION_CROSS_PROCESS
2017 * RTL_ENCRYPT_OPTION_SAME_LOGON
2020 * Success: STATUS_SUCCESS
2021 * Failure: NTSTATUS error code
2024 * length must be a multiple of RTL_ENCRYPT_MEMORY_SIZE.
2025 * If flags are specified when encrypting, the same flag value must be given
2026 * when decrypting the memory.
2028 NTSTATUS WINAPI
SystemFunction040(PVOID memory
, ULONG length
, ULONG flags
)
2030 FIXME("(%p, %lx, %lx): stub [RtlEncryptMemory]\n", memory
, length
, flags
);
2031 return STATUS_SUCCESS
;
2034 /******************************************************************************
2035 * SystemFunction041 (ADVAPI32.@)
2037 * MSDN documents this function as RtlDecryptMemory.
2040 * memory [I/O] Pointer to memory to decrypt.
2041 * length [I] Length of region to decrypt in bytes.
2042 * flags [I] Control whether other processes are able to decrypt the memory.
2043 * RTL_ENCRYPT_OPTION_SAME_PROCESS
2044 * RTL_ENCRYPT_OPTION_CROSS_PROCESS
2045 * RTL_ENCRYPT_OPTION_SAME_LOGON
2048 * Success: STATUS_SUCCESS
2049 * Failure: NTSTATUS error code
2052 * length must be a multiple of RTL_ENCRYPT_MEMORY_SIZE.
2053 * If flags are specified when encrypting, the same flag value must be given
2054 * when decrypting the memory.
2056 NTSTATUS WINAPI
SystemFunction041(PVOID memory
, ULONG length
, ULONG flags
)
2058 FIXME("(%p, %lx, %lx): stub [RtlDecryptMemory]\n", memory
, length
, flags
);
2059 return STATUS_SUCCESS
;