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