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"
49 WINE_DEFAULT_DEBUG_CHANNEL(crypt
);
51 HWND crypt_hWindow
= 0;
53 #define CRYPT_ReturnLastError(err) {SetLastError(err); return FALSE;}
55 #define CRYPT_Alloc(size) ((LPVOID)LocalAlloc(LMEM_ZEROINIT, size))
56 #define CRYPT_Free(buffer) (LocalFree((HLOCAL)buffer))
58 static inline PSTR
CRYPT_GetProvKeyName(PCSTR pProvName
)
60 PCSTR KEYSTR
= "Software\\Microsoft\\Cryptography\\Defaults\\Provider\\";
63 keyname
= CRYPT_Alloc(strlen(KEYSTR
) + strlen(pProvName
) +1);
66 strcpy(keyname
, KEYSTR
);
67 strcpy(keyname
+ strlen(KEYSTR
), pProvName
);
69 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
73 static inline PSTR
CRYPT_GetTypeKeyName(DWORD dwType
, BOOL user
)
75 PCSTR MACHINESTR
= "Software\\Microsoft\\Cryptography\\Defaults\\Provider Types\\Type XXX";
76 PCSTR USERSTR
= "Software\\Microsoft\\Cryptography\\Provider Type XXX";
80 keyname
= CRYPT_Alloc( (user
? strlen(USERSTR
) : strlen(MACHINESTR
)) +1);
83 user
? strcpy(keyname
, USERSTR
) : strcpy(keyname
, MACHINESTR
);
84 ptr
= keyname
+ strlen(keyname
);
85 *(--ptr
) = (dwType
% 10) + '0';
86 *(--ptr
) = ((dwType
/ 10) % 10) + '0';
87 *(--ptr
) = (dwType
/ 100) + '0';
89 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
93 /* CRYPT_UnicodeTOANSI
94 * wstr - unicode string
95 * str - pointer to ANSI string
96 * strsize - size of buffer pointed to by str or -1 if we have to do the allocation
98 * returns TRUE if unsuccessfull, FALSE otherwise.
99 * if wstr is NULL, returns TRUE and sets str to NULL! Value of str should be checked after call
101 static inline BOOL
CRYPT_UnicodeToANSI(LPCWSTR wstr
, LPSTR
* str
, int strsize
)
110 count
= WideCharToMultiByte(CP_ACP
, 0, wstr
, -1, NULL
, 0, NULL
, NULL
);
112 *str
= CRYPT_Alloc(count
* sizeof(CHAR
));
114 count
= min( count
, strsize
);
117 WideCharToMultiByte(CP_ACP
, 0, wstr
, -1, *str
, count
, 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 BOOL CALLBACK
CRYPT_ReturnhWnd(HWND
*phWnd
)
170 *phWnd
= crypt_hWindow
;
174 #define CRYPT_GetProvFunc(name) \
175 if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error
176 #define CRYPT_GetProvFuncOpt(name) \
177 provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)
178 static PCRYPTPROV
CRYPT_LoadProvider(PSTR pImage
)
181 DWORD errorcode
= ERROR_NOT_ENOUGH_MEMORY
;
183 if ( !(provider
= CRYPT_Alloc(sizeof(CRYPTPROV
))) ) goto error
;
184 if ( !(provider
->pFuncs
= CRYPT_Alloc(sizeof(PROVFUNCS
))) ) goto error
;
185 if ( !(provider
->pVTable
= CRYPT_Alloc(sizeof(VTableProvStruc
))) ) goto error
;
186 if ( !(provider
->hModule
= LoadLibraryA(pImage
)) )
188 errorcode
= (GetLastError() == ERROR_FILE_NOT_FOUND
) ? NTE_PROV_DLL_NOT_FOUND
: NTE_PROVIDER_DLL_FAIL
;
189 FIXME("Failed to load dll %s\n", debugstr_a(pImage
));
192 provider
->dwMagic
= MAGIC_CRYPTPROV
;
193 provider
->refcount
= 1;
195 errorcode
= NTE_PROVIDER_DLL_FAIL
;
196 CRYPT_GetProvFunc(CPAcquireContext
);
197 CRYPT_GetProvFunc(CPCreateHash
);
198 CRYPT_GetProvFunc(CPDecrypt
);
199 CRYPT_GetProvFunc(CPDeriveKey
);
200 CRYPT_GetProvFunc(CPDestroyHash
);
201 CRYPT_GetProvFunc(CPDestroyKey
);
202 CRYPT_GetProvFuncOpt(CPDuplicateHash
);
203 CRYPT_GetProvFuncOpt(CPDuplicateKey
);
204 CRYPT_GetProvFunc(CPEncrypt
);
205 CRYPT_GetProvFunc(CPExportKey
);
206 CRYPT_GetProvFunc(CPGenKey
);
207 CRYPT_GetProvFunc(CPGenRandom
);
208 CRYPT_GetProvFunc(CPGetHashParam
);
209 CRYPT_GetProvFunc(CPGetKeyParam
);
210 CRYPT_GetProvFunc(CPGetProvParam
);
211 CRYPT_GetProvFunc(CPGetUserKey
);
212 CRYPT_GetProvFunc(CPHashData
);
213 CRYPT_GetProvFunc(CPHashSessionKey
);
214 CRYPT_GetProvFunc(CPImportKey
);
215 CRYPT_GetProvFunc(CPReleaseContext
);
216 CRYPT_GetProvFunc(CPSetHashParam
);
217 CRYPT_GetProvFunc(CPSetKeyParam
);
218 CRYPT_GetProvFunc(CPSetProvParam
);
219 CRYPT_GetProvFunc(CPSignHash
);
220 CRYPT_GetProvFunc(CPVerifySignature
);
222 /* FIXME: Not sure what the pbContextInfo field is for.
223 * Does it need memory allocation?
225 provider
->pVTable
->Version
= 3;
226 provider
->pVTable
->pFuncVerifyImage
= (FARPROC
)CRYPT_VerifyImage
;
227 provider
->pVTable
->pFuncReturnhWnd
= (FARPROC
)CRYPT_ReturnhWnd
;
228 provider
->pVTable
->dwProvType
= 0;
229 provider
->pVTable
->pbContextInfo
= NULL
;
230 provider
->pVTable
->cbContextInfo
= 0;
231 provider
->pVTable
->pszProvName
= NULL
;
235 SetLastError(errorcode
);
238 provider
->dwMagic
= 0;
239 if (provider
->hModule
)
240 FreeLibrary(provider
->hModule
);
241 CRYPT_Free(provider
->pVTable
);
242 CRYPT_Free(provider
->pFuncs
);
243 CRYPT_Free(provider
);
247 #undef CRYPT_GetProvFunc
248 #undef CRYPT_GetProvFuncOpt
251 /******************************************************************************
252 * CryptAcquireContextA (ADVAPI32.@)
253 * Acquire a crypto provider context handle.
256 * phProv: Pointer to HCRYPTPROV for the output.
257 * pszContainer: Key Container Name
258 * pszProvider: Cryptographic Service Provider Name
259 * dwProvType: Crypto provider type to get a handle.
260 * dwFlags: flags for the operation
262 * RETURNS TRUE on success, FALSE on failure.
264 BOOL WINAPI
CryptAcquireContextA (HCRYPTPROV
*phProv
, LPCSTR pszContainer
,
265 LPCSTR pszProvider
, DWORD dwProvType
, DWORD dwFlags
)
267 PCRYPTPROV pProv
= NULL
;
269 PSTR imagepath
= NULL
, keyname
= NULL
, provname
= NULL
, temp
= NULL
;
270 DWORD keytype
, type
, len
;
273 TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv
, pszContainer
,
274 pszProvider
, dwProvType
, dwFlags
);
276 if (dwProvType
< 1 || dwProvType
> MAXPROVTYPES
)
278 SetLastError(NTE_BAD_PROV_TYPE
);
284 SetLastError(ERROR_INVALID_PARAMETER
);
288 if (!pszProvider
|| !*pszProvider
)
290 /* No CSP name specified so try the user default CSP first
291 * then try the machine default CSP
293 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, TRUE
)) ) {
294 TRACE("No provider registered for crypto provider type %ld.\n", dwProvType
);
295 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
298 if (RegOpenKeyA(HKEY_CURRENT_USER
, keyname
, &key
))
301 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, FALSE
)) ) {
302 TRACE("No type registered for crypto provider type %ld.\n", dwProvType
);
304 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
307 if (RegOpenKeyA(HKEY_LOCAL_MACHINE
, keyname
, &key
)) {
308 TRACE("Did not find registry entry of crypto provider for %s.\n", debugstr_a(keyname
));
311 SetLastError(NTE_PROV_TYPE_NOT_DEF
);
316 r
= RegQueryValueExA(key
, "Name", NULL
, &keytype
, NULL
, &len
);
317 if( r
!= ERROR_SUCCESS
|| !len
|| keytype
!= REG_SZ
)
319 TRACE("error %ld reading size of 'Name' from registry\n", r
);
321 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
324 if(!(provname
= CRYPT_Alloc(len
)))
327 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
330 r
= RegQueryValueExA(key
, "Name", NULL
, NULL
, (LPBYTE
)provname
, &len
);
331 if( r
!= ERROR_SUCCESS
)
333 TRACE("error %ld reading 'Name' from registry\n", r
);
335 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
340 if ( !(provname
= CRYPT_Alloc(strlen(pszProvider
) +1)) )
342 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
345 strcpy(provname
, pszProvider
);
348 keyname
= CRYPT_GetProvKeyName(provname
);
349 r
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, keyname
, &key
);
351 if (r
!= ERROR_SUCCESS
)
353 SetLastError(NTE_KEYSET_NOT_DEF
);
357 r
= RegQueryValueExA(key
, "Type", NULL
, NULL
, (BYTE
*)&type
, &len
);
358 if (r
!= ERROR_SUCCESS
)
360 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
363 if (type
!= dwProvType
)
365 TRACE("Crypto provider has wrong type (%ld vs expected %ld).\n", type
, dwProvType
);
366 SetLastError(NTE_PROV_TYPE_NO_MATCH
);
370 r
= RegQueryValueExA(key
, "Image Path", NULL
, &keytype
, NULL
, &len
);
371 if ( r
!= ERROR_SUCCESS
|| keytype
!= REG_SZ
)
373 TRACE("error %ld reading size of 'Image Path' from registry\n", r
);
375 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
378 if (!(temp
= CRYPT_Alloc(len
)))
381 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
384 r
= RegQueryValueExA(key
, "Image Path", NULL
, NULL
, (LPBYTE
)temp
, &len
);
385 if( r
!= ERROR_SUCCESS
)
387 TRACE("error %ld reading 'Image Path' from registry\n", r
);
389 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
393 len
= ExpandEnvironmentStringsA(temp
, NULL
, 0);
394 if ( !(imagepath
= CRYPT_Alloc(len
)) )
396 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
399 if (!ExpandEnvironmentStringsA(temp
, imagepath
, len
))
401 /* ExpandEnvironmentStrings will call SetLastError */
404 pProv
= CRYPT_LoadProvider(imagepath
);
406 /* CRYPT_LoadProvider calls SetLastError */
409 pProv
->pVTable
->dwProvType
= dwProvType
;
410 pProv
->pVTable
->pszProvName
= provname
;
411 if (pProv
->pFuncs
->pCPAcquireContext(&pProv
->hPrivate
, (CHAR
*)pszContainer
, dwFlags
, pProv
->pVTable
))
413 /* MSDN: When this flag is set, the value returned in phProv is undefined,
414 * and thus, the CryptReleaseContext function need not be called afterwards.
415 * Therefore, we must clean up everything now.
417 if (dwFlags
& CRYPT_DELETEKEYSET
)
420 FreeLibrary(pProv
->hModule
);
421 CRYPT_Free(provname
);
422 CRYPT_Free(pProv
->pFuncs
);
425 *phProv
= (HCRYPTPROV
)pProv
;
428 CRYPT_Free(imagepath
);
431 /* FALLTHROUGH TO ERROR IF FALSE - CSP internal error! */
437 FreeLibrary(pProv
->hModule
);
439 CRYPT_Free(pProv
->pVTable
);
441 CRYPT_Free(pProv
->pFuncs
);
445 CRYPT_Free(provname
);
449 CRYPT_Free(imagepath
);
453 /******************************************************************************
454 * CryptAcquireContextW (ADVAPI32.@)
456 * see CryptAcquireContextA
458 BOOL WINAPI
CryptAcquireContextW (HCRYPTPROV
*phProv
, LPCWSTR pszContainer
,
459 LPCWSTR pszProvider
, DWORD dwProvType
, DWORD dwFlags
)
461 PSTR pProvider
= NULL
, pContainer
= NULL
;
464 TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv
, debugstr_w(pszContainer
),
465 debugstr_w(pszProvider
), dwProvType
, dwFlags
);
467 if ( !CRYPT_UnicodeToANSI(pszContainer
, &pContainer
, -1) )
468 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
469 if ( !CRYPT_UnicodeToANSI(pszProvider
, &pProvider
, -1) )
471 CRYPT_Free(pContainer
);
472 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
475 ret
= CryptAcquireContextA(phProv
, pContainer
, pProvider
, dwProvType
, dwFlags
);
478 CRYPT_Free(pContainer
);
480 CRYPT_Free(pProvider
);
485 /******************************************************************************
486 * CryptContextAddRef (ADVAPI32.@)
488 * Increases reference count of a cryptographic service provider handle
492 * hProv [I] Handle to the CSP whose reference is being incremented.
493 * pdwReserved [IN] Reserved for future use and must be NULL.
494 * dwFlags [I] Reserved for future use and must be NULL.
500 BOOL WINAPI
CryptContextAddRef (HCRYPTPROV hProv
, DWORD
*pdwReserved
, DWORD dwFlags
)
502 PCRYPTPROV pProv
= (PCRYPTPROV
)hProv
;
504 TRACE("(0x%lx, %p, %08lx)\n", hProv
, pdwReserved
, dwFlags
);
508 SetLastError(NTE_BAD_UID
);
512 if (pProv
->dwMagic
!= MAGIC_CRYPTPROV
)
514 SetLastError(ERROR_INVALID_PARAMETER
);
522 /******************************************************************************
523 * CryptReleaseContext (ADVAPI32.@)
525 * Releases the handle of a CSP. Reference count is decreased.
528 * hProv [I] Handle of a CSP.
529 * dwFlags [I] Reserved for future use and must be NULL.
535 BOOL WINAPI
CryptReleaseContext (HCRYPTPROV hProv
, DWORD dwFlags
)
537 PCRYPTPROV pProv
= (PCRYPTPROV
)hProv
;
540 TRACE("(0x%lx, %08ld)\n", hProv
, dwFlags
);
544 SetLastError(NTE_BAD_UID
);
548 if (pProv
->dwMagic
!= MAGIC_CRYPTPROV
)
550 SetLastError(ERROR_INVALID_PARAMETER
);
555 if (pProv
->refcount
<= 0)
557 ret
= pProv
->pFuncs
->pCPReleaseContext(pProv
->hPrivate
, dwFlags
);
559 FreeLibrary(pProv
->hModule
);
561 CRYPT_Free(pProv
->pVTable
->pContextInfo
);
563 CRYPT_Free(pProv
->pVTable
->pszProvName
);
564 CRYPT_Free(pProv
->pVTable
);
565 CRYPT_Free(pProv
->pFuncs
);
571 /******************************************************************************
572 * CryptGenRandom (ADVAPI32.@)
574 * Fills a buffer with cryptographically random bytes.
577 * hProv [I] Handle of a CSP.
578 * dwLen [I] Number of bytes to generate.
579 * pbBuffer [I/O] Buffer to contain random bytes.
586 * pdBuffer must be at least dwLen bytes long.
588 BOOL WINAPI
CryptGenRandom (HCRYPTPROV hProv
, DWORD dwLen
, BYTE
*pbBuffer
)
590 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
592 TRACE("(0x%lx, %ld, %p)\n", hProv
, dwLen
, pbBuffer
);
595 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
597 if (prov
->dwMagic
!= MAGIC_CRYPTPROV
)
598 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
600 return prov
->pFuncs
->pCPGenRandom(prov
->hPrivate
, dwLen
, pbBuffer
);
603 /******************************************************************************
604 * CryptCreateHash (ADVAPI32.@)
606 * Initiates the hashing of a stream of data.
609 * hProv [I] Handle of a CSP.
610 * Algid [I] Identifies the hash algorithm to use.
611 * hKey [I] Key for the hash (if required).
612 * dwFlags [I] Reserved for future use and must be NULL.
613 * phHash [O] Address of the future handle to the new hash object.
620 * If the algorithm is a keyed hash, hKey is the key.
622 BOOL WINAPI
CryptCreateHash (HCRYPTPROV hProv
, ALG_ID Algid
, HCRYPTKEY hKey
,
623 DWORD dwFlags
, HCRYPTHASH
*phHash
)
625 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
626 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
629 TRACE("(0x%lx, 0x%x, 0x%lx, %08lx, %p)\n", hProv
, Algid
, hKey
, dwFlags
, phHash
);
632 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
633 if (!phHash
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
634 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
636 CRYPT_ReturnLastError(NTE_BAD_FLAGS
);
637 if ( !(hash
= CRYPT_Alloc(sizeof(CRYPTHASH
))) )
638 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
640 hash
->pProvider
= prov
;
642 if (prov
->pFuncs
->pCPCreateHash(prov
->hPrivate
, Algid
,
643 key
? key
->hPrivate
: 0, 0, &hash
->hPrivate
))
645 *phHash
= (HCRYPTHASH
)hash
;
655 /******************************************************************************
656 * CryptDecrypt (ADVAPI32.@)
658 * Decrypts data encrypted by CryptEncrypt.
661 * hKey [I] Handle to the decryption key.
662 * hHash [I] Handle to a hash object.
663 * Final [I] TRUE if this is the last section to be decrypted.
664 * dwFlags [I] Reserved for future use. Can be CRYPT_OAEP.
665 * pbData [I/O] Buffer that holds the encrypted data. Holds decrypted
667 * pdwDataLen [I/O] Length of pbData before and after the call.
673 BOOL WINAPI
CryptDecrypt (HCRYPTKEY hKey
, HCRYPTHASH hHash
, BOOL Final
,
674 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
)
677 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
678 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
680 TRACE("(0x%lx, 0x%lx, %d, %08lx, %p, %p)\n", hKey
, hHash
, Final
, dwFlags
, pbData
, pdwDataLen
);
682 if (!key
|| !pbData
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
683 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
685 prov
= key
->pProvider
;
686 return prov
->pFuncs
->pCPDecrypt(prov
->hPrivate
, key
->hPrivate
, hash
? hash
->hPrivate
: 0,
687 Final
, dwFlags
, pbData
, pdwDataLen
);
690 /******************************************************************************
691 * CryptDeriveKey (ADVAPI32.@)
693 * Generates session keys derived from a base data value.
696 * hProv [I] Handle to a CSP.
697 * Algid [I] Identifies the symmetric encryption algorithm to use.
698 * hBaseData [I] Handle to a hash object.
699 * dwFlags [I] Type of key to generate.
700 * phKey [I/O] Address of the newly generated key.
706 BOOL WINAPI
CryptDeriveKey (HCRYPTPROV hProv
, ALG_ID Algid
, HCRYPTHASH hBaseData
,
707 DWORD dwFlags
, HCRYPTKEY
*phKey
)
709 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
710 PCRYPTHASH hash
= (PCRYPTHASH
)hBaseData
;
713 TRACE("(0x%lx, 0x%08x, 0x%lx, 0x%08lx, %p)\n", hProv
, Algid
, hBaseData
, dwFlags
, phKey
);
716 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
717 if (!phKey
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
718 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
719 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
720 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
722 key
->pProvider
= prov
;
723 if (prov
->pFuncs
->pCPDeriveKey(prov
->hPrivate
, Algid
, hash
->hPrivate
, dwFlags
, &key
->hPrivate
))
725 *phKey
= (HCRYPTKEY
)key
;
735 /******************************************************************************
736 * CryptDestroyHash (ADVAPI32.@)
738 * Destroys the hash object referenced by hHash.
741 * hHash [I] Handle of the hash object to be destroyed.
747 BOOL WINAPI
CryptDestroyHash (HCRYPTHASH hHash
)
749 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
753 TRACE("(0x%lx)\n", hHash
);
756 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
758 if (!hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
759 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
761 prov
= hash
->pProvider
;
762 ret
= prov
->pFuncs
->pCPDestroyHash(prov
->hPrivate
, hash
->hPrivate
);
767 /******************************************************************************
768 * CryptDestroyKey (ADVAPI32.@)
770 * Releases the handle referenced by hKey.
773 * hKey [I] Handle of the key to be destroyed.
779 BOOL WINAPI
CryptDestroyKey (HCRYPTKEY hKey
)
781 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
785 TRACE("(0x%lx)\n", hKey
);
788 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
790 if (!key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
791 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
793 prov
= key
->pProvider
;
794 ret
= prov
->pFuncs
->pCPDestroyKey(prov
->hPrivate
, key
->hPrivate
);
799 /******************************************************************************
800 * CryptDuplicateHash (ADVAPI32.@)
805 * hHash [I] Handle to the hash to be copied.
806 * pdwReserved [I] Reserved for future use and must be zero.
807 * dwFlags [I] Reserved for future use and must be zero.
808 * phHash [O] Address of the handle to receive the copy.
814 BOOL WINAPI
CryptDuplicateHash (HCRYPTHASH hHash
, DWORD
*pdwReserved
,
815 DWORD dwFlags
, HCRYPTHASH
*phHash
)
818 PCRYPTHASH orghash
, newhash
;
820 TRACE("(0x%lx, %p, %08ld, %p)\n", hHash
, pdwReserved
, dwFlags
, phHash
);
822 orghash
= (PCRYPTHASH
)hHash
;
823 if (!orghash
|| pdwReserved
|| !phHash
|| !orghash
->pProvider
||
824 orghash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
826 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
829 prov
= orghash
->pProvider
;
830 if (!prov
->pFuncs
->pCPDuplicateHash
)
831 CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED
);
833 if ( !(newhash
= CRYPT_Alloc(sizeof(CRYPTHASH
))) )
834 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
836 newhash
->pProvider
= prov
;
837 if (prov
->pFuncs
->pCPDuplicateHash(prov
->hPrivate
, orghash
->hPrivate
, pdwReserved
, dwFlags
, &newhash
->hPrivate
))
839 *phHash
= (HCRYPTHASH
)newhash
;
846 /******************************************************************************
847 * CryptDuplicateKey (ADVAPI32.@)
849 * Duplicate a key and the key's state.
852 * hKey [I] Handle of the key to copy.
853 * pdwReserved [I] Reserved for future use and must be NULL.
854 * dwFlags [I] Reserved for future use and must be zero.
855 * phKey [I] Address of the handle to the duplicated key.
861 BOOL WINAPI
CryptDuplicateKey (HCRYPTKEY hKey
, DWORD
*pdwReserved
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
864 PCRYPTKEY orgkey
, newkey
;
866 TRACE("(0x%lx, %p, %08ld, %p)\n", hKey
, pdwReserved
, dwFlags
, phKey
);
868 orgkey
= (PCRYPTKEY
)hKey
;
869 if (!orgkey
|| pdwReserved
|| !phKey
|| !orgkey
->pProvider
||
870 orgkey
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
872 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
875 prov
= orgkey
->pProvider
;
876 if (!prov
->pFuncs
->pCPDuplicateKey
)
877 CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED
);
879 if ( !(newkey
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
880 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
882 newkey
->pProvider
= prov
;
883 if (prov
->pFuncs
->pCPDuplicateKey(prov
->hPrivate
, orgkey
->hPrivate
, pdwReserved
, dwFlags
, &newkey
->hPrivate
))
885 *phKey
= (HCRYPTKEY
)newkey
;
892 /******************************************************************************
893 * CryptEncrypt (ADVAPI32.@)
898 * hKey [I] Handle to the enryption key.
899 * hHash [I] Handle to a hash object.
900 * Final [I] TRUE if this is the last section to encrypt.
901 * dwFlags [I] Can be CRYPT_OAEP.
902 * pbData [I/O] Data to be encrypted. Contains encrypted data after call.
903 * pdwDataLen [I/O] Length of the data to encrypt. Contains the length of the
904 * encrypted data after call.
905 * dwBufLen [I] Length of the input pbData buffer.
912 * If pbData is NULL, CryptEncrypt determines stores the number of bytes
913 * required for the returned data in pdwDataLen.
915 BOOL WINAPI
CryptEncrypt (HCRYPTKEY hKey
, HCRYPTHASH hHash
, BOOL Final
,
916 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
, DWORD dwBufLen
)
919 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
920 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
922 TRACE("(0x%lx, 0x%lx, %d, %08ld, %p, %p, %ld)\n", hKey
, hHash
, Final
, dwFlags
, pbData
, pdwDataLen
, dwBufLen
);
924 if (!key
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
925 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
927 prov
= key
->pProvider
;
928 return prov
->pFuncs
->pCPEncrypt(prov
->hPrivate
, key
->hPrivate
, hash
? hash
->hPrivate
: 0,
929 Final
, dwFlags
, pbData
, pdwDataLen
, dwBufLen
);
932 /******************************************************************************
933 * CryptEnumProvidersW (ADVAPI32.@)
935 * Returns the next availabe CSP.
938 * dwIndex [I] Index of the next provider to be enumerated.
939 * pdwReserved [I] Reserved for future use and must be NULL.
940 * dwFlags [I] Reserved for future use and must be zero.
941 * pdwProvType [O] DWORD designating the type of the provider.
942 * pszProvName [O] Buffer that receives data from the provider.
943 * pcbProvName [I/O] Specifies the size of pszProvName. Contains the number
944 * of bytes stored in the buffer on return.
951 * If pszProvName is NULL, CryptEnumProvidersW sets the size of the name
952 * for memory allocation purposes.
954 BOOL WINAPI
CryptEnumProvidersW (DWORD dwIndex
, DWORD
*pdwReserved
,
955 DWORD dwFlags
, DWORD
*pdwProvType
, LPWSTR pszProvName
, DWORD
*pcbProvName
)
959 static const WCHAR providerW
[] = {
960 'S','o','f','t','w','a','r','e','\\',
961 'M','i','c','r','o','s','o','f','t','\\',
962 'C','r','y','p','t','o','g','r','a','p','h','y','\\',
963 'D','e','f','a','u','l','t','s','\\',
964 'P','r','o','v','i','d','e','r',0
967 static const WCHAR typeW
[] = {'T','y','p','e',0};
969 TRACE("(%ld, %p, %ld, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
970 pdwProvType
, pszProvName
, pcbProvName
);
972 if (pdwReserved
|| !pcbProvName
) CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
973 if (dwFlags
) CRYPT_ReturnLastError(NTE_BAD_FLAGS
);
975 if (RegOpenKeyW(HKEY_LOCAL_MACHINE
, providerW
, &hKey
))
976 CRYPT_ReturnLastError(NTE_FAIL
);
983 RegQueryInfoKeyW(hKey
, NULL
, NULL
, NULL
, &numkeys
, pcbProvName
,
984 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
986 if (!(provNameW
= CRYPT_Alloc(*pcbProvName
* sizeof(WCHAR
))))
987 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
989 RegEnumKeyExW(hKey
, dwIndex
, provNameW
, pcbProvName
, NULL
, NULL
, NULL
, NULL
);
991 *pcbProvName
*= sizeof(WCHAR
);
993 CRYPT_Free(provNameW
);
995 if (dwIndex
>= numkeys
)
996 CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS
);
998 DWORD size
= sizeof(DWORD
);
1002 result
= RegEnumKeyW(hKey
, dwIndex
, pszProvName
, *pcbProvName
/ sizeof(WCHAR
));
1004 CRYPT_ReturnLastError(result
);
1005 if (RegOpenKeyW(hKey
, pszProvName
, &subkey
))
1007 if (RegQueryValueExW(subkey
, typeW
, NULL
, NULL
, (BYTE
*)pdwProvType
, &size
))
1009 RegCloseKey(subkey
);
1015 /******************************************************************************
1016 * CryptEnumProvidersA (ADVAPI32.@)
1018 * see CryptEnumProvidersW
1020 BOOL WINAPI
CryptEnumProvidersA (DWORD dwIndex
, DWORD
*pdwReserved
,
1021 DWORD dwFlags
, DWORD
*pdwProvType
, LPSTR pszProvName
, DWORD
*pcbProvName
)
1025 BOOL ret
; /* = FALSE; */
1027 TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
1028 pdwProvType
, pszProvName
, pcbProvName
);
1030 strlen
= *pcbProvName
* sizeof(WCHAR
);
1031 if ( pszProvName
&& !(str
= CRYPT_Alloc(strlen
)) )
1032 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1033 ret
= CryptEnumProvidersW(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, str
, &strlen
);
1036 CRYPT_UnicodeToANSI(str
, &pszProvName
, *pcbProvName
);
1039 *pcbProvName
= strlen
/ sizeof(WCHAR
); /* FIXME: not correct */
1043 /******************************************************************************
1044 * CryptEnumProviderTypesA (ADVAPI32i.@)
1046 * Retrieves the next type of CSP supported.
1049 * dwIndex [I] Index of the next provider to be enumerated.
1050 * pdwReserved [I] Reserved for future use and must be NULL.
1051 * dwFlags [I] Reserved for future use and must be zero.
1052 * pdwProvType [O] DWORD designating the type of the provider.
1053 * pszTypeName [O] Buffer that receives data from the provider type.
1054 * pcbTypeName [I/O] Specifies the size of pszTypeName. Contains the number
1055 * of bytes stored in the buffer on return.
1062 * If pszTypeName is NULL, CryptEnumProviderTypesA sets the size of the name
1063 * for memory allocation purposes.
1065 BOOL WINAPI
CryptEnumProviderTypesA (DWORD dwIndex
, DWORD
*pdwReserved
,
1066 DWORD dwFlags
, DWORD
*pdwProvType
, LPSTR pszTypeName
, DWORD
*pcbTypeName
)
1069 DWORD keylen
, numkeys
, dwType
;
1073 TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex
, pdwReserved
,
1074 dwFlags
, pdwProvType
, pszTypeName
, pcbTypeName
);
1076 if (pdwReserved
|| !pdwProvType
|| !pcbTypeName
)
1077 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1078 if (dwFlags
) CRYPT_ReturnLastError(NTE_BAD_FLAGS
);
1080 if (RegOpenKeyA(HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Cryptography\\Defaults\\Provider Types", &hKey
))
1083 RegQueryInfoKeyA(hKey
, NULL
, NULL
, NULL
, &numkeys
, &keylen
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
1084 if (dwIndex
>= numkeys
)
1085 CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS
);
1087 if ( !(keyname
= CRYPT_Alloc(keylen
)) )
1088 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1089 if ( RegEnumKeyA(hKey
, dwIndex
, keyname
, keylen
) ) {
1090 CRYPT_Free(keyname
);
1093 RegOpenKeyA(hKey
, keyname
, &hSubkey
);
1094 ch
= keyname
+ strlen(keyname
);
1095 /* Convert "Type 000" to 0, etc/ */
1096 *pdwProvType
= *(--ch
) - '0';
1097 *pdwProvType
+= (*(--ch
) - '0') * 10;
1098 *pdwProvType
+= (*(--ch
) - '0') * 100;
1099 CRYPT_Free(keyname
);
1101 result
= RegQueryValueExA(hSubkey
, "TypeName", NULL
, &dwType
, (LPBYTE
)pszTypeName
, pcbTypeName
);
1103 CRYPT_ReturnLastError(result
);
1105 RegCloseKey(hSubkey
);
1110 /******************************************************************************
1111 * CryptEnumProviderTypesW (ADVAPI32.@)
1113 * see CryptEnumProviderTypesA
1115 BOOL WINAPI
CryptEnumProviderTypesW (DWORD dwIndex
, DWORD
*pdwReserved
,
1116 DWORD dwFlags
, DWORD
*pdwProvType
, LPWSTR pszTypeName
, DWORD
*pcbTypeName
)
1122 TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex
, pdwReserved
, dwFlags
,
1123 pdwProvType
, pszTypeName
, pcbTypeName
);
1124 strlen
= *pcbTypeName
/ sizeof(WCHAR
);
1125 if ( pszTypeName
&& !(str
= CRYPT_Alloc(strlen
)) )
1126 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1127 ret
= CryptEnumProviderTypesA(dwIndex
, pdwReserved
, dwFlags
, pdwProvType
, str
, &strlen
);
1130 CRYPT_ANSIToUnicode(str
, &pszTypeName
, *pcbTypeName
);
1133 *pcbTypeName
= strlen
* sizeof(WCHAR
);
1137 /******************************************************************************
1138 * CryptExportKey (ADVAPI32.@)
1140 * Exports a cryptographic key from a CSP.
1143 * hKey [I] Handle to the key to export.
1144 * hExpKey [I] Handle to a cryptographic key of the end user.
1145 * dwBlobType [I] Type of BLOB to be exported.
1146 * dwFlags [I] CRYPT_DESTROYKEY/SSL2_FALLBACK/OAEP.
1147 * pbData [O] Buffer to receive BLOB data.
1148 * pdwDataLen [I/O] Specifies the size of pbData.
1155 * if pbData is NULL, CryptExportKey sets pdwDataLen as the size of the
1156 * buffer needed to hold the BLOB.
1158 BOOL WINAPI
CryptExportKey (HCRYPTKEY hKey
, HCRYPTKEY hExpKey
, DWORD dwBlobType
,
1159 DWORD dwFlags
, BYTE
*pbData
, DWORD
*pdwDataLen
)
1162 PCRYPTKEY key
= (PCRYPTKEY
)hKey
, expkey
= (PCRYPTKEY
)hExpKey
;
1164 TRACE("(0x%lx, 0x%lx, %ld, %08ld, %p, %p)\n", hKey
, hExpKey
, dwBlobType
, dwFlags
, pbData
, pdwDataLen
);
1166 if (!key
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1167 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1169 prov
= key
->pProvider
;
1170 return prov
->pFuncs
->pCPExportKey(prov
->hPrivate
, key
->hPrivate
, expkey
? expkey
->hPrivate
: 0,
1171 dwBlobType
, dwFlags
, pbData
, pdwDataLen
);
1174 /******************************************************************************
1175 * CryptGenKey (ADVAPI32.@)
1177 * Generates a random cryptographic session key or a pub/priv key pair.
1180 * hProv [I] Handle to a CSP.
1181 * Algid [I] Algorithm to use to make key.
1182 * dwFlags [I] Specifies type of key to make.
1183 * phKey [I] Address of the handle to which the new key is copied.
1189 BOOL WINAPI
CryptGenKey (HCRYPTPROV hProv
, ALG_ID Algid
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
1191 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1194 TRACE("(0x%lx, %d, %08ld, %p)\n", hProv
, Algid
, dwFlags
, phKey
);
1197 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1198 if (!phKey
|| !prov
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1199 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1200 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1201 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1203 key
->pProvider
= prov
;
1205 if (prov
->pFuncs
->pCPGenKey(prov
->hPrivate
, Algid
, dwFlags
, &key
->hPrivate
))
1207 *phKey
= (HCRYPTKEY
)key
;
1216 /******************************************************************************
1217 * CryptGetDefaultProviderA (ADVAPI32.@)
1219 * Finds the default CSP of a certain provider type.
1222 * dwProvType [I] Provider type to look for.
1223 * pdwReserved [I] Reserved for future use and must be NULL.
1224 * dwFlags [I] CRYPT_MACHINE_DEFAULT/USER_DEFAULT
1225 * pszProvName [O] Name of the default CSP.
1226 * pcbProvName [I/O] Size of pszProvName
1233 * If pszProvName is NULL, pcbProvName will hold the size of the buffer for
1234 * memory allocation purposes on return.
1236 BOOL WINAPI
CryptGetDefaultProviderA (DWORD dwProvType
, DWORD
*pdwReserved
,
1237 DWORD dwFlags
, LPSTR pszProvName
, DWORD
*pcbProvName
)
1243 if (pdwReserved
|| !pcbProvName
)
1244 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1245 if (dwFlags
& ~(CRYPT_USER_DEFAULT
| CRYPT_MACHINE_DEFAULT
))
1246 CRYPT_ReturnLastError(NTE_BAD_FLAGS
);
1247 if (dwProvType
> 999)
1248 CRYPT_ReturnLastError(NTE_BAD_PROV_TYPE
);
1249 if ( !(keyname
= CRYPT_GetTypeKeyName(dwProvType
, dwFlags
& CRYPT_USER_DEFAULT
)) )
1250 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1251 if (RegOpenKeyA((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,keyname
, &hKey
))
1253 CRYPT_Free(keyname
);
1254 CRYPT_ReturnLastError(NTE_PROV_TYPE_NOT_DEF
);
1256 CRYPT_Free(keyname
);
1258 result
= RegQueryValueExA(hKey
, "Name", NULL
, NULL
, (LPBYTE
)pszProvName
, pcbProvName
);
1261 if (result
!= ERROR_MORE_DATA
)
1262 SetLastError(NTE_PROV_TYPE_ENTRY_BAD
);
1264 SetLastError(result
);
1273 /******************************************************************************
1274 * CryptGetDefaultProviderW (ADVAPI32.@)
1276 * see CryptGetDefaultProviderA
1278 BOOL WINAPI
CryptGetDefaultProviderW (DWORD dwProvType
, DWORD
*pdwReserved
,
1279 DWORD dwFlags
, LPWSTR pszProvName
, DWORD
*pcbProvName
)
1285 TRACE("(%ld, %p, %08ld, %p, %p)\n", dwProvType
, pdwReserved
, dwFlags
, pszProvName
, pcbProvName
);
1287 strlen
= *pcbProvName
/ sizeof(WCHAR
);
1288 if ( pszProvName
&& !(str
= CRYPT_Alloc(strlen
)) )
1289 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1290 ret
= CryptGetDefaultProviderA(dwProvType
, pdwReserved
, dwFlags
, str
, &strlen
);
1293 CRYPT_ANSIToUnicode(str
, &pszProvName
, *pcbProvName
);
1296 *pcbProvName
= strlen
* sizeof(WCHAR
);
1300 /******************************************************************************
1301 * CryptGetHashParam (ADVAPI32.@)
1303 * Retrieves data that controls the operations of a hash object.
1306 * hHash [I] Handle of the hash object to question.
1307 * dwParam [I] Query type.
1308 * pbData [O] Buffer that receives the value data.
1309 * pdwDataLen [I/O] Size of the pbData buffer.
1310 * dwFlags [I] Reserved for future use and must be zero.
1317 * If pbData is NULL, pdwDataLen will contain the length required.
1319 BOOL WINAPI
CryptGetHashParam (HCRYPTHASH hHash
, DWORD dwParam
, BYTE
*pbData
,
1320 DWORD
*pdwDataLen
, DWORD dwFlags
)
1323 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1325 TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hHash
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1327 if (!hash
|| !pdwDataLen
|| !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1328 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1330 prov
= hash
->pProvider
;
1331 return prov
->pFuncs
->pCPGetHashParam(prov
->hPrivate
, hash
->hPrivate
, dwParam
,
1332 pbData
, pdwDataLen
, dwFlags
);
1335 /******************************************************************************
1336 * CryptGetKeyParam (ADVAPI32.@)
1338 * Retrieves data that controls the operations of a key.
1341 * hKey [I] Handle to they key in question.
1342 * dwParam [I] Specifies query type.
1343 * pbData [O] Sequence of bytes to receive data.
1344 * pdwDataLen [I/O] Size of pbData.
1345 * dwFlags [I] Reserved for future use and must be zero.
1352 * If pbData is NULL, pdwDataLen is set to the needed length of the buffer.
1354 BOOL WINAPI
CryptGetKeyParam (HCRYPTKEY hKey
, DWORD dwParam
, BYTE
*pbData
,
1355 DWORD
*pdwDataLen
, DWORD dwFlags
)
1358 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1360 TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hKey
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1362 if (!key
|| !pdwDataLen
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1363 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1365 prov
= key
->pProvider
;
1366 return prov
->pFuncs
->pCPGetKeyParam(prov
->hPrivate
, key
->hPrivate
, dwParam
,
1367 pbData
, pdwDataLen
, dwFlags
);
1370 /******************************************************************************
1371 * CryptGetProvParam (ADVAPI32.@)
1373 * Retrieves parameters that control the operations of a CSP.
1376 * hProv [I] Handle of the CSP in question.
1377 * dwParam [I] Specifies query type.
1378 * pbData [O] Buffer to receive the data.
1379 * pdwDataLen [I/O] Size of pbData.
1380 * dwFlags [I] see MSDN Docs.
1387 * If pbData is NULL, pdwDataLen is set to the needed buffer length.
1389 BOOL WINAPI
CryptGetProvParam (HCRYPTPROV hProv
, DWORD dwParam
, BYTE
*pbData
,
1390 DWORD
*pdwDataLen
, DWORD dwFlags
)
1392 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1394 TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hProv
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1396 if (!prov
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1397 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1399 return prov
->pFuncs
->pCPGetProvParam(prov
->hPrivate
, dwParam
, pbData
, pdwDataLen
, dwFlags
);
1402 /******************************************************************************
1403 * CryptGetUserKey (ADVAPI32.@)
1405 * Gets a handle of one of a user's two public/private key pairs.
1408 * hProv [I] Handle of a CSP.
1409 * dwKeySpec [I] Private key to use.
1410 * phUserKey [O] Pointer to the handle of the retrieved keys.
1416 BOOL WINAPI
CryptGetUserKey (HCRYPTPROV hProv
, DWORD dwKeySpec
, HCRYPTKEY
*phUserKey
)
1418 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1421 TRACE("(0x%lx, %ld, %p)\n", hProv
, dwKeySpec
, phUserKey
);
1424 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1425 if (!phUserKey
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1426 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1427 if ( !(key
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1428 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1430 key
->pProvider
= prov
;
1432 if (prov
->pFuncs
->pCPGetUserKey(prov
->hPrivate
, dwKeySpec
, &key
->hPrivate
))
1434 *phUserKey
= (HCRYPTKEY
)key
;
1444 /******************************************************************************
1445 * CryptHashData (ADVAPI32.@)
1447 * Adds data to a hash object.
1450 * hHash [I] Handle of the hash object.
1451 * pbData [I] Buffer of data to be hashed.
1452 * dwDataLen [I] Number of bytes to add.
1453 * dwFlags [I] Can be CRYPT_USERDATA
1459 BOOL WINAPI
CryptHashData (HCRYPTHASH hHash
, const BYTE
*pbData
, DWORD dwDataLen
, DWORD dwFlags
)
1461 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1464 TRACE("(0x%lx, %p, %ld, %08ld)\n", hHash
, pbData
, dwDataLen
, dwFlags
);
1467 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1468 if (!hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1469 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1471 prov
= hash
->pProvider
;
1472 return prov
->pFuncs
->pCPHashData(prov
->hPrivate
, hash
->hPrivate
, pbData
, dwDataLen
, dwFlags
);
1475 /******************************************************************************
1476 * CryptHashSessionKey (ADVAPI32.@)
1479 * hHash [I] Handle to the hash object.
1480 * hKey [I] Handle to the key to be hashed.
1481 * dwFlags [I] Can be CRYPT_LITTLE_ENDIAN.
1487 BOOL WINAPI
CryptHashSessionKey (HCRYPTHASH hHash
, HCRYPTKEY hKey
, DWORD dwFlags
)
1489 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1490 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1493 TRACE("(0x%lx, 0x%lx, %08ld)\n", hHash
, hKey
, dwFlags
);
1496 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1498 if (!hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1499 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1501 prov
= hash
->pProvider
;
1502 return prov
->pFuncs
->pCPHashSessionKey(prov
->hPrivate
, hash
->hPrivate
, key
->hPrivate
, dwFlags
);
1505 /******************************************************************************
1506 * CryptImportKey (ADVAPI32.@)
1509 * hProv [I] Handle of a CSP.
1510 * pbData [I] Contains the key to be imported.
1511 * dwDataLen [I] Length of the key.
1512 * hPubKey [I] Cryptographic key that decrypts pdData
1513 * dwFlags [I] Used only with a public/private key pair.
1514 * phKey [O] Imported key.
1520 BOOL WINAPI
CryptImportKey (HCRYPTPROV hProv
, BYTE
*pbData
, DWORD dwDataLen
,
1521 HCRYPTKEY hPubKey
, DWORD dwFlags
, HCRYPTKEY
*phKey
)
1523 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1524 PCRYPTKEY pubkey
= (PCRYPTKEY
)hPubKey
, importkey
;
1526 TRACE("(0x%lx, %p, %ld, 0x%lx, %08ld, %p)\n", hProv
, pbData
, dwDataLen
, hPubKey
, dwFlags
, phKey
);
1528 if (!prov
|| !pbData
|| !dwDataLen
|| !phKey
|| prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1529 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1531 if ( !(importkey
= CRYPT_Alloc(sizeof(CRYPTKEY
))) )
1532 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1534 importkey
->pProvider
= prov
;
1535 if (prov
->pFuncs
->pCPImportKey(prov
->hPrivate
, pbData
, dwDataLen
,
1536 pubkey
? pubkey
->hPrivate
: 0, dwFlags
, &importkey
->hPrivate
))
1538 *phKey
= (HCRYPTKEY
)importkey
;
1542 CRYPT_Free(importkey
);
1546 /******************************************************************************
1547 * CryptSignHashW (ADVAPI32.@)
1552 * hHash [I] Handle of the hash object to be signed.
1553 * dwKeySpec [I] Private key to use.
1554 * sDescription [I] Should be NULL.
1555 * dwFlags [I] CRYPT_NOHASHOID/X931_FORMAT.
1556 * pbSignature [O] Buffer of the signature data.
1557 * pdwSigLen [I/O] Size of the pbSignature buffer.
1564 * Because of security flaws sDescription should not be used and should thus be
1565 * NULL. It is supported only for compatibility with Microsoft's Cryptographic
1568 BOOL WINAPI
CryptSignHashW (HCRYPTHASH hHash
, DWORD dwKeySpec
, LPCWSTR sDescription
,
1569 DWORD dwFlags
, BYTE
*pbSignature
, DWORD
*pdwSigLen
)
1571 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1574 TRACE("(0x%lx, %ld, %s, %08ld, %p, %p)\n",
1575 hHash
, dwKeySpec
, debugstr_w(sDescription
), dwFlags
, pbSignature
, pdwSigLen
);
1578 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1579 if (!pdwSigLen
|| !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1580 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1582 prov
= hash
->pProvider
;
1583 return prov
->pFuncs
->pCPSignHash(prov
->hPrivate
, hash
->hPrivate
, dwKeySpec
, sDescription
,
1584 dwFlags
, pbSignature
, pdwSigLen
);
1587 /******************************************************************************
1588 * CryptSignHashA (ADVAPI32.@)
1590 * ASCII version of CryptSignHashW
1592 BOOL WINAPI
CryptSignHashA (HCRYPTHASH hHash
, DWORD dwKeySpec
, LPCSTR sDescription
,
1593 DWORD dwFlags
, BYTE
*pbSignature
, DWORD
*pdwSigLen
)
1595 LPWSTR wsDescription
;
1598 TRACE("(0x%lx, %ld, %s, %08ld, %p, %p)\n",
1599 hHash
, dwKeySpec
, debugstr_a(sDescription
), dwFlags
, pbSignature
, pdwSigLen
);
1601 CRYPT_ANSIToUnicode(sDescription
, &wsDescription
, -1);
1602 result
= CryptSignHashW(hHash
, dwKeySpec
, wsDescription
, dwFlags
, pbSignature
, pdwSigLen
);
1603 if (wsDescription
) CRYPT_Free(wsDescription
);
1608 /******************************************************************************
1609 * CryptSetHashParam (ADVAPI32.@)
1611 * Customizes the operations of a hash object.
1614 * hHash [I] Handle of the hash object to set parameters.
1615 * dwParam [I] HP_HMAC_INFO/HASHVAL.
1616 * pbData [I] Value data buffer.
1617 * dwFlags [I] Reserved for future use and must be zero.
1623 BOOL WINAPI
CryptSetHashParam (HCRYPTHASH hHash
, DWORD dwParam
, BYTE
*pbData
, DWORD dwFlags
)
1626 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1628 TRACE("(0x%lx, %ld, %p, %08ld)\n", hHash
, dwParam
, pbData
, dwFlags
);
1630 if (!hash
|| !pbData
|| !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1631 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1633 prov
= hash
->pProvider
;
1634 return prov
->pFuncs
->pCPSetHashParam(prov
->hPrivate
, hash
->hPrivate
,
1635 dwParam
, pbData
, dwFlags
);
1638 /******************************************************************************
1639 * CryptSetKeyParam (ADVAPI32.@)
1641 * Customizes a session key's operations.
1644 * hKey [I] Handle to the key to set values.
1645 * dwParam [I] See MSDN Doc.
1646 * pbData [I] Buffer of values to set.
1647 * dwFlags [I] Only used when dwParam == KP_ALGID.
1653 BOOL WINAPI
CryptSetKeyParam (HCRYPTKEY hKey
, DWORD dwParam
, BYTE
*pbData
, DWORD dwFlags
)
1656 PCRYPTKEY key
= (PCRYPTKEY
)hKey
;
1658 TRACE("(0x%lx, %ld, %p, %08ld)\n", hKey
, dwParam
, pbData
, dwFlags
);
1660 if (!key
|| !pbData
|| !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1661 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1663 prov
= key
->pProvider
;
1664 return prov
->pFuncs
->pCPSetKeyParam(prov
->hPrivate
, key
->hPrivate
,
1665 dwParam
, pbData
, dwFlags
);
1668 /******************************************************************************
1669 * CryptSetProviderA (ADVAPI32.@)
1671 * Specifies the current user's default CSP.
1674 * pszProvName [I] Name of the new default CSP.
1675 * dwProvType [I] Provider type of the CSP.
1681 BOOL WINAPI
CryptSetProviderA (LPCSTR pszProvName
, DWORD dwProvType
)
1683 TRACE("(%s, %ld)\n", pszProvName
, dwProvType
);
1684 return CryptSetProviderExA(pszProvName
, dwProvType
, NULL
, CRYPT_USER_DEFAULT
);
1687 /******************************************************************************
1688 * CryptSetProviderW (ADVAPI32.@)
1690 * See CryptSetProviderA
1692 BOOL WINAPI
CryptSetProviderW (LPCWSTR pszProvName
, DWORD dwProvType
)
1694 TRACE("(%s, %ld)\n", debugstr_w(pszProvName
), dwProvType
);
1695 return CryptSetProviderExW(pszProvName
, dwProvType
, NULL
, CRYPT_USER_DEFAULT
);
1698 /******************************************************************************
1699 * CryptSetProviderExA (ADVAPI32.@)
1701 * Specifies the default CSP.
1704 * pszProvName [I] Name of the new default CSP.
1705 * dwProvType [I] Provider type of the CSP.
1706 * pdwReserved [I] Reserved for future use and must be NULL.
1707 * dwFlags [I] See MSDN Doc.
1713 BOOL WINAPI
CryptSetProviderExA (LPCSTR pszProvName
, DWORD dwProvType
, DWORD
*pdwReserved
, DWORD dwFlags
)
1715 HKEY hProvKey
, hTypeKey
;
1718 TRACE("(%s, %ld, %p, %08ld)\n", pszProvName
, dwProvType
, pdwReserved
, dwFlags
);
1720 if (!pszProvName
|| pdwReserved
)
1721 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1722 if (dwProvType
> MAXPROVTYPES
)
1723 CRYPT_ReturnLastError(NTE_BAD_PROV_TYPE
);
1724 if (dwFlags
& ~(CRYPT_MACHINE_DEFAULT
| CRYPT_USER_DEFAULT
| CRYPT_DELETE_DEFAULT
)
1725 || dwFlags
== CRYPT_DELETE_DEFAULT
)
1726 CRYPT_ReturnLastError(NTE_BAD_FLAGS
);
1728 if (!(keyname
= CRYPT_GetTypeKeyName(dwProvType
, dwFlags
& CRYPT_USER_DEFAULT
)))
1729 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1730 if (RegOpenKeyA((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,
1731 keyname
, &hTypeKey
))
1733 CRYPT_Free(keyname
);
1734 CRYPT_ReturnLastError(NTE_BAD_PROVIDER
);
1736 CRYPT_Free(keyname
);
1738 if (dwFlags
& CRYPT_DELETE_DEFAULT
)
1740 RegDeleteValueA(hTypeKey
, "Name");
1744 if (!(keyname
= CRYPT_GetProvKeyName(pszProvName
)))
1746 RegCloseKey(hTypeKey
);
1747 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY
);
1749 if (RegOpenKeyA((dwFlags
& CRYPT_USER_DEFAULT
) ? HKEY_CURRENT_USER
: HKEY_LOCAL_MACHINE
,
1750 keyname
, &hProvKey
))
1752 CRYPT_Free(keyname
);
1753 RegCloseKey(hTypeKey
);
1754 CRYPT_ReturnLastError(NTE_BAD_PROVIDER
);
1756 CRYPT_Free(keyname
);
1758 if (RegSetValueExA(hTypeKey
, "Name", 0, REG_SZ
, (LPBYTE
)pszProvName
, strlen(pszProvName
) + 1))
1760 RegCloseKey(hTypeKey
);
1761 RegCloseKey(hProvKey
);
1765 RegCloseKey(hProvKey
);
1767 RegCloseKey(hTypeKey
);
1772 /******************************************************************************
1773 * CryptSetProviderExW (ADVAPI32.@)
1775 * See CryptSetProviderExA
1777 BOOL WINAPI
CryptSetProviderExW (LPCWSTR pszProvName
, DWORD dwProvType
, DWORD
*pdwReserved
, DWORD dwFlags
)
1782 TRACE("(%s, %ld, %p, %08ld)\n", debugstr_w(pszProvName
), dwProvType
, pdwReserved
, dwFlags
);
1784 if (CRYPT_UnicodeToANSI(pszProvName
, &str
, -1))
1786 ret
= CryptSetProviderExA(str
, dwProvType
, pdwReserved
, dwFlags
);
1792 /******************************************************************************
1793 * CryptSetProvParam (ADVAPI32.@)
1795 * Customizes the operations of a CSP.
1798 * hProv [I] Handle of a CSP.
1799 * dwParam [I] See MSDN Doc.
1800 * pbData [I] Buffer that contains a value to set as a parameter.
1801 * dwFlags [I] if dwParam is PP_USE_HARDWARE_RNG, dwFlags must be zero.
1807 BOOL WINAPI
CryptSetProvParam (HCRYPTPROV hProv
, DWORD dwParam
, BYTE
*pbData
, DWORD dwFlags
)
1809 PCRYPTPROV prov
= (PCRYPTPROV
)hProv
;
1811 TRACE("(0x%lx, %ld, %p, %08ld)\n", hProv
, dwParam
, pbData
, dwFlags
);
1814 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1815 if (prov
->dwMagic
!= MAGIC_CRYPTPROV
)
1816 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1817 if (dwFlags
& PP_USE_HARDWARE_RNG
)
1819 FIXME("PP_USE_HARDWARE_RNG: What do I do with this?\n");
1820 FIXME("\tLetting the CSP decide.\n");
1822 if (dwFlags
& PP_CLIENT_HWND
)
1824 /* FIXME: Should verify the parameter */
1825 if (pbData
/* && IsWindow((HWND)pbData) */)
1827 crypt_hWindow
= (HWND
)(pbData
);
1830 SetLastError(ERROR_INVALID_PARAMETER
);
1834 /* All other flags go to the CSP */
1835 return prov
->pFuncs
->pCPSetProvParam(prov
->hPrivate
, dwParam
, pbData
, dwFlags
);
1838 /******************************************************************************
1839 * CryptVerifySignatureW (ADVAPI32.@)
1841 * Verifies the signature of a hash object.
1844 * hHash [I] Handle of the hash object to verify.
1845 * pbSignature [I] Signature data to verify.
1846 * dwSigLen [I] Size of pbSignature.
1847 * hPubKey [I] Handle to the public key to authenticate signature.
1848 * sDescription [I] Should be NULL.
1849 * dwFlags [I] See MSDN doc.
1856 * Because of security flaws sDescription should not be used and should thus be
1857 * NULL. It is supported only for compatibility with Microsoft's Cryptographic
1860 BOOL WINAPI
CryptVerifySignatureW (HCRYPTHASH hHash
, BYTE
*pbSignature
, DWORD dwSigLen
,
1861 HCRYPTKEY hPubKey
, LPCWSTR sDescription
, DWORD dwFlags
)
1863 PCRYPTHASH hash
= (PCRYPTHASH
)hHash
;
1864 PCRYPTKEY key
= (PCRYPTKEY
)hPubKey
;
1867 TRACE("(0x%lx, %p, %ld, 0x%lx, %s, %08ld)\n", hHash
, pbSignature
,
1868 dwSigLen
, hPubKey
, debugstr_w(sDescription
), dwFlags
);
1871 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE
);
1872 if (!pbSignature
|| !dwSigLen
||
1873 !hash
->pProvider
|| hash
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
||
1874 !key
->pProvider
|| key
->pProvider
->dwMagic
!= MAGIC_CRYPTPROV
)
1876 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER
);
1879 prov
= hash
->pProvider
;
1880 return prov
->pFuncs
->pCPVerifySignature(prov
->hPrivate
, hash
->hPrivate
, pbSignature
, dwSigLen
,
1881 key
->hPrivate
, sDescription
, dwFlags
);
1884 /******************************************************************************
1885 * CryptVerifySignatureA (ADVAPI32.@)
1887 * ASCII version of CryptVerifySignatureW
1889 BOOL WINAPI
CryptVerifySignatureA (HCRYPTHASH hHash
, BYTE
*pbSignature
, DWORD dwSigLen
,
1890 HCRYPTKEY hPubKey
, LPCSTR sDescription
, DWORD dwFlags
)
1892 LPWSTR wsDescription
;
1895 TRACE("(0x%lx, %p, %ld, 0x%lx, %s, %08ld)\n", hHash
, pbSignature
,
1896 dwSigLen
, hPubKey
, debugstr_a(sDescription
), dwFlags
);
1898 CRYPT_ANSIToUnicode(sDescription
, &wsDescription
, -1);
1899 result
= CryptVerifySignatureW(hHash
, pbSignature
, dwSigLen
, hPubKey
, wsDescription
, dwFlags
);
1900 if (wsDescription
) CRYPT_Free(wsDescription
);
1905 /******************************************************************************
1906 * SystemFunction036 (ADVAPI32.@)
1908 * MSDN documents this function as RtlGenRandom and declares it in ntsecapi.h
1911 * pbBufer [O] Pointer to memory to receive random bytes.
1912 * dwLen [I] Number of random bytes to fetch.
1915 BOOL WINAPI
SystemFunction036(PVOID pbBuffer
, ULONG dwLen
)
1919 /* FIXME: /dev/urandom does not provide random numbers of a sufficient
1920 * quality for cryptographic applications. /dev/random is much better,
1921 * but it blocks if the kernel has not yet collected enough entropy for
1922 * the request, which will suspend the calling thread for an indefinite
1923 * amount of time. */
1924 dev_random
= open("/dev/urandom", O_RDONLY
);
1925 if (dev_random
!= -1)
1927 if (read(dev_random
, pbBuffer
, dwLen
) == (ssize_t
)dwLen
)
1934 SetLastError(NTE_FAIL
);
1939 These functions have nearly identical prototypes to CryptProtectMemory and CryptUnprotectMemory,
1943 /******************************************************************************
1944 * SystemFunction040 (ADVAPI32.@)
1946 * MSDN documents this function as RtlEncryptMemory.
1949 * memory [I/O] Pointer to memory to encrypt.
1950 * length [I] Length of region to encrypt in bytes.
1951 * flags [I] Control whether other processes are able to decrypt the memory.
1952 * RTL_ENCRYPT_OPTION_SAME_PROCESS
1953 * RTL_ENCRYPT_OPTION_CROSS_PROCESS
1954 * RTL_ENCRYPT_OPTION_SAME_LOGON
1957 * length must be a multiple of RTL_ENCRYPT_MEMORY_SIZE.
1958 * If flags are specified when encrypting, the same flag value must be given
1959 * when decrypting the memory.
1961 NTSTATUS WINAPI
SystemFunction040(PVOID memory
, ULONG length
, ULONG flags
)
1963 FIXME("(%p, %lx, %lx): stub [RtlEncryptMemory]\n", memory
, length
, flags
);
1964 return STATUS_SUCCESS
;
1967 /******************************************************************************
1968 * SystemFunction041 (ADVAPI32.@)
1970 * MSDN documents this function as RtlDecryptMemory.
1973 * memory [I/O] Pointer to memory to decrypt.
1974 * length [I] Length of region to decrypt in bytes.
1975 * flags [I] Control whether other processes are able to decrypt the memory.
1976 * RTL_ENCRYPT_OPTION_SAME_PROCESS
1977 * RTL_ENCRYPT_OPTION_CROSS_PROCESS
1978 * RTL_ENCRYPT_OPTION_SAME_LOGON
1981 * length must be a multiple of RTL_ENCRYPT_MEMORY_SIZE.
1982 * If flags are specified when encrypting, the same flag value must be given
1983 * when decrypting the memory.
1985 NTSTATUS WINAPI
SystemFunction041(PVOID memory
, ULONG length
, ULONG flags
)
1987 FIXME("(%p, %lx, %lx): stub [RtlDecryptMemory]\n", memory
, length
, flags
);
1988 return STATUS_SUCCESS
;