?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wow64: In wow64_NtSetInformationToken forward TokenIntegrityLevel.
[wine.git] / dlls / advapi32 / crypt.c
blob0c94999660a2a9160c52619e54df98b71cf3efd0
1 /*
2 * Copyright 1999 Ian Schmidt
3 * Copyright 2001 Travis Michielsen
4 *
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.
9 *
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.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 /***********************************************************************
21 *
22 * TODO:
23 * - Reference counting
24 * - Thread-safing
25 */
26
27 #include <limits.h>
28 #include <time.h>
29 #include <stdlib.h>
30 #include <stdio.h>
31 #include <sys/types.h>
32
33 #include "ntstatus.h"
34 #define WIN32_NO_STATUS
35 #include "crypt.h"
36 #include "winnls.h"
37 #include "winreg.h"
38 #include "rpc.h"
39 #include "wine/debug.h"
40 #include "wine/exception.h"
41 #include "winternl.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
44
45 typedef struct tagMD4_CTX {
46 unsigned int buf[4];
47 unsigned int i[2];
48 unsigned char in[64];
49 unsigned char digest[16];
50 } MD4_CTX;
51
52 void WINAPI MD4Init(MD4_CTX *ctx);
53 void WINAPI MD4Update(MD4_CTX *ctx, const unsigned char *buf, unsigned int len);
54 void WINAPI MD4Final(MD4_CTX *ctx);
55
56 static HWND crypt_hWindow;
57
58 #define CRYPT_Alloc(size) (LocalAlloc(LMEM_ZEROINIT, size))
59 #define CRYPT_Free(buffer) (LocalFree(buffer))
60
61 static void *pointer_from_handle(UINT_PTR handle, DWORD magic)
62 {
63 void *ret = NULL;
64
65 __TRY
66 {
67 if (handle && *(DWORD *)handle == magic)
68 ret = (void *)handle;
69 }
70 __EXCEPT_PAGE_FAULT
71 {
72 }
73 __ENDTRY
74
75 if (!ret)
76 SetLastError(ERROR_INVALID_PARAMETER);
77
78 return ret;
79 }
80
81 static PCRYPTPROV provider_from_handle(HCRYPTPROV handle)
82 {
83 return pointer_from_handle(handle, MAGIC_CRYPTPROV);
84 }
85
86 static PCRYPTHASH hash_from_handle(HCRYPTHASH handle)
87 {
88 return pointer_from_handle(handle, MAGIC_CRYPTHASH);
89 }
90
91 static PCRYPTKEY key_from_handle(HCRYPTKEY handle)
92 {
93 return pointer_from_handle(handle, MAGIC_CRYPTKEY);
94 }
95
96 static inline PWSTR CRYPT_GetProvKeyName(PCWSTR pProvName)
97 {
98 static const WCHAR KEYSTR[] = L"Software\\Microsoft\\Cryptography\\Defaults\\Provider\\";
99 PWSTR keyname;
100
101 keyname = CRYPT_Alloc((lstrlenW(KEYSTR) + lstrlenW(pProvName) +1)*sizeof(WCHAR));
102 if (keyname)
103 {
104 lstrcpyW(keyname, KEYSTR);
105 lstrcpyW(keyname + lstrlenW(KEYSTR), pProvName);
106 } else
107 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
108 return keyname;
109 }
110
111 static inline PWSTR CRYPT_GetTypeKeyName(DWORD dwType, BOOL user)
112 {
113 static const WCHAR MACHINESTR[] = L"Software\\Microsoft\\Cryptography\\Defaults\\Provider Types\\Type XXX";
114 static const WCHAR USERSTR[] = L"Software\\Microsoft\\Cryptography\\Provider Type XXX";
115 PWSTR keyname;
116 PWSTR ptr;
117
118 keyname = CRYPT_Alloc( ((user ? lstrlenW(USERSTR) : lstrlenW(MACHINESTR)) +1)*sizeof(WCHAR));
119 if (keyname)
120 {
121 user ? lstrcpyW(keyname, USERSTR) : lstrcpyW(keyname, MACHINESTR);
122 ptr = keyname + lstrlenW(keyname);
123 *(--ptr) = (dwType % 10) + '0';
124 *(--ptr) = ((dwType / 10) % 10) + '0';
125 *(--ptr) = (dwType / 100) + '0';
126 } else
127 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
128 return keyname;
129 }
130
131 /* CRYPT_UnicodeToANSI
132 * wstr - unicode string
133 * str - pointer to ANSI string or pointer to null pointer if we have to do the allocation
134 * strsize - size of buffer pointed to by str
135 *
136 * returns TRUE if unsuccessful, FALSE otherwise.
137 * if wstr is NULL, returns TRUE and sets str to NULL! Value of str should be checked after call
138 */
139 static inline BOOL CRYPT_UnicodeToANSI(LPCWSTR wstr, LPSTR* str, int strsize)
140 {
141 if (!wstr)
142 {
143 *str = NULL;
144 return TRUE;
145 }
146
147 if (!*str)
148 {
149 strsize = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
150 *str = CRYPT_Alloc(strsize * sizeof(CHAR));
151 }
152 else if (strsize < 0)
153 {
154 strsize = INT_MAX; /* windows will pretend that the buffer is infinitely long */
155 }
156
157 if (*str)
158 {
159 WideCharToMultiByte(CP_ACP, 0, wstr, -1, *str, strsize, NULL, NULL);
160 return TRUE;
161 }
162
163 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
164 return FALSE;
165 }
166
167 /* CRYPT_ANSITOUnicode
168 * str - ANSI string
169 * wstr - pointer to unicode string
170 * wstrsize - size of buffer pointed to by wstr or -1 if we have to do the allocation
171 */
172 static inline BOOL CRYPT_ANSIToUnicode(LPCSTR str, LPWSTR* wstr, int wstrsize)
173 {
174 unsigned int wcount;
175
176 if (!str)
177 {
178 *wstr = NULL;
179 return TRUE;
180 }
181 wcount = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
182 if (wstrsize == -1)
183 *wstr = CRYPT_Alloc(wcount * sizeof(WCHAR));
184 else
185 wcount = min( wcount, wstrsize/sizeof(WCHAR) );
186 if (*wstr)
187 {
188 MultiByteToWideChar(CP_ACP, 0, str, -1, *wstr, wcount);
189 return TRUE;
190 }
191 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
192 return FALSE;
193 }
194
195 /* These next 2 functions are used by the VTableProvStruc structure */
196 static BOOL CALLBACK CRYPT_VerifyImage(LPCSTR lpszImage, BYTE* pData)
197 {
198 if (!lpszImage || !pData)
199 {
200 SetLastError(ERROR_INVALID_PARAMETER);
201 return FALSE;
202 }
203
204 FIXME("(%s, %p): not verifying image\n", lpszImage, pData);
205
206 return TRUE;
207 }
208
209 static void CALLBACK CRYPT_ReturnhWnd(HWND *phWnd)
210 {
211 if (phWnd) *phWnd = crypt_hWindow;
212 }
213
214 #define CRYPT_GetProvFunc(name) \
215 if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error
216 #define CRYPT_GetProvFuncOpt(name) \
217 provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)
218 static PCRYPTPROV CRYPT_LoadProvider(PCWSTR pImage)
219 {
220 PCRYPTPROV provider;
221 DWORD errorcode = ERROR_NOT_ENOUGH_MEMORY;
222
223 if ( !(provider = CRYPT_Alloc(sizeof(CRYPTPROV))) ) goto error;
224 if ( !(provider->pFuncs = CRYPT_Alloc(sizeof(PROVFUNCS))) ) goto error;
225 if ( !(provider->pVTable = CRYPT_Alloc(sizeof(VTableProvStruc))) ) goto error;
226 if ( !(provider->hModule = LoadLibraryW(pImage)) )
227 {
228 errorcode = (GetLastError() == ERROR_FILE_NOT_FOUND) ? NTE_PROV_DLL_NOT_FOUND : NTE_PROVIDER_DLL_FAIL;
229 FIXME("Failed to load dll %s\n", debugstr_w(pImage));
230 goto error;
231 }
232 provider->dwMagic = MAGIC_CRYPTPROV;
233 provider->refcount = 1;
234
235 errorcode = NTE_PROVIDER_DLL_FAIL;
236 CRYPT_GetProvFunc(CPAcquireContext);
237 CRYPT_GetProvFunc(CPCreateHash);
238 CRYPT_GetProvFunc(CPDecrypt);
239 CRYPT_GetProvFunc(CPDeriveKey);
240 CRYPT_GetProvFunc(CPDestroyHash);
241 CRYPT_GetProvFunc(CPDestroyKey);
242 CRYPT_GetProvFuncOpt(CPDuplicateHash);
243 CRYPT_GetProvFuncOpt(CPDuplicateKey);
244 CRYPT_GetProvFunc(CPEncrypt);
245 CRYPT_GetProvFunc(CPExportKey);
246 CRYPT_GetProvFunc(CPGenKey);
247 CRYPT_GetProvFunc(CPGenRandom);
248 CRYPT_GetProvFunc(CPGetHashParam);
249 CRYPT_GetProvFunc(CPGetKeyParam);
250 CRYPT_GetProvFunc(CPGetProvParam);
251 CRYPT_GetProvFunc(CPGetUserKey);
252 CRYPT_GetProvFunc(CPHashData);
253 CRYPT_GetProvFunc(CPHashSessionKey);
254 CRYPT_GetProvFunc(CPImportKey);
255 CRYPT_GetProvFunc(CPReleaseContext);
256 CRYPT_GetProvFunc(CPSetHashParam);
257 CRYPT_GetProvFunc(CPSetKeyParam);
258 CRYPT_GetProvFunc(CPSetProvParam);
259 CRYPT_GetProvFunc(CPSignHash);
260 CRYPT_GetProvFunc(CPVerifySignature);
261
262 /* FIXME: Not sure what the pbContextInfo field is for.
263 * Does it need memory allocation?
264 */
265 provider->pVTable->Version = 3;
266 provider->pVTable->FuncVerifyImage = CRYPT_VerifyImage;
267 provider->pVTable->FuncReturnhWnd = CRYPT_ReturnhWnd;
268 provider->pVTable->dwProvType = 0;
269 provider->pVTable->pbContextInfo = NULL;
270 provider->pVTable->cbContextInfo = 0;
271 provider->pVTable->pszProvName = NULL;
272 return provider;
273
274 error:
275 SetLastError(errorcode);
276 if (provider)
277 {
278 provider->dwMagic = 0;
279 if (provider->hModule)
280 FreeLibrary(provider->hModule);
281 CRYPT_Free(provider->pVTable);
282 CRYPT_Free(provider->pFuncs);
283 CRYPT_Free(provider);
284 }
285 return NULL;
286 }
287 #undef CRYPT_GetProvFunc
288 #undef CRYPT_GetProvFuncOpt
289
290
291 static void CRYPT_CreateMachineGuid(void)
292 {
293 LONG r;
294 HKEY key;
295
296 r = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Cryptography", 0, KEY_ALL_ACCESS | KEY_WOW64_64KEY,
297 &key);
298 if (!r)
299 {
300 DWORD size;
301
302 r = RegQueryValueExW(key, L"MachineGuid", NULL, NULL, NULL, &size);
303 if (r == ERROR_FILE_NOT_FOUND)
304 {
305 UUID uuid;
306 WCHAR buf[37];
307
308 if (UuidCreate(&uuid) == S_OK)
309 {
310 swprintf(buf, ARRAY_SIZE(buf), L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
311 uuid.Data1, uuid.Data2, uuid.Data3,
312 uuid.Data4[0], uuid.Data4[1],
313 uuid.Data4[2], uuid.Data4[3],
314 uuid.Data4[4], uuid.Data4[5],
315 uuid.Data4[6], uuid.Data4[7] );
316 RegSetValueExW(key, L"MachineGuid", 0, REG_SZ,
317 (const BYTE *)buf,
318 (lstrlenW(buf)+1)*sizeof(WCHAR));
319 }
320 }
321 RegCloseKey(key);
322 }
323 }
324
325
326 /******************************************************************************
327 * CloseEncryptedFileRaw (ADVAPI32.@)
328 *
329 * Close encrypted files
330 *
331 * PARAMS
332 * context [I] pointer to the context
333 * RETURNS
334 * Success: ERROR_SUCCESS
335 * Failure: NTSTATUS error code
336 */
337 void WINAPI CloseEncryptedFileRaw(PVOID context)
338 {
339 FIXME("(%p): stub\n", context);
340 }
341
342 /******************************************************************************
343 * CryptAcquireContextW (ADVAPI32.@)
344 *
345 * Acquire a crypto provider context handle.
346 *
347 * PARAMS
348 * phProv [O] Pointer to HCRYPTPROV for the output.
349 * pszContainer [I] Key Container Name
350 * pszProvider [I] Cryptographic Service Provider Name
351 * dwProvType [I] Crypto provider type to get a handle.
352 * dwFlags [I] flags for the operation
353 *
354 * RETURNS
355 * TRUE on success, FALSE on failure.
356 */
357 BOOL WINAPI CryptAcquireContextW (HCRYPTPROV *phProv, LPCWSTR pszContainer,
358 LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
359 {
360 PCRYPTPROV pProv = NULL;
361 HKEY key;
362 PWSTR imagepath = NULL, keyname = NULL, provname = NULL, temp = NULL;
363 PSTR provnameA = NULL, pszContainerA = NULL;
364 DWORD keytype, type, len;
365 ULONG r;
366
367 TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv, debugstr_w(pszContainer),
368 debugstr_w(pszProvider), dwProvType, dwFlags);
369
370 if (dwProvType < 1 || dwProvType > MAXPROVTYPES)
371 {
372 SetLastError(NTE_BAD_PROV_TYPE);
373 return FALSE;
374 }
375
376 if (!phProv)
377 {
378 SetLastError(ERROR_INVALID_PARAMETER);
379 return FALSE;
380 }
381
382 /* Make sure the MachineGuid value exists */
383 CRYPT_CreateMachineGuid();
384
385 if (!pszProvider || !*pszProvider)
386 {
387 /* No CSP name specified so try the user default CSP first
388 * then try the machine default CSP
389 */
390 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, TRUE)) ) {
391 TRACE("No provider registered for crypto provider type %ld.\n", dwProvType);
392 SetLastError(NTE_PROV_TYPE_NOT_DEF);
393 return FALSE;
394 }
395 if (RegOpenKeyW(HKEY_CURRENT_USER, keyname, &key))
396 {
397 CRYPT_Free(keyname);
398 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, FALSE)) ) {
399 TRACE("No type registered for crypto provider type %ld.\n", dwProvType);
400 RegCloseKey(key);
401 SetLastError(NTE_PROV_TYPE_NOT_DEF);
402 goto error;
403 }
404 if (RegOpenKeyW(HKEY_LOCAL_MACHINE, keyname, &key)) {
405 TRACE("Did not find registry entry of crypto provider for %s.\n", debugstr_w(keyname));
406 CRYPT_Free(keyname);
407 RegCloseKey(key);
408 SetLastError(NTE_PROV_TYPE_NOT_DEF);
409 goto error;
410 }
411 }
412 CRYPT_Free(keyname);
413 r = RegQueryValueExW(key, L"Name", NULL, &keytype, NULL, &len);
414 if( r != ERROR_SUCCESS || !len || keytype != REG_SZ)
415 {
416 TRACE("error %ld reading size of 'Name' from registry\n", r );
417 RegCloseKey(key);
418 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
419 goto error;
420 }
421 if(!(provname = CRYPT_Alloc(len)))
422 {
423 RegCloseKey(key);
424 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
425 goto error;
426 }
427 r = RegQueryValueExW(key, L"Name", NULL, NULL, (LPBYTE)provname, &len);
428 if( r != ERROR_SUCCESS )
429 {
430 TRACE("error %ld reading 'Name' from registry\n", r );
431 RegCloseKey(key);
432 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
433 goto error;
434 }
435 RegCloseKey(key);
436 } else {
437 if ( !(provname = CRYPT_Alloc((lstrlenW(pszProvider) +1)*sizeof(WCHAR))) )
438 {
439 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
440 goto error;
441 }
442 lstrcpyW(provname, pszProvider);
443 }
444
445 keyname = CRYPT_GetProvKeyName(provname);
446 r = RegOpenKeyW(HKEY_LOCAL_MACHINE, keyname, &key);
447 CRYPT_Free(keyname);
448 if (r != ERROR_SUCCESS)
449 {
450 SetLastError(NTE_KEYSET_NOT_DEF);
451 goto error;
452 }
453 len = sizeof(DWORD);
454 r = RegQueryValueExW(key, L"Type", NULL, NULL, (BYTE*)&type, &len);
455 if (r != ERROR_SUCCESS)
456 {
457 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
458 goto error;
459 }
460 if (type != dwProvType)
461 {
462 TRACE("Crypto provider has wrong type (%ld vs expected %ld).\n", type, dwProvType);
463 SetLastError(NTE_PROV_TYPE_NO_MATCH);
464 goto error;
465 }
466
467 r = RegQueryValueExW(key, L"Image Path", NULL, &keytype, NULL, &len);
468 if ( r != ERROR_SUCCESS || keytype != REG_SZ)
469 {
470 TRACE("error %ld reading size of 'Image Path' from registry\n", r );
471 RegCloseKey(key);
472 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
473 goto error;
474 }
475 if (!(temp = CRYPT_Alloc(len)))
476 {
477 RegCloseKey(key);
478 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
479 goto error;
480 }
481 r = RegQueryValueExW(key, L"Image Path", NULL, NULL, (LPBYTE)temp, &len);
482 if( r != ERROR_SUCCESS )
483 {
484 TRACE("error %ld reading 'Image Path' from registry\n", r );
485 RegCloseKey(key);
486 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
487 goto error;
488 }
489 RegCloseKey(key);
490 len = ExpandEnvironmentStringsW(temp, NULL, 0);
491 if ( !(imagepath = CRYPT_Alloc(len*sizeof(WCHAR))) )
492 {
493 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
494 goto error;
495 }
496 if (!ExpandEnvironmentStringsW(temp, imagepath, len))
497 {
498 /* ExpandEnvironmentStrings will call SetLastError */
499 goto error;
500 }
501 pProv = CRYPT_LoadProvider(imagepath);
502 if (!pProv) {
503 /* CRYPT_LoadProvider calls SetLastError */
504 goto error;
505 }
506 pProv->pVTable->dwProvType = dwProvType;
507 if(!CRYPT_UnicodeToANSI(provname, &provnameA, 0))
508 {
509 /* CRYPT_UnicodeToANSI calls SetLastError */
510 goto error;
511 }
512 pProv->pVTable->pszProvName = provnameA;
513 if(!CRYPT_UnicodeToANSI(pszContainer, &pszContainerA, 0))
514 {
515 /* CRYPT_UnicodeToANSI calls SetLastError */
516 goto error;
517 }
518 if (pProv->pFuncs->pCPAcquireContext(&pProv->hPrivate, pszContainerA, dwFlags, pProv->pVTable))
519 {
520 /* MSDN: When this flag is set, the value returned in phProv is undefined,
521 * and thus, the CryptReleaseContext function need not be called afterwards.
522 * Therefore, we must clean up everything now.
523 */
524 if (dwFlags & CRYPT_DELETEKEYSET)
525 {
526 *phProv = 0;
527 pProv->dwMagic = 0;
528 FreeLibrary(pProv->hModule);
529 CRYPT_Free(provnameA);
530 CRYPT_Free(pProv->pVTable);
531 CRYPT_Free(pProv->pFuncs);
532 CRYPT_Free(pProv);
533 } else {
534 *phProv = (HCRYPTPROV)pProv;
535 }
536 CRYPT_Free(pszContainerA);
537 CRYPT_Free(provname);
538 CRYPT_Free(temp);
539 CRYPT_Free(imagepath);
540 return TRUE;
541 }
542 /* FALLTHROUGH TO ERROR IF FALSE - CSP internal error! */
543 error:
544 if (pProv)
545 {
546 pProv->dwMagic = 0;
547 if (pProv->hModule)
548 FreeLibrary(pProv->hModule);
549 CRYPT_Free(pProv->pVTable);
550 CRYPT_Free(pProv->pFuncs);
551 CRYPT_Free(pProv);
552 }
553 CRYPT_Free(pszContainerA);
554 CRYPT_Free(provnameA);
555 CRYPT_Free(provname);
556 CRYPT_Free(temp);
557 CRYPT_Free(imagepath);
558 return FALSE;
559 }
560
561 /******************************************************************************
562 * CryptAcquireContextA (ADVAPI32.@)
563 *
564 * See CryptAcquireContextW.
565 */
566 BOOL WINAPI CryptAcquireContextA (HCRYPTPROV *phProv, LPCSTR pszContainer,
567 LPCSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
568 {
569 PWSTR pProvider = NULL, pContainer = NULL;
570 BOOL ret = FALSE;
571
572 TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv, debugstr_a(pszContainer),
573 debugstr_a(pszProvider), dwProvType, dwFlags);
574
575 if ( !CRYPT_ANSIToUnicode(pszContainer, &pContainer, -1) )
576 {
577 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
578 return FALSE;
579 }
580 if ( !CRYPT_ANSIToUnicode(pszProvider, &pProvider, -1) )
581 {
582 CRYPT_Free(pContainer);
583 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
584 return FALSE;
585 }
586
587 ret = CryptAcquireContextW(phProv, pContainer, pProvider, dwProvType, dwFlags);
588
589 CRYPT_Free(pContainer);
590 CRYPT_Free(pProvider);
591
592 return ret;
593 }
594
595 /******************************************************************************
596 * CryptContextAddRef (ADVAPI32.@)
597 *
598 * Increases reference count of a cryptographic service provider handle
599 * by one.
600 *
601 * PARAMS
602 * hProv [I] Handle to the CSP whose reference is being incremented.
603 * pdwReserved [IN] Reserved for future use and must be NULL.
604 * dwFlags [I] Reserved for future use and must be 0.
605 *
606 * RETURNS
607 * Success: TRUE
608 * Failure: FALSE
609 */
610 BOOL WINAPI CryptContextAddRef (HCRYPTPROV hProv, DWORD *pdwReserved, DWORD dwFlags)
611 {
612 PCRYPTPROV pProv = provider_from_handle(hProv);
613
614 TRACE("(0x%Ix, %p, %08lx)\n", hProv, pdwReserved, dwFlags);
615
616 if (!pProv)
617 return FALSE;
618
619 InterlockedIncrement(&pProv->refcount);
620 return TRUE;
621 }
622
623 /******************************************************************************
624 * CryptReleaseContext (ADVAPI32.@)
625 *
626 * Releases the handle of a CSP. Reference count is decreased.
627 *
628 * PARAMS
629 * hProv [I] Handle of a CSP.
630 * dwFlags [I] Reserved for future use and must be 0.
631 *
632 * RETURNS
633 * Success: TRUE
634 * Failure: FALSE
635 */
636 BOOL WINAPI CryptReleaseContext (HCRYPTPROV hProv, DWORD dwFlags)
637 {
638 PCRYPTPROV pProv = provider_from_handle(hProv);
639 BOOL ret = TRUE;
640
641 TRACE("(0x%Ix, %08lx)\n", hProv, dwFlags);
642
643 if (!pProv)
644 return FALSE;
645
646 if (InterlockedDecrement(&pProv->refcount) == 0)
647 {
648 ret = pProv->pFuncs->pCPReleaseContext(pProv->hPrivate, dwFlags);
649 pProv->dwMagic = 0;
650 FreeLibrary(pProv->hModule);
651 #if 0
652 CRYPT_Free(pProv->pVTable->pContextInfo);
653 #endif
654 CRYPT_Free(pProv->pVTable->pszProvName);
655 CRYPT_Free(pProv->pVTable);
656 CRYPT_Free(pProv->pFuncs);
657 CRYPT_Free(pProv);
658 }
659 return ret;
660 }
661
662 /******************************************************************************
663 * CryptGenRandom (ADVAPI32.@)
664 *
665 * Fills a buffer with cryptographically random bytes.
666 *
667 * PARAMS
668 * hProv [I] Handle of a CSP.
669 * dwLen [I] Number of bytes to generate.
670 * pbBuffer [I/O] Buffer to contain random bytes.
671 *
672 * RETURNS
673 * Success: TRUE
674 * Failure: FALSE
675 *
676 * NOTES
677 * pdBuffer must be at least dwLen bytes long.
678 */
679 BOOL WINAPI CryptGenRandom (HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer)
680 {
681 PCRYPTPROV prov = provider_from_handle(hProv);
682
683 TRACE("(0x%Ix, %ld, %p)\n", hProv, dwLen, pbBuffer);
684
685 if (!prov)
686 return FALSE;
687
688 return prov->pFuncs->pCPGenRandom(prov->hPrivate, dwLen, pbBuffer);
689 }
690
691 /******************************************************************************
692 * CryptCreateHash (ADVAPI32.@)
693 *
694 * Initiates the hashing of a stream of data.
695 *
696 * PARAMS
697 * hProv [I] Handle of a CSP.
698 * Algid [I] Identifies the hash algorithm to use.
699 * hKey [I] Key for the hash (if required).
700 * dwFlags [I] Reserved for future use and must be 0.
701 * phHash [O] Address of the future handle to the new hash object.
702 *
703 * RETURNS
704 * Success: TRUE
705 * Failure: FALSE
706 *
707 * NOTES
708 * If the algorithm is a keyed hash, hKey is the key.
709 */
710 BOOL WINAPI CryptCreateHash (HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey,
711 DWORD dwFlags, HCRYPTHASH *phHash)
712 {
713 PCRYPTKEY key = NULL;
714 PCRYPTPROV prov;
715 PCRYPTHASH hash;
716
717 TRACE("(0x%Ix, 0x%x, 0x%Ix, %08lx, %p)\n", hProv, Algid, hKey, dwFlags, phHash);
718
719 if (!(prov = provider_from_handle(hProv)))
720 return FALSE;
721
722 if (hKey && !(key = key_from_handle(hKey)))
723 return FALSE;
724
725 if (!phHash)
726 {
727 SetLastError(ERROR_INVALID_PARAMETER);
728 return FALSE;
729 }
730 if (dwFlags)
731 {
732 SetLastError(NTE_BAD_FLAGS);
733 return FALSE;
734 }
735 if ( !(hash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
736 {
737 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
738 return FALSE;
739 }
740
741 hash->pProvider = prov;
742 hash->dwMagic = MAGIC_CRYPTHASH;
743 if (prov->pFuncs->pCPCreateHash(prov->hPrivate, Algid,
744 key ? key->hPrivate : 0, 0, &hash->hPrivate))
745 {
746 *phHash = (HCRYPTHASH)hash;
747 return TRUE;
748 }
749
750 /* CSP error! */
751 hash->dwMagic = 0;
752 CRYPT_Free(hash);
753 *phHash = 0;
754 return FALSE;
755 }
756
757 /******************************************************************************
758 * CryptDecrypt (ADVAPI32.@)
759 *
760 * Decrypts data encrypted by CryptEncrypt.
761 *
762 * PARAMS
763 * hKey [I] Handle to the decryption key.
764 * hHash [I] Handle to a hash object.
765 * Final [I] TRUE if this is the last section to be decrypted.
766 * dwFlags [I] Reserved for future use. Can be CRYPT_OAEP.
767 * pbData [I/O] Buffer that holds the encrypted data. Holds decrypted
768 * data on return
769 * pdwDataLen [I/O] Length of pbData before and after the call.
770 *
771 * RETURNS
772 * Success: TRUE
773 * Failure: FALSE
774 */
775 BOOL WINAPI CryptDecrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final,
776 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
777 {
778 PCRYPTHASH hash = NULL;
779 PCRYPTPROV prov;
780 PCRYPTKEY key;
781
782 TRACE("(0x%Ix, 0x%Ix, %d, %08lx, %p, %p)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen);
783
784 if (!(key = key_from_handle(hKey)))
785 return FALSE;
786
787 if (hHash && !(hash = hash_from_handle(hHash)))
788 return FALSE;
789
790 if (!pbData || !pdwDataLen || !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
791 {
792 SetLastError(ERROR_INVALID_PARAMETER);
793 return FALSE;
794 }
795
796 prov = key->pProvider;
797 return prov->pFuncs->pCPDecrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
798 Final, dwFlags, pbData, pdwDataLen);
799 }
800
801 /******************************************************************************
802 * CryptDeriveKey (ADVAPI32.@)
803 *
804 * Generates session keys derived from a base data value.
805 *
806 * PARAMS
807 * hProv [I] Handle to a CSP.
808 * Algid [I] Identifies the symmetric encryption algorithm to use.
809 * hBaseData [I] Handle to a hash object.
810 * dwFlags [I] Type of key to generate.
811 * phKey [I/O] Address of the newly generated key.
812 *
813 * RETURNS
814 * Success: TRUE
815 * Failure: FALSE
816 */
817 BOOL WINAPI CryptDeriveKey (HCRYPTPROV hProv, ALG_ID Algid, HCRYPTHASH hBaseData,
818 DWORD dwFlags, HCRYPTKEY *phKey)
819 {
820 PCRYPTPROV prov;
821 PCRYPTHASH hash;
822 PCRYPTKEY key;
823
824 TRACE("(0x%Ix, 0x%08x, 0x%Ix, 0x%08lx, %p)\n", hProv, Algid, hBaseData, dwFlags, phKey);
825
826 if (!(prov = provider_from_handle(hProv)))
827 return FALSE;
828
829 if (!(hash = hash_from_handle(hBaseData)))
830 return FALSE;
831
832 if (!phKey)
833 {
834 SetLastError(ERROR_INVALID_PARAMETER);
835 return FALSE;
836 }
837 if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
838 {
839 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
840 return FALSE;
841 }
842
843 key->pProvider = prov;
844 key->dwMagic = MAGIC_CRYPTKEY;
845 if (prov->pFuncs->pCPDeriveKey(prov->hPrivate, Algid, hash->hPrivate, dwFlags, &key->hPrivate))
846 {
847 *phKey = (HCRYPTKEY)key;
848 return TRUE;
849 }
850
851 /* CSP error! */
852 key->dwMagic = 0;
853 CRYPT_Free(key);
854 *phKey = 0;
855 return FALSE;
856 }
857
858 /******************************************************************************
859 * CryptDestroyHash (ADVAPI32.@)
860 *
861 * Destroys the hash object referenced by hHash.
862 *
863 * PARAMS
864 * hHash [I] Handle of the hash object to be destroyed.
865 *
866 * RETURNS
867 * Success: TRUE
868 * Failure: FALSE
869 */
870 BOOL WINAPI CryptDestroyHash (HCRYPTHASH hHash)
871 {
872 PCRYPTHASH hash;
873 PCRYPTPROV prov;
874 BOOL ret;
875
876 TRACE("(0x%Ix)\n", hHash);
877
878 if (!(hash = hash_from_handle(hHash)))
879 return FALSE;
880
881 if (!hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
882 {
883 SetLastError(ERROR_INVALID_PARAMETER);
884 return FALSE;
885 }
886
887 prov = hash->pProvider;
888 ret = prov->pFuncs->pCPDestroyHash(prov->hPrivate, hash->hPrivate);
889 hash->dwMagic = 0;
890 CRYPT_Free(hash);
891 return ret;
892 }
893
894 /******************************************************************************
895 * CryptDestroyKey (ADVAPI32.@)
896 *
897 * Releases the handle referenced by hKey.
898 *
899 * PARAMS
900 * hKey [I] Handle of the key to be destroyed.
901 *
902 * RETURNS
903 * Success: TRUE
904 * Failure: FALSE
905 */
906 BOOL WINAPI CryptDestroyKey (HCRYPTKEY hKey)
907 {
908 PCRYPTPROV prov;
909 PCRYPTKEY key;
910 BOOL ret;
911
912 TRACE("(0x%Ix)\n", hKey);
913
914 if (!(key = key_from_handle(hKey)))
915 return FALSE;
916
917 if (!key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
918 {
919 SetLastError(ERROR_INVALID_PARAMETER);
920 return FALSE;
921 }
922
923 prov = key->pProvider;
924 ret = prov->pFuncs->pCPDestroyKey(prov->hPrivate, key->hPrivate);
925 key->dwMagic = 0;
926 CRYPT_Free(key);
927 return ret;
928 }
929
930 /******************************************************************************
931 * CryptDuplicateHash (ADVAPI32.@)
932 *
933 * Duplicates a hash.
934 *
935 * PARAMS
936 * hHash [I] Handle to the hash to be copied.
937 * pdwReserved [I] Reserved for future use and must be NULL.
938 * dwFlags [I] Reserved for future use and must be zero.
939 * phHash [O] Address of the handle to receive the copy.
940 *
941 * RETURNS
942 * Success: TRUE
943 * Failure: FALSE
944 */
945 BOOL WINAPI CryptDuplicateHash (HCRYPTHASH hHash, DWORD *pdwReserved,
946 DWORD dwFlags, HCRYPTHASH *phHash)
947 {
948 PCRYPTPROV prov;
949 PCRYPTHASH orghash, newhash;
950
951 TRACE("(0x%Ix, %p, %08lx, %p)\n", hHash, pdwReserved, dwFlags, phHash);
952
953 if (!(orghash = hash_from_handle(hHash)))
954 return FALSE;
955
956 if (pdwReserved || !phHash || !orghash->pProvider || orghash->pProvider->dwMagic != MAGIC_CRYPTPROV)
957 {
958 SetLastError(ERROR_INVALID_PARAMETER);
959 return FALSE;
960 }
961
962 prov = orghash->pProvider;
963 if (!prov->pFuncs->pCPDuplicateHash)
964 {
965 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
966 return FALSE;
967 }
968
969 if ( !(newhash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
970 {
971 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
972 return FALSE;
973 }
974
975 newhash->pProvider = prov;
976 newhash->dwMagic = MAGIC_CRYPTHASH;
977 if (prov->pFuncs->pCPDuplicateHash(prov->hPrivate, orghash->hPrivate, pdwReserved, dwFlags, &newhash->hPrivate))
978 {
979 *phHash = (HCRYPTHASH)newhash;
980 return TRUE;
981 }
982 newhash->dwMagic = 0;
983 CRYPT_Free(newhash);
984 return FALSE;
985 }
986
987 /******************************************************************************
988 * CryptDuplicateKey (ADVAPI32.@)
989 *
990 * Duplicate a key and the key's state.
991 *
992 * PARAMS
993 * hKey [I] Handle of the key to copy.
994 * pdwReserved [I] Reserved for future use and must be NULL.
995 * dwFlags [I] Reserved for future use and must be zero.
996 * phKey [I] Address of the handle to the duplicated key.
997 *
998 * RETURNS
999 * Success: TRUE
1000 * Failure: FALSE
1001 */
1002 BOOL WINAPI CryptDuplicateKey (HCRYPTKEY hKey, DWORD *pdwReserved, DWORD dwFlags, HCRYPTKEY *phKey)
1003 {
1004 PCRYPTPROV prov;
1005 PCRYPTKEY orgkey, newkey;
1006
1007 TRACE("(0x%Ix, %p, %08lx, %p)\n", hKey, pdwReserved, dwFlags, phKey);
1008
1009 if (!(orgkey = key_from_handle(hKey)))
1010 return FALSE;
1011
1012 if (pdwReserved || !phKey || !orgkey->pProvider || orgkey->pProvider->dwMagic != MAGIC_CRYPTPROV)
1013 {
1014 SetLastError(ERROR_INVALID_PARAMETER);
1015 return FALSE;
1016 }
1017
1018 prov = orgkey->pProvider;
1019 if (!prov->pFuncs->pCPDuplicateKey)
1020 {
1021 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1022 return FALSE;
1023 }
1024
1025 if ( !(newkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
1026 {
1027 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1028 return FALSE;
1029 }
1030
1031 newkey->pProvider = prov;
1032 newkey->dwMagic = MAGIC_CRYPTKEY;
1033 if (prov->pFuncs->pCPDuplicateKey(prov->hPrivate, orgkey->hPrivate, pdwReserved, dwFlags, &newkey->hPrivate))
1034 {
1035 *phKey = (HCRYPTKEY)newkey;
1036 return TRUE;
1037 }
1038 newkey->dwMagic = 0;
1039 CRYPT_Free(newkey);
1040 return FALSE;
1041 }
1042
1043 /******************************************************************************
1044 * CryptEncrypt (ADVAPI32.@)
1045 *
1046 * Encrypts data.
1047 *
1048 * PARAMS
1049 * hKey [I] Handle to the encryption key.
1050 * hHash [I] Handle to a hash object.
1051 * Final [I] TRUE if this is the last section to encrypt.
1052 * dwFlags [I] Can be CRYPT_OAEP.
1053 * pbData [I/O] Data to be encrypted. Contains encrypted data after call.
1054 * pdwDataLen [I/O] Length of the data to encrypt. Contains the length of the
1055 * encrypted data after call.
1056 * dwBufLen [I] Length of the input pbData buffer.
1057 *
1058 * RETURNS
1059 * Success: TRUE
1060 * Failure: FALSE
1061 *
1062 * NOTES
1063 * If pbData is NULL, CryptEncrypt determines stores the number of bytes
1064 * required for the returned data in pdwDataLen.
1065 */
1066 BOOL WINAPI CryptEncrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final,
1067 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen)
1068 {
1069 PCRYPTHASH hash = NULL;
1070 PCRYPTPROV prov;
1071 PCRYPTKEY key;
1072
1073 TRACE("(0x%Ix, 0x%Ix, %d, %08lx, %p, %p, %ld)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen, dwBufLen);
1074
1075 if (!(key = key_from_handle(hKey)))
1076 return FALSE;
1077
1078 if (hHash && !(hash = hash_from_handle(hHash)))
1079 return FALSE;
1080
1081 if (!pdwDataLen || !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
1082 {
1083 SetLastError(ERROR_INVALID_PARAMETER);
1084 return FALSE;
1085 }
1086
1087 prov = key->pProvider;
1088 return prov->pFuncs->pCPEncrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
1089 Final, dwFlags, pbData, pdwDataLen, dwBufLen);
1090 }
1091
1092 /******************************************************************************
1093 * CryptEnumProvidersW (ADVAPI32.@)
1094 *
1095 * Returns the next available CSP.
1096 *
1097 * PARAMS
1098 * dwIndex [I] Index of the next provider to be enumerated.
1099 * pdwReserved [I] Reserved for future use and must be NULL.
1100 * dwFlags [I] Reserved for future use and must be zero.
1101 * pdwProvType [O] DWORD designating the type of the provider.
1102 * pszProvName [O] Buffer that receives data from the provider.
1103 * pcbProvName [I/O] Specifies the size of pszProvName. Contains the number
1104 * of bytes stored in the buffer on return.
1105 *
1106 * RETURNS
1107 * Success: TRUE
1108 * Failure: FALSE
1109 *
1110 * NOTES
1111 * If pszProvName is NULL, CryptEnumProvidersW sets the size of the name
1112 * for memory allocation purposes.
1113 */
1114 BOOL WINAPI CryptEnumProvidersW (DWORD dwIndex, DWORD *pdwReserved,
1115 DWORD dwFlags, DWORD *pdwProvType, LPWSTR pszProvName, DWORD *pcbProvName)
1116 {
1117 HKEY hKey;
1118 BOOL ret;
1119
1120 TRACE("(%ld, %p, %ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
1121 pdwProvType, pszProvName, pcbProvName);
1122
1123 if (pdwReserved || !pcbProvName)
1124 {
1125 SetLastError(ERROR_INVALID_PARAMETER);
1126 return FALSE;
1127 }
1128 if (dwFlags)
1129 {
1130 SetLastError(NTE_BAD_FLAGS);
1131 return FALSE;
1132 }
1133
1134 if (RegOpenKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Cryptography\\Defaults\\Provider", &hKey))
1135 {
1136 SetLastError(NTE_FAIL);
1137 return FALSE;
1138 }
1139
1140 ret = TRUE;
1141 if (!pszProvName)
1142 {
1143 DWORD numkeys;
1144 WCHAR *provNameW;
1145
1146 RegQueryInfoKeyW(hKey, NULL, NULL, NULL, &numkeys, pcbProvName,
1147 NULL, NULL, NULL, NULL, NULL, NULL);
1148
1149 if (!(provNameW = CRYPT_Alloc(*pcbProvName * sizeof(WCHAR))))
1150 {
1151 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1152 RegCloseKey(hKey);
1153 return FALSE;
1154 }
1155
1156 RegEnumKeyExW(hKey, dwIndex, provNameW, pcbProvName, NULL, NULL, NULL, NULL);
1157 CRYPT_Free(provNameW);
1158 (*pcbProvName)++;
1159 *pcbProvName *= sizeof(WCHAR);
1160
1161 if (dwIndex >= numkeys)
1162 {
1163 SetLastError(ERROR_NO_MORE_ITEMS);
1164 ret = FALSE;
1165 }
1166 } else {
1167 DWORD size = sizeof(DWORD);
1168 DWORD result;
1169 HKEY subkey;
1170
1171 result = RegEnumKeyW(hKey, dwIndex, pszProvName, *pcbProvName / sizeof(WCHAR));
1172 if (result)
1173 {
1174 SetLastError(result);
1175 RegCloseKey(hKey);
1176 return FALSE;
1177 }
1178 if (RegOpenKeyW(hKey, pszProvName, &subkey))
1179 {
1180 RegCloseKey(hKey);
1181 return FALSE;
1182 }
1183
1184 if (RegQueryValueExW(subkey, L"Type", NULL, NULL, (BYTE*)pdwProvType, &size))
1185 ret = FALSE;
1186
1187 RegCloseKey(subkey);
1188 }
1189 RegCloseKey(hKey);
1190 return ret;
1191 }
1192
1193 /******************************************************************************
1194 * CryptEnumProvidersA (ADVAPI32.@)
1195 *
1196 * See CryptEnumProvidersW.
1197 */
1198 BOOL WINAPI CryptEnumProvidersA (DWORD dwIndex, DWORD *pdwReserved,
1199 DWORD dwFlags, DWORD *pdwProvType, LPSTR pszProvName, DWORD *pcbProvName)
1200 {
1201 PWSTR str = NULL;
1202 DWORD bufsize;
1203 BOOL ret;
1204
1205 TRACE("(%ld, %p, %08lx, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
1206 pdwProvType, pszProvName, pcbProvName);
1207
1208 if(!CryptEnumProvidersW(dwIndex, pdwReserved, dwFlags, pdwProvType, NULL, &bufsize))
1209 return FALSE;
1210 if ( pszProvName && !(str = CRYPT_Alloc(bufsize)) )
1211 {
1212 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1213 return FALSE;
1214 }
1215 ret = CryptEnumProvidersW(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &bufsize);
1216 if (str)
1217 CRYPT_UnicodeToANSI(str, &pszProvName, *pcbProvName);
1218 *pcbProvName = bufsize / sizeof(WCHAR); /* FIXME: not correct */
1219 if (str)
1220 {
1221 CRYPT_Free(str);
1222 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1223 {
1224 SetLastError(ERROR_MORE_DATA);
1225 return FALSE;
1226 }
1227 }
1228 return ret;
1229 }
1230
1231 /******************************************************************************
1232 * CryptEnumProviderTypesW (ADVAPI32.@)
1233 *
1234 * Retrieves the next type of CSP supported.
1235 *
1236 * PARAMS
1237 * dwIndex [I] Index of the next provider to be enumerated.
1238 * pdwReserved [I] Reserved for future use and must be NULL.
1239 * dwFlags [I] Reserved for future use and must be zero.
1240 * pdwProvType [O] DWORD designating the type of the provider.
1241 * pszTypeName [O] Buffer that receives data from the provider type.
1242 * pcbTypeName [I/O] Specifies the size of pszTypeName. Contains the number
1243 * of bytes stored in the buffer on return.
1244 *
1245 * RETURNS
1246 * Success: TRUE
1247 * Failure: FALSE
1248 *
1249 * NOTES
1250 * If pszTypeName is NULL, CryptEnumProviderTypesW sets the size of the name
1251 * for memory allocation purposes.
1252 */
1253 BOOL WINAPI CryptEnumProviderTypesW (DWORD dwIndex, DWORD *pdwReserved,
1254 DWORD dwFlags, DWORD *pdwProvType, LPWSTR pszTypeName, DWORD *pcbTypeName)
1255 {
1256 HKEY hKey, hSubkey;
1257 DWORD keylen, numkeys, dwType;
1258 PWSTR keyname, ch;
1259 DWORD result;
1260
1261 TRACE("(%ld, %p, %08lx, %p, %p, %p)\n", dwIndex, pdwReserved,
1262 dwFlags, pdwProvType, pszTypeName, pcbTypeName);
1263
1264 if (pdwReserved || !pdwProvType || !pcbTypeName)
1265 {
1266 SetLastError(ERROR_INVALID_PARAMETER);
1267 return FALSE;
1268 }
1269 if (dwFlags)
1270 {
1271 SetLastError(NTE_BAD_FLAGS);
1272 return FALSE;
1273 }
1274
1275 if (RegOpenKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Cryptography\\Defaults\\Provider Types", &hKey))
1276 return FALSE;
1277
1278 RegQueryInfoKeyW(hKey, NULL, NULL, NULL, &numkeys, &keylen, NULL, NULL, NULL, NULL, NULL, NULL);
1279 if (dwIndex >= numkeys)
1280 {
1281 SetLastError(ERROR_NO_MORE_ITEMS);
1282 RegCloseKey(hKey);
1283 return FALSE;
1284 }
1285 keylen++;
1286 if ( !(keyname = CRYPT_Alloc(keylen*sizeof(WCHAR))) )
1287 {
1288 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1289 RegCloseKey(hKey);
1290 return FALSE;
1291 }
1292 if ( RegEnumKeyW(hKey, dwIndex, keyname, keylen) ) {
1293 CRYPT_Free(keyname);
1294 RegCloseKey(hKey);
1295 return FALSE;
1296 }
1297 RegOpenKeyW(hKey, keyname, &hSubkey);
1298 RegCloseKey(hKey);
1299
1300 ch = keyname + lstrlenW(keyname);
1301 /* Convert "Type 000" to 0, etc/ */
1302 *pdwProvType = *(--ch) - '0';
1303 *pdwProvType += (*(--ch) - '0') * 10;
1304 *pdwProvType += (*(--ch) - '0') * 100;
1305 CRYPT_Free(keyname);
1306
1307 result = RegQueryValueExW(hSubkey, L"TypeName", NULL, &dwType, (LPBYTE)pszTypeName, pcbTypeName);
1308 if (result)
1309 {
1310 SetLastError(result);
1311 RegCloseKey(hSubkey);
1312 return FALSE;
1313 }
1314
1315 RegCloseKey(hSubkey);
1316 return TRUE;
1317 }
1318
1319 /******************************************************************************
1320 * CryptEnumProviderTypesA (ADVAPI32.@)
1321 *
1322 * See CryptEnumProviderTypesW.
1323 */
1324 BOOL WINAPI CryptEnumProviderTypesA (DWORD dwIndex, DWORD *pdwReserved,
1325 DWORD dwFlags, DWORD *pdwProvType, LPSTR pszTypeName, DWORD *pcbTypeName)
1326 {
1327 PWSTR str = NULL;
1328 DWORD bufsize;
1329 BOOL ret;
1330
1331 TRACE("(%ld, %p, %08lx, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
1332 pdwProvType, pszTypeName, pcbTypeName);
1333
1334 if(!CryptEnumProviderTypesW(dwIndex, pdwReserved, dwFlags, pdwProvType, NULL, &bufsize))
1335 return FALSE;
1336 if ( pszTypeName && !(str = CRYPT_Alloc(bufsize)) )
1337 {
1338 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1339 return FALSE;
1340 }
1341 ret = CryptEnumProviderTypesW(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &bufsize);
1342 if (str)
1343 CRYPT_UnicodeToANSI(str, &pszTypeName, *pcbTypeName);
1344 *pcbTypeName = bufsize / sizeof(WCHAR);
1345 if (str)
1346 {
1347 CRYPT_Free(str);
1348 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1349 {
1350 SetLastError(ERROR_MORE_DATA);
1351 return FALSE;
1352 }
1353 }
1354 return ret;
1355 }
1356
1357 /******************************************************************************
1358 * CryptExportKey (ADVAPI32.@)
1359 *
1360 * Exports a cryptographic key from a CSP.
1361 *
1362 * PARAMS
1363 * hKey [I] Handle to the key to export.
1364 * hExpKey [I] Handle to a cryptographic key of the end user.
1365 * dwBlobType [I] Type of BLOB to be exported.
1366 * dwFlags [I] CRYPT_DESTROYKEY/SSL2_FALLBACK/OAEP.
1367 * pbData [O] Buffer to receive BLOB data.
1368 * pdwDataLen [I/O] Specifies the size of pbData.
1369 *
1370 * RETURNS
1371 * Success: TRUE
1372 * Failure: FALSE
1373 *
1374 * NOTES
1375 * if pbData is NULL, CryptExportKey sets pdwDataLen as the size of the
1376 * buffer needed to hold the BLOB.
1377 */
1378 BOOL WINAPI CryptExportKey (HCRYPTKEY hKey, HCRYPTKEY hExpKey, DWORD dwBlobType,
1379 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
1380 {
1381 PCRYPTPROV prov;
1382 PCRYPTKEY key, expkey = NULL;
1383
1384 TRACE("(0x%Ix, 0x%Ix, %ld, %08lx, %p, %p)\n", hKey, hExpKey, dwBlobType, dwFlags, pbData, pdwDataLen);
1385
1386 if (!(key = key_from_handle(hKey)))
1387 return FALSE;
1388
1389 if (hExpKey && !(expkey = key_from_handle(hExpKey)))
1390 return FALSE;
1391
1392 if (!pdwDataLen || !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
1393 {
1394 SetLastError(ERROR_INVALID_PARAMETER);
1395 return FALSE;
1396 }
1397
1398 prov = key->pProvider;
1399 return prov->pFuncs->pCPExportKey(prov->hPrivate, key->hPrivate, expkey ? expkey->hPrivate : 0,
1400 dwBlobType, dwFlags, pbData, pdwDataLen);
1401 }
1402
1403 /******************************************************************************
1404 * CryptGenKey (ADVAPI32.@)
1405 *
1406 * Generates a random cryptographic session key or a pub/priv key pair.
1407 *
1408 * PARAMS
1409 * hProv [I] Handle to a CSP.
1410 * Algid [I] Algorithm to use to make key.
1411 * dwFlags [I] Specifies type of key to make.
1412 * phKey [I] Address of the handle to which the new key is copied.
1413 *
1414 * RETURNS
1415 * Success: TRUE
1416 * Failure: FALSE
1417 */
1418 BOOL WINAPI CryptGenKey (HCRYPTPROV hProv, ALG_ID Algid, DWORD dwFlags, HCRYPTKEY *phKey)
1419 {
1420 PCRYPTPROV prov;
1421 PCRYPTKEY key;
1422
1423 TRACE("(0x%Ix, %d, %08lx, %p)\n", hProv, Algid, dwFlags, phKey);
1424
1425 if (!(prov = provider_from_handle(hProv)))
1426 return FALSE;
1427
1428 if (!phKey)
1429 {
1430 SetLastError(ERROR_INVALID_PARAMETER);
1431 return FALSE;
1432 }
1433 if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
1434 {
1435 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1436 return FALSE;
1437 }
1438
1439 key->pProvider = prov;
1440 key->dwMagic = MAGIC_CRYPTKEY;
1441 if (prov->pFuncs->pCPGenKey(prov->hPrivate, Algid, dwFlags, &key->hPrivate))
1442 {
1443 *phKey = (HCRYPTKEY)key;
1444 return TRUE;
1445 }
1446
1447 /* CSP error! */
1448 key->dwMagic = 0;
1449 CRYPT_Free(key);
1450 return FALSE;
1451 }
1452
1453 /******************************************************************************
1454 * CryptGetDefaultProviderW (ADVAPI32.@)
1455 *
1456 * Finds the default CSP of a certain provider type.
1457 *
1458 * PARAMS
1459 * dwProvType [I] Provider type to look for.
1460 * pdwReserved [I] Reserved for future use and must be NULL.
1461 * dwFlags [I] CRYPT_MACHINE_DEFAULT/USER_DEFAULT
1462 * pszProvName [O] Name of the default CSP.
1463 * pcbProvName [I/O] Size of pszProvName
1464 *
1465 * RETURNS
1466 * Success: TRUE
1467 * Failure: FALSE
1468 *
1469 * NOTES
1470 * If pszProvName is NULL, pcbProvName will hold the size of the buffer for
1471 * memory allocation purposes on return.
1472 */
1473 BOOL WINAPI CryptGetDefaultProviderW (DWORD dwProvType, DWORD *pdwReserved,
1474 DWORD dwFlags, LPWSTR pszProvName, DWORD *pcbProvName)
1475 {
1476 HKEY hKey;
1477 PWSTR keyname;
1478 DWORD result;
1479
1480 if (pdwReserved || !pcbProvName)
1481 {
1482 SetLastError(ERROR_INVALID_PARAMETER);
1483 return FALSE;
1484 }
1485 if (dwFlags & ~(CRYPT_USER_DEFAULT | CRYPT_MACHINE_DEFAULT))
1486 {
1487 SetLastError(NTE_BAD_FLAGS);
1488 return FALSE;
1489 }
1490 if (dwProvType > 999)
1491 {
1492 SetLastError(NTE_BAD_PROV_TYPE);
1493 return FALSE;
1494 }
1495 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)) )
1496 {
1497 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1498 return FALSE;
1499 }
1500 if (RegOpenKeyW((dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE ,keyname, &hKey))
1501 {
1502 CRYPT_Free(keyname);
1503 SetLastError(NTE_PROV_TYPE_NOT_DEF);
1504 return FALSE;
1505 }
1506 CRYPT_Free(keyname);
1507
1508 result = RegQueryValueExW(hKey, L"Name", NULL, NULL, (LPBYTE)pszProvName, pcbProvName);
1509 RegCloseKey(hKey);
1510
1511 if (result)
1512 {
1513 if (result != ERROR_MORE_DATA)
1514 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
1515 else
1516 SetLastError(result);
1517
1518 return FALSE;
1519 }
1520
1521 return TRUE;
1522 }
1523
1524 /******************************************************************************
1525 * CryptGetDefaultProviderA (ADVAPI32.@)
1526 *
1527 * See CryptGetDefaultProviderW.
1528 */
1529 BOOL WINAPI CryptGetDefaultProviderA (DWORD dwProvType, DWORD *pdwReserved,
1530 DWORD dwFlags, LPSTR pszProvName, DWORD *pcbProvName)
1531 {
1532 PWSTR str = NULL;
1533 DWORD bufsize;
1534 BOOL ret;
1535
1536 TRACE("(%ld, %p, %08lx, %p, %p)\n", dwProvType, pdwReserved, dwFlags, pszProvName, pcbProvName);
1537
1538 CryptGetDefaultProviderW(dwProvType, pdwReserved, dwFlags, NULL, &bufsize);
1539 if ( pszProvName && !(str = CRYPT_Alloc(bufsize)) )
1540 {
1541 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1542 return FALSE;
1543 }
1544 ret = CryptGetDefaultProviderW(dwProvType, pdwReserved, dwFlags, str, &bufsize);
1545 if (str)
1546 CRYPT_UnicodeToANSI(str, &pszProvName, *pcbProvName);
1547 *pcbProvName = bufsize / sizeof(WCHAR);
1548 if (str)
1549 {
1550 CRYPT_Free(str);
1551 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1552 {
1553 SetLastError(ERROR_MORE_DATA);
1554 return FALSE;
1555 }
1556 }
1557 return ret;
1558 }
1559
1560 /******************************************************************************
1561 * CryptGetHashParam (ADVAPI32.@)
1562 *
1563 * Retrieves data that controls the operations of a hash object.
1564 *
1565 * PARAMS
1566 * hHash [I] Handle of the hash object to question.
1567 * dwParam [I] Query type.
1568 * pbData [O] Buffer that receives the value data.
1569 * pdwDataLen [I/O] Size of the pbData buffer.
1570 * dwFlags [I] Reserved for future use and must be zero.
1571 *
1572 * RETURNS
1573 * Success: TRUE
1574 * Failure: FALSE
1575 *
1576 * NOTES
1577 * If pbData is NULL, pdwDataLen will contain the length required.
1578 */
1579 BOOL WINAPI CryptGetHashParam (HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData,
1580 DWORD *pdwDataLen, DWORD dwFlags)
1581 {
1582 PCRYPTPROV prov;
1583 PCRYPTHASH hash;
1584
1585 TRACE("(0x%Ix, %ld, %p, %p, %08lx)\n", hHash, dwParam, pbData, pdwDataLen, dwFlags);
1586
1587 if (!(hash = hash_from_handle(hHash)))
1588 return FALSE;
1589
1590
1591 if (!pdwDataLen || !hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
1592 {
1593 SetLastError(ERROR_INVALID_PARAMETER);
1594 return FALSE;
1595 }
1596
1597 prov = hash->pProvider;
1598 return prov->pFuncs->pCPGetHashParam(prov->hPrivate, hash->hPrivate, dwParam,
1599 pbData, pdwDataLen, dwFlags);
1600 }
1601
1602 /******************************************************************************
1603 * CryptGetKeyParam (ADVAPI32.@)
1604 *
1605 * Retrieves data that controls the operations of a key.
1606 *
1607 * PARAMS
1608 * hKey [I] Handle to they key in question.
1609 * dwParam [I] Specifies query type.
1610 * pbData [O] Sequence of bytes to receive data.
1611 * pdwDataLen [I/O] Size of pbData.
1612 * dwFlags [I] Reserved for future use and must be zero.
1613 *
1614 * RETURNS
1615 * Success: TRUE
1616 * Failure: FALSE
1617 *
1618 * NOTES
1619 * If pbData is NULL, pdwDataLen is set to the needed length of the buffer.
1620 */
1621 BOOL WINAPI CryptGetKeyParam (HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData,
1622 DWORD *pdwDataLen, DWORD dwFlags)
1623 {
1624 PCRYPTPROV prov;
1625 PCRYPTKEY key;
1626
1627 TRACE("(0x%Ix, %ld, %p, %p, %08lx)\n", hKey, dwParam, pbData, pdwDataLen, dwFlags);
1628
1629 if (!(key = key_from_handle(hKey)))
1630 return FALSE;
1631
1632 if (!pdwDataLen || !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
1633 {
1634 SetLastError(ERROR_INVALID_PARAMETER);
1635 return FALSE;
1636 }
1637
1638 prov = key->pProvider;
1639 return prov->pFuncs->pCPGetKeyParam(prov->hPrivate, key->hPrivate, dwParam,
1640 pbData, pdwDataLen, dwFlags);
1641 }
1642
1643 /******************************************************************************
1644 * CryptGetProvParam (ADVAPI32.@)
1645 *
1646 * Retrieves parameters that control the operations of a CSP.
1647 *
1648 * PARAMS
1649 * hProv [I] Handle of the CSP in question.
1650 * dwParam [I] Specifies query type.
1651 * pbData [O] Buffer to receive the data.
1652 * pdwDataLen [I/O] Size of pbData.
1653 * dwFlags [I] see MSDN Docs.
1654 *
1655 * RETURNS
1656 * Success: TRUE
1657 * Failure: FALSE
1658 *
1659 * NOTES
1660 * If pbData is NULL, pdwDataLen is set to the needed buffer length.
1661 */
1662 BOOL WINAPI CryptGetProvParam (HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData,
1663 DWORD *pdwDataLen, DWORD dwFlags)
1664 {
1665 PCRYPTPROV prov;
1666
1667 TRACE("(0x%Ix, %ld, %p, %p, %08lx)\n", hProv, dwParam, pbData, pdwDataLen, dwFlags);
1668
1669 if (!(prov = provider_from_handle(hProv)))
1670 return FALSE;
1671
1672 return prov->pFuncs->pCPGetProvParam(prov->hPrivate, dwParam, pbData, pdwDataLen, dwFlags);
1673 }
1674
1675 /******************************************************************************
1676 * CryptGetUserKey (ADVAPI32.@)
1677 *
1678 * Gets a handle of one of a user's two public/private key pairs.
1679 *
1680 * PARAMS
1681 * hProv [I] Handle of a CSP.
1682 * dwKeySpec [I] Private key to use.
1683 * phUserKey [O] Pointer to the handle of the retrieved keys.
1684 *
1685 * RETURNS
1686 * Success: TRUE
1687 * Failure: FALSE
1688 */
1689 BOOL WINAPI CryptGetUserKey (HCRYPTPROV hProv, DWORD dwKeySpec, HCRYPTKEY *phUserKey)
1690 {
1691 PCRYPTPROV prov;
1692 PCRYPTKEY key;
1693
1694 TRACE("(0x%Ix, %ld, %p)\n", hProv, dwKeySpec, phUserKey);
1695
1696 if (!(prov = provider_from_handle(hProv)))
1697 return FALSE;
1698
1699 if (!phUserKey)
1700 {
1701 SetLastError(ERROR_INVALID_PARAMETER);
1702 return FALSE;
1703 }
1704 if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
1705 {
1706 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1707 return FALSE;
1708 }
1709
1710 key->pProvider = prov;
1711 key->dwMagic = MAGIC_CRYPTKEY;
1712 if (prov->pFuncs->pCPGetUserKey(prov->hPrivate, dwKeySpec, &key->hPrivate))
1713 {
1714 *phUserKey = (HCRYPTKEY)key;
1715 return TRUE;
1716 }
1717
1718 /* CSP Error */
1719 key->dwMagic = 0;
1720 CRYPT_Free(key);
1721 *phUserKey = 0;
1722 return FALSE;
1723 }
1724
1725 /******************************************************************************
1726 * CryptHashData (ADVAPI32.@)
1727 *
1728 * Adds data to a hash object.
1729 *
1730 * PARAMS
1731 * hHash [I] Handle of the hash object.
1732 * pbData [I] Buffer of data to be hashed.
1733 * dwDataLen [I] Number of bytes to add.
1734 * dwFlags [I] Can be CRYPT_USERDATA
1735 *
1736 * RETURNS
1737 * Success: TRUE
1738 * Failure: FALSE
1739 */
1740 BOOL WINAPI CryptHashData (HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLen, DWORD dwFlags)
1741 {
1742 PCRYPTHASH hash;
1743 PCRYPTPROV prov;
1744
1745 TRACE("(0x%Ix, %p, %ld, %08lx)\n", hHash, pbData, dwDataLen, dwFlags);
1746
1747 if (!(hash = hash_from_handle(hHash)))
1748 return FALSE;
1749
1750 if (!hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
1751 {
1752 SetLastError(ERROR_INVALID_PARAMETER);
1753 return FALSE;
1754 }
1755
1756 prov = hash->pProvider;
1757 return prov->pFuncs->pCPHashData(prov->hPrivate, hash->hPrivate, pbData, dwDataLen, dwFlags);
1758 }
1759
1760 /******************************************************************************
1761 * CryptHashSessionKey (ADVAPI32.@)
1762 *
1763 * Compute the cryptographic hash of a session key object.
1764 *
1765 * PARAMS
1766 * hHash [I] Handle to the hash object.
1767 * hKey [I] Handle to the key to be hashed.
1768 * dwFlags [I] Can be CRYPT_LITTLE_ENDIAN.
1769 *
1770 * RETURNS
1771 * Success: TRUE
1772 * Failure: FALSE
1773 */
1774 BOOL WINAPI CryptHashSessionKey (HCRYPTHASH hHash, HCRYPTKEY hKey, DWORD dwFlags)
1775 {
1776 PCRYPTHASH hash;
1777 PCRYPTKEY key;
1778 PCRYPTPROV prov;
1779
1780 TRACE("(0x%Ix, 0x%Ix, %08lx)\n", hHash, hKey, dwFlags);
1781
1782 if (!(hash = hash_from_handle(hHash)))
1783 return FALSE;
1784
1785 if (!(key = key_from_handle(hKey)))
1786 return FALSE;
1787
1788 if (!hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
1789 {
1790 SetLastError(ERROR_INVALID_PARAMETER);
1791 return FALSE;
1792 }
1793
1794 prov = hash->pProvider;
1795 return prov->pFuncs->pCPHashSessionKey(prov->hPrivate, hash->hPrivate, key->hPrivate, dwFlags);
1796 }
1797
1798 /******************************************************************************
1799 * CryptImportKey (ADVAPI32.@)
1800 *
1801 * Transfer a cryptographic key from a key BLOB into a cryptographic service provider (CSP).
1802 *
1803 * PARAMS
1804 * hProv [I] Handle of a CSP.
1805 * pbData [I] Contains the key to be imported.
1806 * dwDataLen [I] Length of the key.
1807 * hPubKey [I] Cryptographic key that decrypts pdData
1808 * dwFlags [I] Used only with a public/private key pair.
1809 * phKey [O] Imported key.
1810 *
1811 * RETURNS
1812 * Success: TRUE
1813 * Failure: FALSE
1814 */
1815 BOOL WINAPI CryptImportKey (HCRYPTPROV hProv, const BYTE *pbData, DWORD dwDataLen,
1816 HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey)
1817 {
1818 PCRYPTPROV prov;
1819 PCRYPTKEY pubkey = NULL, importkey;
1820
1821 TRACE("(0x%Ix, %p, %ld, 0x%Ix, %08lx, %p)\n", hProv, pbData, dwDataLen, hPubKey, dwFlags, phKey);
1822
1823 if (!(prov = provider_from_handle(hProv)))
1824 return FALSE;
1825
1826 if (hPubKey && !(pubkey = key_from_handle(hPubKey)))
1827 return FALSE;
1828
1829 if (!pbData || !dwDataLen || !phKey)
1830 {
1831 SetLastError(ERROR_INVALID_PARAMETER);
1832 return FALSE;
1833 }
1834
1835 if ( !(importkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
1836 {
1837 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1838 return FALSE;
1839 }
1840
1841 importkey->pProvider = prov;
1842 importkey->dwMagic = MAGIC_CRYPTKEY;
1843 if (prov->pFuncs->pCPImportKey(prov->hPrivate, pbData, dwDataLen,
1844 pubkey ? pubkey->hPrivate : 0, dwFlags, &importkey->hPrivate))
1845 {
1846 *phKey = (HCRYPTKEY)importkey;
1847 return TRUE;
1848 }
1849
1850 importkey->dwMagic = 0;
1851 CRYPT_Free(importkey);
1852 return FALSE;
1853 }
1854
1855 /******************************************************************************
1856 * CryptSignHashW (ADVAPI32.@)
1857 *
1858 * Signs data.
1859 *
1860 * PARAMS
1861 * hHash [I] Handle of the hash object to be signed.
1862 * dwKeySpec [I] Private key to use.
1863 * sDescription [I] Should be NULL.
1864 * dwFlags [I] CRYPT_NOHASHOID/X931_FORMAT.
1865 * pbSignature [O] Buffer of the signature data.
1866 * pdwSigLen [I/O] Size of the pbSignature buffer.
1867 *
1868 * RETURNS
1869 * Success: TRUE
1870 * Failure: FALSE
1871 *
1872 * NOTES
1873 * Because of security flaws sDescription should not be used and should thus be
1874 * NULL. It is supported only for compatibility with Microsoft's Cryptographic
1875 * Providers.
1876 */
1877 BOOL WINAPI CryptSignHashW (HCRYPTHASH hHash, DWORD dwKeySpec, LPCWSTR sDescription,
1878 DWORD dwFlags, BYTE *pbSignature, DWORD *pdwSigLen)
1879 {
1880 PCRYPTHASH hash;
1881 PCRYPTPROV prov;
1882
1883 TRACE("(0x%Ix, %ld, %s, %08lx, %p, %p)\n",
1884 hHash, dwKeySpec, debugstr_w(sDescription), dwFlags, pbSignature, pdwSigLen);
1885
1886 if (!(hash = hash_from_handle(hHash)))
1887 return FALSE;
1888
1889 if (!pdwSigLen || !hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
1890 {
1891 SetLastError(ERROR_INVALID_PARAMETER);
1892 return FALSE;
1893 }
1894
1895 prov = hash->pProvider;
1896 return prov->pFuncs->pCPSignHash(prov->hPrivate, hash->hPrivate, dwKeySpec, sDescription,
1897 dwFlags, pbSignature, pdwSigLen);
1898 }
1899
1900 /******************************************************************************
1901 * CryptSignHashA (ADVAPI32.@)
1902 *
1903 * See CryptSignHashW.
1904 */
1905 BOOL WINAPI CryptSignHashA (HCRYPTHASH hHash, DWORD dwKeySpec, LPCSTR sDescription,
1906 DWORD dwFlags, BYTE *pbSignature, DWORD *pdwSigLen)
1907 {
1908 LPWSTR wsDescription;
1909 BOOL result;
1910
1911 TRACE("(0x%Ix, %ld, %s, %08lx, %p, %p)\n",
1912 hHash, dwKeySpec, debugstr_a(sDescription), dwFlags, pbSignature, pdwSigLen);
1913
1914 CRYPT_ANSIToUnicode(sDescription, &wsDescription, -1);
1915 result = CryptSignHashW(hHash, dwKeySpec, wsDescription, dwFlags, pbSignature, pdwSigLen);
1916 CRYPT_Free(wsDescription);
1917
1918 return result;
1919 }
1920
1921 /******************************************************************************
1922 * CryptSetHashParam (ADVAPI32.@)
1923 *
1924 * Customizes the operations of a hash object.
1925 *
1926 * PARAMS
1927 * hHash [I] Handle of the hash object to set parameters.
1928 * dwParam [I] HP_HMAC_INFO/HASHVAL.
1929 * pbData [I] Value data buffer.
1930 * dwFlags [I] Reserved for future use and must be zero.
1931 *
1932 * RETURNS
1933 * Success: TRUE
1934 * Failure: FALSE
1935 */
1936 BOOL WINAPI CryptSetHashParam (HCRYPTHASH hHash, DWORD dwParam, const BYTE *pbData, DWORD dwFlags)
1937 {
1938 PCRYPTPROV prov;
1939 PCRYPTHASH hash;
1940
1941 TRACE("(0x%Ix, %ld, %p, %08lx)\n", hHash, dwParam, pbData, dwFlags);
1942
1943 if (!(hash = hash_from_handle(hHash)))
1944 return FALSE;
1945
1946 if (!pbData || !hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
1947 {
1948 SetLastError(ERROR_INVALID_PARAMETER);
1949 return FALSE;
1950 }
1951
1952 prov = hash->pProvider;
1953 return prov->pFuncs->pCPSetHashParam(prov->hPrivate, hash->hPrivate,
1954 dwParam, pbData, dwFlags);
1955 }
1956
1957 /******************************************************************************
1958 * CryptSetKeyParam (ADVAPI32.@)
1959 *
1960 * Customizes a session key's operations.
1961 *
1962 * PARAMS
1963 * hKey [I] Handle to the key to set values.
1964 * dwParam [I] See MSDN Doc.
1965 * pbData [I] Buffer of values to set.
1966 * dwFlags [I] Only used when dwParam == KP_ALGID.
1967 *
1968 * RETURNS
1969 * Success: TRUE
1970 * Failure: FALSE
1971 */
1972 BOOL WINAPI CryptSetKeyParam (HCRYPTKEY hKey, DWORD dwParam, const BYTE *pbData, DWORD dwFlags)
1973 {
1974 PCRYPTPROV prov;
1975 PCRYPTKEY key;
1976
1977 TRACE("(0x%Ix, %ld, %p, %08lx)\n", hKey, dwParam, pbData, dwFlags);
1978
1979 if (!(key = key_from_handle(hKey)))
1980 return FALSE;
1981
1982 if (!key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
1983 {
1984 SetLastError(ERROR_INVALID_PARAMETER);
1985 return FALSE;
1986 }
1987
1988 prov = key->pProvider;
1989 return prov->pFuncs->pCPSetKeyParam(prov->hPrivate, key->hPrivate,
1990 dwParam, pbData, dwFlags);
1991 }
1992
1993 /******************************************************************************
1994 * CryptSetProviderA (ADVAPI32.@)
1995 *
1996 * Specifies the current user's default CSP.
1997 *
1998 * PARAMS
1999 * pszProvName [I] Name of the new default CSP.
2000 * dwProvType [I] Provider type of the CSP.
2001 *
2002 * RETURNS
2003 * Success: TRUE
2004 * Failure: FALSE
2005 */
2006 BOOL WINAPI CryptSetProviderA (LPCSTR pszProvName, DWORD dwProvType)
2007 {
2008 TRACE("(%s, %ld)\n", pszProvName, dwProvType);
2009 return CryptSetProviderExA(pszProvName, dwProvType, NULL, CRYPT_USER_DEFAULT);
2010 }
2011
2012 /******************************************************************************
2013 * CryptSetProviderW (ADVAPI32.@)
2014 *
2015 * See CryptSetProviderA.
2016 */
2017 BOOL WINAPI CryptSetProviderW (LPCWSTR pszProvName, DWORD dwProvType)
2018 {
2019 TRACE("(%s, %ld)\n", debugstr_w(pszProvName), dwProvType);
2020 return CryptSetProviderExW(pszProvName, dwProvType, NULL, CRYPT_USER_DEFAULT);
2021 }
2022
2023 /******************************************************************************
2024 * CryptSetProviderExW (ADVAPI32.@)
2025 *
2026 * Specifies the default CSP.
2027 *
2028 * PARAMS
2029 * pszProvName [I] Name of the new default CSP.
2030 * dwProvType [I] Provider type of the CSP.
2031 * pdwReserved [I] Reserved for future use and must be NULL.
2032 * dwFlags [I] See MSDN Doc.
2033 *
2034 * RETURNS
2035 * Success: TRUE
2036 * Failure: FALSE
2037 */
2038 BOOL WINAPI CryptSetProviderExW (LPCWSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags)
2039 {
2040 HKEY hProvKey, hTypeKey;
2041 PWSTR keyname;
2042
2043 TRACE("(%s, %ld, %p, %08lx)\n", debugstr_w(pszProvName), dwProvType, pdwReserved, dwFlags);
2044
2045 if (!pszProvName || pdwReserved)
2046 {
2047 SetLastError(ERROR_INVALID_PARAMETER);
2048 return FALSE;
2049 }
2050 if (dwProvType > MAXPROVTYPES)
2051 {
2052 SetLastError(NTE_BAD_PROV_TYPE);
2053 return FALSE;
2054 }
2055 if (dwFlags & ~(CRYPT_MACHINE_DEFAULT | CRYPT_USER_DEFAULT | CRYPT_DELETE_DEFAULT)
2056 || dwFlags == CRYPT_DELETE_DEFAULT)
2057 {
2058 SetLastError(NTE_BAD_FLAGS);
2059 return FALSE;
2060 }
2061
2062 if (!(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)))
2063 {
2064 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2065 return FALSE;
2066 }
2067 if (RegOpenKeyW((dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
2068 keyname, &hTypeKey))
2069 {
2070 CRYPT_Free(keyname);
2071 SetLastError(NTE_BAD_PROVIDER);
2072 return FALSE;
2073 }
2074 CRYPT_Free(keyname);
2075
2076 if (dwFlags & CRYPT_DELETE_DEFAULT)
2077 {
2078 RegDeleteValueW(hTypeKey, L"Name");
2079 }
2080 else
2081 {
2082 if (!(keyname = CRYPT_GetProvKeyName(pszProvName)))
2083 {
2084 RegCloseKey(hTypeKey);
2085 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2086 return FALSE;
2087 }
2088 if (RegOpenKeyW((dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
2089 keyname, &hProvKey))
2090 {
2091 CRYPT_Free(keyname);
2092 RegCloseKey(hTypeKey);
2093 SetLastError(NTE_BAD_PROVIDER);
2094 return FALSE;
2095 }
2096 CRYPT_Free(keyname);
2097
2098 if (RegSetValueExW(hTypeKey, L"Name", 0, REG_SZ, (const BYTE *)pszProvName,
2099 (lstrlenW(pszProvName) + 1)*sizeof(WCHAR)))
2100 {
2101 RegCloseKey(hTypeKey);
2102 RegCloseKey(hProvKey);
2103 return FALSE;
2104 }
2105
2106 RegCloseKey(hProvKey);
2107 }
2108 RegCloseKey(hTypeKey);
2109
2110 return TRUE;
2111 }
2112
2113 /******************************************************************************
2114 * CryptSetProviderExA (ADVAPI32.@)
2115 *
2116 * See CryptSetProviderExW.
2117 */
2118 BOOL WINAPI CryptSetProviderExA (LPCSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags)
2119 {
2120 BOOL ret = FALSE;
2121 PWSTR str = NULL;
2122
2123 TRACE("(%s, %ld, %p, %08lx)\n", pszProvName, dwProvType, pdwReserved, dwFlags);
2124
2125 if (CRYPT_ANSIToUnicode(pszProvName, &str, -1))
2126 {
2127 ret = CryptSetProviderExW(str, dwProvType, pdwReserved, dwFlags);
2128 CRYPT_Free(str);
2129 }
2130 return ret;
2131 }
2132
2133 /******************************************************************************
2134 * CryptSetProvParam (ADVAPI32.@)
2135 *
2136 * Customizes the operations of a CSP.
2137 *
2138 * PARAMS
2139 * hProv [I] Handle of a CSP.
2140 * dwParam [I] See MSDN Doc.
2141 * pbData [I] Buffer that contains a value to set as a parameter.
2142 * dwFlags [I] if dwParam is PP_USE_HARDWARE_RNG, dwFlags must be zero.
2143 *
2144 * RETURNS
2145 * Success: TRUE
2146 * Failure: FALSE
2147 */
2148 BOOL WINAPI CryptSetProvParam (HCRYPTPROV hProv, DWORD dwParam, const BYTE *pbData, DWORD dwFlags)
2149 {
2150 PCRYPTPROV prov;
2151
2152 TRACE("(0x%Ix, %ld, %p, %08lx)\n", hProv, dwParam, pbData, dwFlags);
2153
2154 if (!(prov = provider_from_handle(hProv)))
2155 return FALSE;
2156
2157 if (dwParam == PP_USE_HARDWARE_RNG)
2158 {
2159 FIXME("PP_USE_HARDWARE_RNG: What do I do with this?\n");
2160 FIXME("\tLetting the CSP decide.\n");
2161 }
2162 if (dwFlags & PP_CLIENT_HWND)
2163 {
2164 /* FIXME: Should verify the parameter */
2165 if (pbData /* && IsWindow((HWND)pbData) */)
2166 {
2167 crypt_hWindow = (HWND)(pbData);
2168 return TRUE;
2169 } else {
2170 SetLastError(ERROR_INVALID_PARAMETER);
2171 return FALSE;
2172 }
2173 }
2174 /* All other flags go to the CSP */
2175 return prov->pFuncs->pCPSetProvParam(prov->hPrivate, dwParam, pbData, dwFlags);
2176 }
2177
2178 /******************************************************************************
2179 * CryptVerifySignatureW (ADVAPI32.@)
2180 *
2181 * Verifies the signature of a hash object.
2182 *
2183 * PARAMS
2184 * hHash [I] Handle of the hash object to verify.
2185 * pbSignature [I] Signature data to verify.
2186 * dwSigLen [I] Size of pbSignature.
2187 * hPubKey [I] Handle to the public key to authenticate signature.
2188 * sDescription [I] Should be NULL.
2189 * dwFlags [I] See MSDN doc.
2190 *
2191 * RETURNS
2192 * Success: TRUE
2193 * Failure: FALSE
2194 *
2195 * NOTES
2196 * Because of security flaws sDescription should not be used and should thus be
2197 * NULL. It is supported only for compatibility with Microsoft's Cryptographic
2198 * Providers.
2199 */
2200 BOOL WINAPI CryptVerifySignatureW (HCRYPTHASH hHash, const BYTE *pbSignature, DWORD dwSigLen,
2201 HCRYPTKEY hPubKey, LPCWSTR sDescription, DWORD dwFlags)
2202 {
2203 PCRYPTHASH hash;
2204 PCRYPTKEY key;
2205 PCRYPTPROV prov;
2206
2207 TRACE("(0x%Ix, %p, %ld, 0x%Ix, %s, %08lx)\n", hHash, pbSignature,
2208 dwSigLen, hPubKey, debugstr_w(sDescription), dwFlags);
2209
2210 if (!(hash = hash_from_handle(hHash)))
2211 return FALSE;
2212
2213 if (!(key = key_from_handle(hPubKey)))
2214 return FALSE;
2215
2216 if (!hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV ||
2217 !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
2218 {
2219 SetLastError(ERROR_INVALID_PARAMETER);
2220 return FALSE;
2221 }
2222
2223 prov = hash->pProvider;
2224 return prov->pFuncs->pCPVerifySignature(prov->hPrivate, hash->hPrivate, pbSignature, dwSigLen,
2225 key->hPrivate, sDescription, dwFlags);
2226 }
2227
2228 /******************************************************************************
2229 * CryptVerifySignatureA (ADVAPI32.@)
2230 *
2231 * See CryptVerifySignatureW.
2232 */
2233 BOOL WINAPI CryptVerifySignatureA (HCRYPTHASH hHash, const BYTE *pbSignature, DWORD dwSigLen,
2234 HCRYPTKEY hPubKey, LPCSTR sDescription, DWORD dwFlags)
2235 {
2236 LPWSTR wsDescription;
2237 BOOL result;
2238
2239 TRACE("(0x%Ix, %p, %ld, 0x%Ix, %s, %08lx)\n", hHash, pbSignature,
2240 dwSigLen, hPubKey, debugstr_a(sDescription), dwFlags);
2241
2242 CRYPT_ANSIToUnicode(sDescription, &wsDescription, -1);
2243 result = CryptVerifySignatureW(hHash, pbSignature, dwSigLen, hPubKey, wsDescription, dwFlags);
2244 CRYPT_Free(wsDescription);
2245
2246 return result;
2247 }
2248
2249 /******************************************************************************
2250 * OpenEncryptedFileRawA (ADVAPI32.@)
2251 *
2252 * See OpenEncryptedFileRawW
2253 */
2254 DWORD WINAPI OpenEncryptedFileRawA(LPCSTR filename, ULONG flags, PVOID *context)
2255 {
2256 FIXME("(%s, %lx, %p): stub\n", debugstr_a(filename), flags, context);
2257 return ERROR_CALL_NOT_IMPLEMENTED;
2258 }
2259
2260 /******************************************************************************
2261 * OpenEncryptedFileRawW (ADVAPI32.@)
2262 *
2263 * Opens an EFS encrypted file for backup/restore
2264 *
2265 * PARAMS
2266 * filename [I] Filename to operate on
2267 * flags [I] Operation to perform
2268 * context [I] Handle to the context (out)
2269 * RETURNS
2270 * Success: ERROR_SUCCESS
2271 * Failure: NTSTATUS error code
2272 */
2273 DWORD WINAPI OpenEncryptedFileRawW(LPCWSTR filename, ULONG flags, PVOID *context)
2274 {
2275 FIXME("(%s, %lx, %p): stub\n", debugstr_w(filename), flags, context);
2276 return ERROR_CALL_NOT_IMPLEMENTED;
2277 }
2278
2279 /******************************************************************************
2280 * ReadEncryptedFileRaw (ADVAPI32.@)
2281 *
2282 * Export encrypted files
2283 *
2284 * PARAMS
2285 * export [I] pointer to the export callback function
2286 * callback [I] pointer to the application defined context
2287 * context [I] pointer to the system context
2288 * RETURNS
2289 * Success: ERROR_SUCCESS
2290 * Failure: NTSTATUS error code
2291 */
2292 DWORD WINAPI ReadEncryptedFileRaw(PFE_EXPORT_FUNC export, PVOID callback, PVOID context)
2293 {
2294 FIXME("(%p, %p, %p): stub\n", export, callback, context);
2295 return ERROR_CALL_NOT_IMPLEMENTED;
2296 }
2297
2298 /******************************************************************************
2299 * SystemFunction007 [ADVAPI32.@]
2300 *
2301 * MD4 hash a unicode string
2302 *
2303 * PARAMS
2304 * string [I] the string to hash
2305 * output [O] the md4 hash of the string (16 bytes)
2306 *
2307 * RETURNS
2308 * Success: STATUS_SUCCESS
2309 * Failure: STATUS_UNSUCCESSFUL
2310 *
2311 */
2312 NTSTATUS WINAPI SystemFunction007(const UNICODE_STRING *string, LPBYTE hash)
2313 {
2314 MD4_CTX ctx;
2315
2316 MD4Init( &ctx );
2317 MD4Update( &ctx, (const BYTE *)string->Buffer, string->Length );
2318 MD4Final( &ctx );
2319 memcpy( hash, ctx.digest, 0x10 );
2320
2321 return STATUS_SUCCESS;
2322 }
2323
2324 /******************************************************************************
2325 * SystemFunction010 [ADVAPI32.@]
2326 * SystemFunction011 [ADVAPI32.@]
2327 *
2328 * MD4 hashes 16 bytes of data
2329 *
2330 * PARAMS
2331 * unknown [] seems to have no effect on the output
2332 * data [I] pointer to data to hash (16 bytes)
2333 * output [O] the md4 hash of the data (16 bytes)
2334 *
2335 * RETURNS
2336 * Success: STATUS_SUCCESS
2337 * Failure: STATUS_UNSUCCESSFUL
2338 *
2339 */
2340 NTSTATUS WINAPI SystemFunction010(LPVOID unknown, const BYTE *data, LPBYTE hash)
2341 {
2342 MD4_CTX ctx;
2343
2344 MD4Init( &ctx );
2345 MD4Update( &ctx, data, 0x10 );
2346 MD4Final( &ctx );
2347 memcpy( hash, ctx.digest, 0x10 );
2348
2349 return STATUS_SUCCESS;
2350 }
2351
2352 /******************************************************************************
2353 * SystemFunction030 (ADVAPI32.@)
2354 *
2355 * Tests if two blocks of 16 bytes are equal
2356 *
2357 * PARAMS
2358 * b1,b2 [I] block of 16 bytes
2359 *
2360 * RETURNS
2361 * TRUE if blocks are the same
2362 * FALSE if blocks are different
2363 */
2364 BOOL WINAPI SystemFunction030(LPCVOID b1, LPCVOID b2)
2365 {
2366 return !memcmp(b1, b2, 0x10);
2367 }
2368
2369 /******************************************************************************
2370 * SystemFunction035 (ADVAPI32.@)
2371 *
2372 * Described here:
2373 http://disc.server.com/discussion.cgi?disc=148775;article=942;title=Coding%2FASM%2FSystem
2374 *
2375 * NOTES
2376 * Stub, always return TRUE.
2377 */
2378 BOOL WINAPI SystemFunction035(LPCSTR lpszDllFilePath)
2379 {
2380 FIXME("%s: stub\n", debugstr_a(lpszDllFilePath));
2381 return TRUE;
2382 }
2383
2384 static CRITICAL_SECTION random_cs;
2385 static CRITICAL_SECTION_DEBUG random_debug =
2386 {
2387 0, 0, &random_cs,
2388 { &random_debug.ProcessLocksList, &random_debug.ProcessLocksList },
2389 0, 0, { (DWORD_PTR)(__FILE__ ": random_cs") }
2390 };
2391 static CRITICAL_SECTION random_cs = { &random_debug, -1, 0, 0, 0, 0 };
2392
2393 #define MAX_CPUS 256
2394 static char random_buf[sizeof(SYSTEM_INTERRUPT_INFORMATION) * MAX_CPUS];
2395 static ULONG random_len;
2396 static ULONG random_pos;
2397
2398 /* FIXME: assumes interrupt information provides sufficient randomness */
2399 static BOOL fill_random_buffer(void)
2400 {
2401 ULONG len = sizeof(SYSTEM_INTERRUPT_INFORMATION) * min( NtCurrentTeb()->Peb->NumberOfProcessors, MAX_CPUS );
2402 NTSTATUS status;
2403
2404 if ((status = NtQuerySystemInformation( SystemInterruptInformation, random_buf, len, NULL )))
2405 {
2406 WARN( "failed to get random bytes %08lx\n", status );
2407 return FALSE;
2408 }
2409 random_len = len;
2410 random_pos = 0;
2411 return TRUE;
2412 }
2413
2414 /******************************************************************************
2415 * SystemFunction036 (ADVAPI32.@)
2416 *
2417 * MSDN documents this function as RtlGenRandom and declares it in ntsecapi.h
2418 *
2419 * PARAMS
2420 * pbBuffer [O] Pointer to memory to receive random bytes.
2421 * dwLen [I] Number of random bytes to fetch.
2422 *
2423 * RETURNS
2424 * Success: TRUE
2425 * Failure: FALSE
2426 */
2427
2428 BOOLEAN WINAPI SystemFunction036( void *buffer, ULONG len )
2429 {
2430 char *ptr = buffer;
2431
2432 EnterCriticalSection( &random_cs );
2433 while (len)
2434 {
2435 ULONG size;
2436 if (random_pos >= random_len && !fill_random_buffer())
2437 {
2438 SetLastError( NTE_FAIL );
2439 LeaveCriticalSection( &random_cs );
2440 return FALSE;
2441 }
2442 size = min( len, random_len - random_pos );
2443 memcpy( ptr, random_buf + random_pos, size );
2444 random_pos += size;
2445 ptr += size;
2446 len -= size;
2447 }
2448 LeaveCriticalSection( &random_cs );
2449 return TRUE;
2450 }
2451
2452 /*
2453 These functions have nearly identical prototypes to CryptProtectMemory and CryptUnprotectMemory,
2454 in crypt32.dll.
2455 */
2456
2457 /******************************************************************************
2458 * SystemFunction040 (ADVAPI32.@)
2459 *
2460 * MSDN documents this function as RtlEncryptMemory and declares it in ntsecapi.h.
2461 *
2462 * PARAMS
2463 * memory [I/O] Pointer to memory to encrypt.
2464 * length [I] Length of region to encrypt in bytes.
2465 * flags [I] Control whether other processes are able to decrypt the memory.
2466 * RTL_ENCRYPT_OPTION_SAME_PROCESS
2467 * RTL_ENCRYPT_OPTION_CROSS_PROCESS
2468 * RTL_ENCRYPT_OPTION_SAME_LOGON
2469 *
2470 * RETURNS
2471 * Success: STATUS_SUCCESS
2472 * Failure: NTSTATUS error code
2473 *
2474 * NOTES
2475 * length must be a multiple of RTL_ENCRYPT_MEMORY_SIZE.
2476 * If flags are specified when encrypting, the same flag value must be given
2477 * when decrypting the memory.
2478 */
2479 NTSTATUS WINAPI SystemFunction040(PVOID memory, ULONG length, ULONG flags)
2480 {
2481 FIXME("(%p, %lx, %lx): stub [RtlEncryptMemory]\n", memory, length, flags);
2482 return STATUS_SUCCESS;
2483 }
2484
2485 /******************************************************************************
2486 * SystemFunction041 (ADVAPI32.@)
2487 *
2488 * MSDN documents this function as RtlDecryptMemory and declares it in ntsecapi.h.
2489 *
2490 * PARAMS
2491 * memory [I/O] Pointer to memory to decrypt.
2492 * length [I] Length of region to decrypt in bytes.
2493 * flags [I] Control whether other processes are able to decrypt the memory.
2494 * RTL_ENCRYPT_OPTION_SAME_PROCESS
2495 * RTL_ENCRYPT_OPTION_CROSS_PROCESS
2496 * RTL_ENCRYPT_OPTION_SAME_LOGON
2497 *
2498 * RETURNS
2499 * Success: STATUS_SUCCESS
2500 * Failure: NTSTATUS error code
2501 *
2502 * NOTES
2503 * length must be a multiple of RTL_ENCRYPT_MEMORY_SIZE.
2504 * If flags are specified when encrypting, the same flag value must be given
2505 * when decrypting the memory.
2506 */
2507 NTSTATUS WINAPI SystemFunction041(PVOID memory, ULONG length, ULONG flags)
2508 {
2509 FIXME("(%p, %lx, %lx): stub [RtlDecryptMemory]\n", memory, length, flags);
2510 return STATUS_SUCCESS;
2511 }
2512
2513 /******************************************************************************
2514 * WriteEncryptedFileRaw (ADVAPI32.@)
2515 *
2516 * Import encrypted files
2517 *
2518 * PARAMS
2519 * import [I] pointer to the import callback function
2520 * callback [I] pointer to the application defined context
2521 * context [I] pointer to the system context
2522 * RETURNS
2523 * Success: ERROR_SUCCESS
2524 * Failure: NTSTATUS error code
2525 */
2526 DWORD WINAPI WriteEncryptedFileRaw(PFE_IMPORT_FUNC import, PVOID callback, PVOID context)
2527 {
2528 FIXME("(%p, %p, %p): stub\n", import, callback, context);
2529 return ERROR_CALL_NOT_IMPLEMENTED;
2530 }
Windows API implementation