?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Stub for DrawDibProfileDisplay.
[wine/multimedia.git] / dlls / advapi32 / crypt.c
blobe2db49a300b97ed20bcc0a364442288af4c62fcd
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20 /***********************************************************************
21 *
22 * TODO:
23 * - Reference counting
24 * - Thread-safing
25 * - Signature checking
26 */
27
28 #include <time.h>
29 #include <stdlib.h>
30 #include <stdio.h>
31
32 #include "wine/unicode.h"
33 #include "crypt.h"
34 #include "winnls.h"
35 #include "wincrypt.h"
36 #include "windef.h"
37 #include "winerror.h"
38 #include "winreg.h"
39 #include "winbase.h"
40 #include "winuser.h"
41 #include "wine/debug.h"
42 #include "winternl.h"
43 #include "ntstatus.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
46
47 HWND crypt_hWindow = 0;
48
49 #define CRYPT_ReturnLastError(err) {SetLastError(err); return FALSE;}
50
51 #define CRYPT_Alloc(size) ((LPVOID)LocalAlloc(LMEM_ZEROINIT, size))
52 #define CRYPT_Free(buffer) (LocalFree((HLOCAL)buffer))
53
54 static inline PSTR CRYPT_GetProvKeyName(PCSTR pProvName)
55 {
56 PCSTR KEYSTR = "Software\\Microsoft\\Cryptography\\Defaults\\Provider\\";
57 PSTR keyname;
58
59 keyname = CRYPT_Alloc(strlen(KEYSTR) + strlen(pProvName) +1);
60 if (keyname)
61 {
62 strcpy(keyname, KEYSTR);
63 strcpy(keyname + strlen(KEYSTR), pProvName);
64 } else
65 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
66 return keyname;
67 }
68
69 static inline PSTR CRYPT_GetTypeKeyName(DWORD dwType, BOOL user)
70 {
71 PCSTR MACHINESTR = "Software\\Microsoft\\Cryptography\\Defaults\\Provider Types\\Type XXX";
72 PCSTR USERSTR = "Software\\Microsoft\\Cryptography\\Provider Type XXX";
73 PSTR keyname;
74 PSTR ptr;
75
76 keyname = CRYPT_Alloc( (user ? strlen(USERSTR) : strlen(MACHINESTR)) +1);
77 if (keyname)
78 {
79 user ? strcpy(keyname, USERSTR) : strcpy(keyname, MACHINESTR);
80 ptr = keyname + strlen(keyname);
81 *(--ptr) = (dwType % 10) + '0';
82 *(--ptr) = (dwType / 10) + '0';
83 *(--ptr) = (dwType / 100) + '0';
84 } else
85 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
86 return keyname;
87 }
88
89 /* CRYPT_UnicodeTOANSI
90 * wstr - unicode string
91 * str - pointer to ANSI string
92 * strsize - size of buffer pointed to by str or -1 if we have to do the allocation
93 *
94 * returns TRUE if unsuccessfull, FALSE otherwise.
95 * if wstr is NULL, returns TRUE and sets str to NULL! Value of str should be checked after call
96 */
97 static inline BOOL CRYPT_UnicodeToANSI(LPCWSTR wstr, LPSTR* str, int strsize)
98 {
99 int count;
100
101 if (!wstr)
102 {
103 *str = NULL;
104 return TRUE;
105 }
106 count = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
107 count = count < strsize ? count : strsize;
108 if (strsize == -1)
109 *str = CRYPT_Alloc(count * sizeof(CHAR));
110 if (*str)
111 {
112 WideCharToMultiByte(CP_ACP, 0, wstr, -1, *str, count, NULL, NULL);
113 return TRUE;
114 }
115 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
116 return FALSE;
117 }
118
119 /* CRYPT_ANSITOUnicode
120 * str - ANSI string
121 * wstr - pointer to unicode string
122 * wstrsize - size of buffer pointed to by wstr or -1 if we have to do the allocation
123 */
124 static inline BOOL CRYPT_ANSIToUnicode(LPCSTR str, LPWSTR* wstr, int wstrsize)
125 {
126 int wcount;
127
128 if (!str)
129 {
130 *wstr = NULL;
131 return TRUE;
132 }
133 wcount = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
134 wcount = wcount < wstrsize/sizeof(WCHAR) ? wcount : wstrsize/sizeof(WCHAR);
135 if (wstrsize == -1)
136 *wstr = CRYPT_Alloc(wcount * sizeof(WCHAR));
137 if (*wstr)
138 {
139 MultiByteToWideChar(CP_ACP, 0, str, -1, *wstr, wcount);
140 return TRUE;
141 }
142 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
143 return FALSE;
144 }
145
146 /* These next 2 functions are used by the VTableProvStruc structure */
147 static BOOL CALLBACK CRYPT_VerifyImage(LPCSTR lpszImage, BYTE* pData)
148 {
149 if (!lpszImage || !pData)
150 {
151 SetLastError(ERROR_INVALID_PARAMETER);
152 return FALSE;
153 }
154
155 FIXME("(%s, %p): not verifying image\n", lpszImage, pData);
156
157 return TRUE;
158 }
159
160 static BOOL CALLBACK CRYPT_ReturnhWnd(HWND *phWnd)
161 {
162 if (!phWnd)
163 return FALSE;
164 *phWnd = crypt_hWindow;
165 return TRUE;
166 }
167
168 #define CRYPT_GetProvFunc(name) \
169 if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error
170 #define CRYPT_GetProvFuncOpt(name) \
171 provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)
172 PCRYPTPROV CRYPT_LoadProvider(PSTR pImage)
173 {
174 PCRYPTPROV provider;
175 DWORD errorcode = ERROR_NOT_ENOUGH_MEMORY;
176
177 if ( !(provider = CRYPT_Alloc(sizeof(CRYPTPROV))) ) goto error;
178 if ( !(provider->pFuncs = CRYPT_Alloc(sizeof(PROVFUNCS))) ) goto error;
179 if ( !(provider->pVTable = CRYPT_Alloc(sizeof(VTableProvStruc))) ) goto error;
180 if ( !(provider->hModule = LoadLibraryA(pImage)) )
181 {
182 errorcode = (GetLastError() == ERROR_FILE_NOT_FOUND) ? NTE_PROV_DLL_NOT_FOUND : NTE_PROVIDER_DLL_FAIL;
183 FIXME("Failed to load dll %s\n", debugstr_a(pImage));
184 goto error;
185 }
186
187 errorcode = NTE_PROVIDER_DLL_FAIL;
188 CRYPT_GetProvFunc(CPAcquireContext);
189 CRYPT_GetProvFunc(CPCreateHash);
190 CRYPT_GetProvFunc(CPDecrypt);
191 CRYPT_GetProvFunc(CPDeriveKey);
192 CRYPT_GetProvFunc(CPDestroyHash);
193 CRYPT_GetProvFunc(CPDestroyKey);
194 CRYPT_GetProvFuncOpt(CPDuplicateHash);
195 CRYPT_GetProvFuncOpt(CPDuplicateKey);
196 CRYPT_GetProvFunc(CPEncrypt);
197 CRYPT_GetProvFunc(CPExportKey);
198 CRYPT_GetProvFunc(CPGenKey);
199 CRYPT_GetProvFunc(CPGenRandom);
200 CRYPT_GetProvFunc(CPGetHashParam);
201 CRYPT_GetProvFunc(CPGetKeyParam);
202 CRYPT_GetProvFunc(CPGetProvParam);
203 CRYPT_GetProvFunc(CPGetUserKey);
204 CRYPT_GetProvFunc(CPHashData);
205 CRYPT_GetProvFunc(CPHashSessionKey);
206 CRYPT_GetProvFunc(CPImportKey);
207 CRYPT_GetProvFunc(CPReleaseContext);
208 CRYPT_GetProvFunc(CPSetHashParam);
209 CRYPT_GetProvFunc(CPSetKeyParam);
210 CRYPT_GetProvFunc(CPSetProvParam);
211 CRYPT_GetProvFunc(CPSignHash);
212 CRYPT_GetProvFunc(CPVerifySignature);
213
214 /* FIXME: Not sure what the pbContextInfo field is for.
215 * Does it need memory allocation?
216 */
217 provider->pVTable->Version = 3;
218 provider->pVTable->pFuncVerifyImage = (FARPROC)CRYPT_VerifyImage;
219 provider->pVTable->pFuncReturnhWnd = (FARPROC)CRYPT_ReturnhWnd;
220 provider->pVTable->dwProvType = 0;
221 provider->pVTable->pbContextInfo = NULL;
222 provider->pVTable->cbContextInfo = 0;
223 provider->pVTable->pszProvName = NULL;
224 return provider;
225
226 error:
227 SetLastError(errorcode);
228 if (provider)
229 {
230 if (provider->hModule)
231 FreeLibrary(provider->hModule);
232 CRYPT_Free(provider->pVTable);
233 CRYPT_Free(provider->pFuncs);
234 CRYPT_Free(provider);
235 }
236 return NULL;
237 }
238 #undef CRYPT_GetProvFunc
239 #undef CRYPT_GetProvFuncOpt
240
241
242 /******************************************************************************
243 * CryptAcquireContextA (ADVAPI32.@)
244 * Acquire a crypto provider context handle.
245 *
246 * PARAMS
247 * phProv: Pointer to HCRYPTPROV for the output.
248 * pszContainer: Key Container Name
249 * pszProvider: Cryptographic Service Provider Name
250 * dwProvType: Crypto provider type to get a handle.
251 * dwFlags: flags for the operation
252 *
253 * RETURNS TRUE on success, FALSE on failure.
254 */
255 BOOL WINAPI CryptAcquireContextA (HCRYPTPROV *phProv, LPCSTR pszContainer,
256 LPCSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
257 {
258 PCRYPTPROV pProv = NULL;
259 HKEY key;
260 PSTR imagepath = NULL, keyname = NULL, provname = NULL, temp = NULL;
261 BYTE* signature;
262 DWORD keytype, type, len;
263 ULONG r;
264
265 TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv, pszContainer,
266 pszProvider, dwProvType, dwFlags);
267
268 if (!phProv || !dwProvType)
269 {
270 SetLastError(ERROR_INVALID_PARAMETER);
271 return FALSE;
272 }
273 if (dwProvType > MAXPROVTYPES)
274 {
275 SetLastError(NTE_BAD_PROV_TYPE);
276 return FALSE;
277 }
278
279 if (!pszProvider)
280 {
281 /* No CSP name specified so try the user default CSP first
282 * then try the machine default CSP
283 */
284 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, TRUE)) ) {
285 FIXME("No provider registered for crypto provider type %ld.\n", dwProvType);
286 SetLastError(NTE_PROV_TYPE_NOT_DEF);
287 return FALSE;
288 }
289 if (RegOpenKeyA(HKEY_CURRENT_USER, keyname, &key))
290 {
291 CRYPT_Free(keyname);
292 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, FALSE)) ) {
293 FIXME("No type registered for crypto provider type %ld.\n", dwProvType);
294 RegCloseKey(key);
295 SetLastError(NTE_PROV_TYPE_NOT_DEF);
296 goto error;
297 }
298 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, keyname, &key)) {
299 FIXME("Did not find registry entry of crypto provider for %s.\n", debugstr_a(keyname));
300 RegCloseKey(key);
301 SetLastError(NTE_PROV_TYPE_NOT_DEF);
302 goto error;
303 }
304 }
305 CRYPT_Free(keyname);
306 r = RegQueryValueExA(key, "Name", NULL, &keytype, NULL, &len);
307 if( r != ERROR_SUCCESS || !len || keytype != REG_SZ)
308 {
309 TRACE("error %ld reading size of 'Name' from registry\n", r );
310 RegCloseKey(key);
311 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
312 goto error;
313 }
314 if(!(provname = CRYPT_Alloc(len)))
315 {
316 RegCloseKey(key);
317 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
318 goto error;
319 }
320 r = RegQueryValueExA(key, "Name", NULL, NULL, provname, &len);
321 if( r != ERROR_SUCCESS )
322 {
323 TRACE("error %ld reading 'Name' from registry\n", r );
324 RegCloseKey(key);
325 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
326 goto error;
327 }
328 RegCloseKey(key);
329 } else {
330 if ( !(provname = CRYPT_Alloc(strlen(pszProvider) +1)) )
331 {
332 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
333 goto error;
334 }
335 strcpy(provname, pszProvider);
336 }
337
338 keyname = CRYPT_GetProvKeyName(provname);
339 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, keyname, &key)) goto error;
340 CRYPT_Free(keyname);
341 len = sizeof(DWORD);
342 r = RegQueryValueExA(key, "Type", NULL, NULL, (BYTE*)&type, &len);
343 if (r != ERROR_SUCCESS || type != dwProvType)
344 {
345 FIXME("Crypto provider has wrong type (%ld vs expected %ld).\n", type, dwProvType);
346 SetLastError(NTE_BAD_PROV_TYPE);
347 goto error;
348 }
349
350 r = RegQueryValueExA(key, "Image Path", NULL, &keytype, NULL, &len);
351 if ( r != ERROR_SUCCESS || keytype != REG_SZ)
352 {
353 TRACE("error %ld reading size of 'Image Path' from registry\n", r );
354 RegCloseKey(key);
355 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
356 goto error;
357 }
358 if (!(temp = CRYPT_Alloc(len)))
359 {
360 RegCloseKey(key);
361 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
362 goto error;
363 }
364 r = RegQueryValueExA(key, "Image Path", NULL, NULL, temp, &len);
365 if( r != ERROR_SUCCESS )
366 {
367 TRACE("error %ld reading 'Image Path' from registry\n", r );
368 RegCloseKey(key);
369 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
370 goto error;
371 }
372
373 r = RegQueryValueExA(key, "Signature", NULL, &keytype, NULL, &len);
374 if ( r == ERROR_SUCCESS && keytype == REG_BINARY )
375 {
376 if (!(signature = CRYPT_Alloc(len)))
377 {
378 RegCloseKey(key);
379 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
380 goto error;
381 }
382 r = RegQueryValueExA(key, "Signature", NULL, NULL, signature, &len);
383 if ( r != ERROR_SUCCESS )
384 {
385 TRACE("error %ld reading 'Signature'\n", r );
386 RegCloseKey(key);
387 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
388 goto error;
389 }
390 }
391 else
392 {
393 r = RegQueryValueExA(key, "SigInFile", NULL, &keytype, NULL, &len);
394 if (r != ERROR_SUCCESS)
395 {
396 TRACE("error %ld reading size of 'SigInFile'\n", r );
397 RegCloseKey(key);
398 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
399 goto error;
400 }
401 else
402 {
403 /* FIXME: The presence of the SigInFile value indicates the
404 * provider's signature is in its resources, so need to read it.
405 * But since CRYPT_VerifyImage is stubbed, provide any old thing
406 * for now.
407 */
408 if (!(signature = CRYPT_Alloc(1)))
409 {
410 RegCloseKey(key);
411 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
412 goto error;
413 }
414 }
415 }
416 RegCloseKey(key);
417 len = ExpandEnvironmentStringsA(temp, NULL, 0);
418 if ( !(imagepath = CRYPT_Alloc(len)) )
419 {
420 CRYPT_Free(signature);
421 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
422 goto error;
423 }
424 if (!ExpandEnvironmentStringsA(temp, imagepath, len))
425 {
426 CRYPT_Free(signature);
427 /* ExpandEnvironmentStrings will call SetLastError */
428 goto error;
429 }
430
431 if (!CRYPT_VerifyImage(imagepath, signature))
432 {
433 CRYPT_Free(signature);
434 SetLastError(NTE_SIGNATURE_FILE_BAD);
435 goto error;
436 }
437 pProv = CRYPT_LoadProvider(imagepath);
438 CRYPT_Free(temp);
439 CRYPT_Free(signature);
440 if (!pProv) {
441 /* CRYPT_LoadProvider calls SetLastError */
442 goto error;
443 }
444 pProv->pVTable->dwProvType = dwProvType;
445 pProv->pVTable->pszProvName = provname;
446 if (pProv->pFuncs->pCPAcquireContext(&pProv->hPrivate, (CHAR*)pszContainer, dwFlags, pProv->pVTable))
447 {
448 /* MSDN: When this flag is set, the value returned in phProv is undefined,
449 * and thus, the CryptReleaseContext function need not be called afterwards.
450 * Therefore, we must clean up everything now.
451 */
452 if (dwFlags & CRYPT_DELETEKEYSET)
453 {
454 FreeLibrary(pProv->hModule);
455 CRYPT_Free(provname);
456 CRYPT_Free(pProv->pFuncs);
457 CRYPT_Free(pProv);
458 } else {
459 *phProv = (HCRYPTPROV)pProv;
460 }
461 return TRUE;
462 }
463 /* FALLTHROUGH TO ERROR IF FALSE - CSP internal error! */
464 error:
465 if (pProv)
466 {
467 FreeLibrary(pProv->hModule);
468 CRYPT_Free(pProv->pVTable);
469 CRYPT_Free(pProv->pFuncs);
470 CRYPT_Free(pProv);
471 }
472 CRYPT_Free(provname);
473 CRYPT_Free(temp);
474 CRYPT_Free(imagepath);
475 CRYPT_Free(keyname);
476 return FALSE;
477 }
478
479 /******************************************************************************
480 * CryptAcquireContextW (ADVAPI32.@)
481 */
482 BOOL WINAPI CryptAcquireContextW (HCRYPTPROV *phProv, LPCWSTR pszContainer,
483 LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
484 {
485 PSTR pProvider = NULL, pContainer = NULL;
486 BOOL ret = FALSE;
487
488 TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv, debugstr_w(pszContainer),
489 debugstr_w(pszProvider), dwProvType, dwFlags);
490
491 if ( !CRYPT_UnicodeToANSI(pszContainer, &pContainer, -1) )
492 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
493 if ( !CRYPT_UnicodeToANSI(pszProvider, &pProvider, -1) )
494 {
495 CRYPT_Free(pContainer);
496 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
497 }
498
499 ret = CryptAcquireContextA(phProv, pContainer, pProvider, dwProvType, dwFlags);
500
501 if (pContainer)
502 CRYPT_Free(pContainer);
503 if (pProvider)
504 CRYPT_Free(pProvider);
505
506 return ret;
507 }
508
509 /******************************************************************************
510 * CryptContextAddRef (ADVAPI32.@)
511 */
512 BOOL WINAPI CryptContextAddRef (HCRYPTPROV hProv, DWORD *pdwReserved, DWORD dwFlags)
513 {
514 FIXME("(0x%lx, %p, %08lx): stub!\n", hProv, pdwReserved, dwFlags);
515 return FALSE;
516 /* InterlockIncrement?? */
517 }
518
519 /******************************************************************************
520 * CryptReleaseContext (ADVAPI32.@)
521 */
522 BOOL WINAPI CryptReleaseContext (HCRYPTPROV hProv, DWORD dwFlags)
523 {
524 PCRYPTPROV pProv = (PCRYPTPROV)hProv;
525 BOOL ret;
526
527 TRACE("(0x%lx, %08ld)\n", hProv, dwFlags);
528
529 if (!pProv)
530 {
531 SetLastError(NTE_BAD_UID);
532 return FALSE;
533 }
534 /* FIXME: Decrement the counter here first if possible */
535 ret = pProv->pFuncs->pCPReleaseContext(pProv->hPrivate, dwFlags);
536 FreeLibrary(pProv->hModule);
537 #if 0
538 CRYPT_Free(pProv->pVTable->pContextInfo);
539 #endif
540 CRYPT_Free(pProv->pVTable->pszProvName);
541 CRYPT_Free(pProv->pVTable);
542 CRYPT_Free(pProv->pFuncs);
543 CRYPT_Free(pProv);
544 return ret;
545 }
546
547 /******************************************************************************
548 * CryptGenRandom (ADVAPI32.@)
549 */
550 BOOL WINAPI CryptGenRandom (HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer)
551 {
552 PCRYPTPROV prov = (PCRYPTPROV)hProv;
553
554 TRACE("(0x%lx, %ld, %p)\n", hProv, dwLen, pbBuffer);
555
556 if (!hProv)
557 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
558
559 return prov->pFuncs->pCPGenRandom(prov->hPrivate, dwLen, pbBuffer);
560 }
561
562 /******************************************************************************
563 * CryptCreateHash (ADVAPI32.@)
564 */
565 BOOL WINAPI CryptCreateHash (HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey,
566 DWORD dwFlags, HCRYPTHASH *phHash)
567 {
568 PCRYPTPROV prov = (PCRYPTPROV)hProv;
569 PCRYPTKEY key = (PCRYPTKEY)hKey;
570 PCRYPTHASH hash;
571
572 TRACE("(0x%lx, 0x%x, 0x%lx, %08lx, %p)\n", hProv, Algid, hKey, dwFlags, phHash);
573
574 if (!prov)
575 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
576 if (!phHash)
577 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
578 if (dwFlags)
579 CRYPT_ReturnLastError(NTE_BAD_FLAGS);
580 if ( !(hash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
581 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
582
583 hash->pProvider = prov;
584
585 if (prov->pFuncs->pCPCreateHash(prov->hPrivate, Algid,
586 key ? key->hPrivate : 0, 0, &hash->hPrivate))
587 {
588 *phHash = (HCRYPTHASH)hash;
589 return TRUE;
590 }
591
592 /* CSP error! */
593 CRYPT_Free(hash);
594 return FALSE;
595 }
596
597 /******************************************************************************
598 * CryptDecrypt (ADVAPI32.@)
599 */
600 BOOL WINAPI CryptDecrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final,
601 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
602 {
603 PCRYPTPROV prov;
604 PCRYPTKEY key = (PCRYPTKEY)hKey;
605 PCRYPTHASH hash = (PCRYPTHASH)hHash;
606
607 TRACE("(0x%lx, 0x%lx, %d, %08lx, %p, %p)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen);
608
609 if (!key || !pbData || !pdwDataLen)
610 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
611
612 prov = key->pProvider;
613 return prov->pFuncs->pCPDecrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
614 Final, dwFlags, pbData, pdwDataLen);
615 }
616
617 /******************************************************************************
618 * CryptDeriveKey (ADVAPI32.@)
619 */
620 BOOL WINAPI CryptDeriveKey (HCRYPTPROV hProv, ALG_ID Algid, HCRYPTHASH hBaseData,
621 DWORD dwFlags, HCRYPTKEY *phKey)
622 {
623 PCRYPTPROV prov = (PCRYPTPROV)hProv;
624 PCRYPTHASH hash = (PCRYPTHASH)hBaseData;
625 PCRYPTKEY key;
626
627 TRACE("(0x%lx, 0x%08x, 0x%lx, 0x%08lx, %p)\n", hProv, Algid, hBaseData, dwFlags, phKey);
628
629 if (!prov || !hash)
630 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
631 if (!phKey)
632 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
633 if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
634 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
635
636 key->pProvider = prov;
637 if (prov->pFuncs->pCPDeriveKey(prov->hPrivate, Algid, hash->hPrivate, dwFlags, &key->hPrivate))
638 {
639 *phKey = (HCRYPTKEY)key;
640 return TRUE;
641 }
642
643 /* CSP error! */
644 CRYPT_Free(key);
645 return FALSE;
646 }
647
648 /******************************************************************************
649 * CryptDestroyHash (ADVAPI32.@)
650 */
651 BOOL WINAPI CryptDestroyHash (HCRYPTHASH hHash)
652 {
653 PCRYPTHASH hash = (PCRYPTHASH)hHash;
654 PCRYPTPROV prov;
655 BOOL ret;
656
657 TRACE("(0x%lx)\n", hHash);
658
659 if (!hash)
660 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
661
662 prov = hash->pProvider;
663 ret = prov->pFuncs->pCPDestroyHash(prov->hPrivate, hash->hPrivate);
664 CRYPT_Free(hash);
665 return ret;
666 }
667
668 /******************************************************************************
669 * CryptDestroyKey (ADVAPI32.@)
670 */
671 BOOL WINAPI CryptDestroyKey (HCRYPTKEY hKey)
672 {
673 PCRYPTKEY key = (PCRYPTKEY)hKey;
674 PCRYPTPROV prov;
675 BOOL ret;
676
677 TRACE("(0x%lx)\n", hKey);
678
679 if (!key)
680 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
681
682 prov = key->pProvider;
683 ret = prov->pFuncs->pCPDestroyKey(prov->hPrivate, key->hPrivate);
684 CRYPT_Free(key);
685 return ret;
686 }
687
688 /******************************************************************************
689 * CryptDuplicateHash (ADVAPI32.@)
690 */
691 BOOL WINAPI CryptDuplicateHash (HCRYPTHASH hHash, DWORD *pdwReserved,
692 DWORD dwFlags, HCRYPTHASH *phHash)
693 {
694 PCRYPTPROV prov;
695 PCRYPTHASH orghash, newhash;
696
697 TRACE("(0x%lx, %p, %08ld, %p)\n", hHash, pdwReserved, dwFlags, phHash);
698
699 orghash = (PCRYPTHASH)hHash;
700 if (!orghash || pdwReserved || !phHash)
701 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
702
703 prov = orghash->pProvider;
704 if (!prov->pFuncs->pCPDuplicateHash)
705 CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED);
706
707 if ( !(newhash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
708 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
709
710 newhash->pProvider = prov;
711 if (prov->pFuncs->pCPDuplicateHash(prov->hPrivate, orghash->hPrivate, pdwReserved, dwFlags, &newhash->hPrivate))
712 {
713 *phHash = (HCRYPTHASH)newhash;
714 return TRUE;
715 }
716 CRYPT_Free(newhash);
717 return FALSE;
718 }
719
720 /******************************************************************************
721 * CryptDuplicateKey (ADVAPI32.@)
722 */
723 BOOL WINAPI CryptDuplicateKey (HCRYPTKEY hKey, DWORD *pdwReserved, DWORD dwFlags, HCRYPTKEY *phKey)
724 {
725 PCRYPTPROV prov;
726 PCRYPTKEY orgkey, newkey;
727
728 TRACE("(0x%lx, %p, %08ld, %p)\n", hKey, pdwReserved, dwFlags, phKey);
729
730 orgkey = (PCRYPTKEY)hKey;
731 if (!orgkey || pdwReserved || !phKey)
732 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
733
734 prov = orgkey->pProvider;
735 if (!prov->pFuncs->pCPDuplicateKey)
736 CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED);
737
738 if ( !(newkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
739 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
740
741 newkey->pProvider = prov;
742 if (prov->pFuncs->pCPDuplicateKey(prov->hPrivate, orgkey->hPrivate, pdwReserved, dwFlags, &newkey->hPrivate))
743 {
744 *phKey = (HCRYPTKEY)newkey;
745 return TRUE;
746 }
747 CRYPT_Free(newkey);
748 return FALSE;
749 }
750
751 /******************************************************************************
752 * CryptEncrypt (ADVAPI32.@)
753 */
754 BOOL WINAPI CryptEncrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final,
755 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen)
756 {
757 PCRYPTPROV prov;
758 PCRYPTKEY key = (PCRYPTKEY)hKey;
759 PCRYPTHASH hash = (PCRYPTHASH)hHash;
760
761 TRACE("(0x%lx, 0x%lx, %d, %08ld, %p, %p, %ld)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen, dwBufLen);
762
763 if (!key || !pdwDataLen)
764 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
765
766 prov = key->pProvider;
767 return prov->pFuncs->pCPEncrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
768 Final, dwFlags, pbData, pdwDataLen, dwBufLen);
769 }
770
771 /******************************************************************************
772 * CryptEnumProvidersA (ADVAPI32.@)
773 */
774 BOOL WINAPI CryptEnumProvidersA (DWORD dwIndex, DWORD *pdwReserved,
775 DWORD dwFlags, DWORD *pdwProvType, LPSTR pszProvName, DWORD *pcbProvName)
776 {
777 HKEY hKey;
778
779 TRACE("(%ld, %p, %ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
780 pdwProvType, pszProvName, pcbProvName);
781
782 if (pdwReserved || !pcbProvName) CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
783 if (dwFlags) CRYPT_ReturnLastError(NTE_BAD_FLAGS);
784
785 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\Defaults\\Provider", &hKey))
786 CRYPT_ReturnLastError(NTE_FAIL);
787
788 if (!pszProvName)
789 {
790 DWORD numkeys;
791 RegQueryInfoKeyA(hKey, NULL, NULL, NULL, &numkeys, pcbProvName, NULL, NULL, NULL, NULL, NULL, NULL);
792 (*pcbProvName)++;
793 if (dwIndex >= numkeys)
794 CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS);
795 } else {
796 DWORD size = sizeof(DWORD);
797 HKEY subkey;
798 if (RegEnumKeyA(hKey, dwIndex, pszProvName, *pcbProvName))
799 return FALSE;
800 if (RegOpenKeyA(hKey, pszProvName, &subkey))
801 return FALSE;
802 if (RegQueryValueExA(subkey, "Type", NULL, NULL, (BYTE*)pdwProvType, &size))
803 return FALSE;
804 RegCloseKey(subkey);
805 }
806 RegCloseKey(hKey);
807 return TRUE;
808 }
809
810 /******************************************************************************
811 * CryptEnumProvidersW (ADVAPI32.@)
812 */
813 BOOL WINAPI CryptEnumProvidersW (DWORD dwIndex, DWORD *pdwReserved,
814 DWORD dwFlags, DWORD *pdwProvType, LPWSTR pszProvName, DWORD *pcbProvName)
815 {
816 PSTR str = NULL;
817 DWORD strlen;
818 BOOL ret; /* = FALSE; */
819
820 TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
821 pdwProvType, pszProvName, pcbProvName);
822
823 strlen = *pcbProvName / sizeof(WCHAR);
824 if ( pszProvName && (str = CRYPT_Alloc(strlen)) )
825 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
826 ret = CryptEnumProvidersA(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &strlen);
827 if (str)
828 {
829 CRYPT_ANSIToUnicode(str, &pszProvName, *pcbProvName);
830 CRYPT_Free(str);
831 }
832 *pcbProvName = strlen * sizeof(WCHAR);
833 return ret;
834 }
835
836 /******************************************************************************
837 * CryptEnumProviderTypesA (ADVAPI32.@)
838 */
839 BOOL WINAPI CryptEnumProviderTypesA (DWORD dwIndex, DWORD *pdwReserved,
840 DWORD dwFlags, DWORD *pdwProvType, LPSTR pszTypeName, DWORD *pcbTypeName)
841 {
842 HKEY hKey, hSubkey;
843 DWORD keylen, numkeys;
844 PSTR keyname, ch;
845
846 TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex, pdwReserved,
847 dwFlags, pdwProvType, pszTypeName, pcbTypeName);
848
849 if (pdwReserved || !pdwProvType || !pcbTypeName)
850 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
851 if (dwFlags) CRYPT_ReturnLastError(NTE_BAD_FLAGS);
852
853 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\Defaults\\Provider Types", &hKey))
854 return FALSE;
855
856 RegQueryInfoKeyA(hKey, NULL, NULL, NULL, &numkeys, &keylen, NULL, NULL, NULL, NULL, NULL, NULL);
857 if (dwIndex >= numkeys)
858 CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS);
859 keylen++;
860 if ( !(keyname = CRYPT_Alloc(keylen)) )
861 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
862 if ( RegEnumKeyA(hKey, dwIndex, keyname, keylen) ) {
863 CRYPT_Free(keyname);
864 return FALSE;
865 }
866 RegOpenKeyA(hKey, keyname, &hSubkey);
867 ch = keyname + strlen(keyname);
868 /* Convert "Type 000" to 0, etc/ */
869 *pdwProvType = *(--ch) - '0';
870 *pdwProvType += (*(--ch) - '0') * 10;
871 *pdwProvType += (*(--ch) - '0') * 100;
872 CRYPT_Free(keyname);
873 RegQueryValueA(hSubkey, "TypeName", pszTypeName, pcbTypeName);
874 RegCloseKey(hSubkey);
875 RegCloseKey(hKey);
876 return TRUE;
877 }
878
879 /******************************************************************************
880 * CryptEnumProviderTypesW (ADVAPI32.@)
881 */
882 BOOL WINAPI CryptEnumProviderTypesW (DWORD dwIndex, DWORD *pdwReserved,
883 DWORD dwFlags, DWORD *pdwProvType, LPWSTR pszTypeName, DWORD *pcbTypeName)
884 {
885 PSTR str = NULL;
886 DWORD strlen;
887 BOOL ret;
888
889 TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
890 pdwProvType, pszTypeName, pcbTypeName);
891 strlen = *pcbTypeName / sizeof(WCHAR);
892 if ( pszTypeName && (str = CRYPT_Alloc(strlen)) )
893 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
894 ret = CryptEnumProviderTypesA(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &strlen);
895 if (str)
896 {
897 CRYPT_ANSIToUnicode(str, &pszTypeName, *pcbTypeName);
898 CRYPT_Free(str);
899 }
900 *pcbTypeName = strlen * sizeof(WCHAR);
901 return ret;
902 }
903
904 /******************************************************************************
905 * CryptExportKey (ADVAPI32.@)
906 */
907 BOOL WINAPI CryptExportKey (HCRYPTKEY hKey, HCRYPTKEY hExpKey, DWORD dwBlobType,
908 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
909 {
910 PCRYPTPROV prov;
911 PCRYPTKEY key = (PCRYPTKEY)hKey, expkey = (PCRYPTKEY)hExpKey;
912
913 TRACE("(0x%lx, 0x%lx, %ld, %08ld, %p, %p)\n", hKey, hExpKey, dwBlobType, dwFlags, pbData, pdwDataLen);
914
915 if (!key || pdwDataLen)
916 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
917
918 prov = key->pProvider;
919 return prov->pFuncs->pCPExportKey(prov->hPrivate, key->hPrivate, expkey ? expkey->hPrivate : 0,
920 dwBlobType, dwFlags, pbData, pdwDataLen);
921 }
922
923 /******************************************************************************
924 * CryptGenKey (ADVAPI32.@)
925 */
926 BOOL WINAPI CryptGenKey (HCRYPTPROV hProv, ALG_ID Algid, DWORD dwFlags, HCRYPTKEY *phKey)
927 {
928 PCRYPTPROV prov = (PCRYPTPROV)hProv;
929 PCRYPTKEY key;
930
931 TRACE("(0x%lx, %d, %08ld, %p)\n", hProv, Algid, dwFlags, phKey);
932
933 if (!prov)
934 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
935 if (!phKey)
936 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
937 if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
938 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
939
940 key->pProvider = prov;
941
942 if (prov->pFuncs->pCPGenKey(prov->hPrivate, Algid, dwFlags, &key->hPrivate))
943 {
944 *phKey = (HCRYPTKEY)key;
945 return TRUE;
946 }
947
948 /* CSP error! */
949 CRYPT_Free(key);
950 return FALSE;
951 }
952
953 /******************************************************************************
954 * CryptGetDefaultProviderA (ADVAPI32.@)
955 */
956 BOOL WINAPI CryptGetDefaultProviderA (DWORD dwProvType, DWORD *pdwReserved,
957 DWORD dwFlags, LPSTR pszProvName, DWORD *pcbProvName)
958 {
959 HKEY hKey;
960 PSTR keyname;
961
962 if (pdwReserved || !pcbProvName)
963 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
964 if (dwFlags & ~(CRYPT_USER_DEFAULT | CRYPT_MACHINE_DEFAULT))
965 CRYPT_ReturnLastError(NTE_BAD_FLAGS);
966 if (dwProvType > 999)
967 CRYPT_ReturnLastError(NTE_BAD_PROV_TYPE);
968 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)) )
969 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
970 if (RegOpenKeyA((dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE ,keyname, &hKey))
971 {
972 CRYPT_Free(keyname);
973 CRYPT_ReturnLastError(NTE_PROV_TYPE_NOT_DEF);
974 }
975 CRYPT_Free(keyname);
976 if (RegQueryValueExA(hKey, "Name", NULL, NULL, pszProvName, pcbProvName))
977 {
978 if (GetLastError() != ERROR_MORE_DATA)
979 SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
980 return FALSE;
981 }
982 RegCloseKey(hKey);
983 return TRUE;
984 }
985
986 /******************************************************************************
987 * CryptGetDefaultProviderW (ADVAPI32.@)
988 */
989 BOOL WINAPI CryptGetDefaultProviderW (DWORD dwProvType, DWORD *pdwReserved,
990 DWORD dwFlags, LPWSTR pszProvName, DWORD *pcbProvName)
991 {
992 PSTR str = NULL;
993 DWORD strlen;
994 BOOL ret = FALSE;
995
996 TRACE("(%ld, %p, %08ld, %p, %p)\n", dwProvType, pdwReserved, dwFlags, pszProvName, pcbProvName);
997
998 strlen = *pcbProvName / sizeof(WCHAR);
999 if ( pszProvName && !(str = CRYPT_Alloc(strlen)) )
1000 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1001 ret = CryptGetDefaultProviderA(dwProvType, pdwReserved, dwFlags, str, &strlen);
1002 if (str)
1003 {
1004 CRYPT_ANSIToUnicode(str, &pszProvName, *pcbProvName);
1005 CRYPT_Free(str);
1006 }
1007 *pcbProvName = strlen * sizeof(WCHAR);
1008 return ret;
1009 }
1010
1011 /******************************************************************************
1012 * CryptGetHashParam (ADVAPI32.@)
1013 */
1014 BOOL WINAPI CryptGetHashParam (HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData,
1015 DWORD *pdwDataLen, DWORD dwFlags)
1016 {
1017 PCRYPTPROV prov;
1018 PCRYPTHASH hash = (PCRYPTHASH)hHash;
1019
1020 TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hHash, dwParam, pbData, pdwDataLen, dwFlags);
1021
1022 if (!hash || !pdwDataLen)
1023 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1024
1025 prov = hash->pProvider;
1026 return prov->pFuncs->pCPGetHashParam(prov->hPrivate, hash->hPrivate, dwParam,
1027 pbData, pdwDataLen, dwFlags);
1028 }
1029
1030 /******************************************************************************
1031 * CryptGetKeyParam (ADVAPI32.@)
1032 */
1033 BOOL WINAPI CryptGetKeyParam (HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData,
1034 DWORD *pdwDataLen, DWORD dwFlags)
1035 {
1036 PCRYPTPROV prov;
1037 PCRYPTKEY key = (PCRYPTKEY)hKey;
1038
1039 TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hKey, dwParam, pbData, pdwDataLen, dwFlags);
1040
1041 if (!key || !pdwDataLen)
1042 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1043
1044 prov = key->pProvider;
1045 return prov->pFuncs->pCPGetKeyParam(prov->hPrivate, key->hPrivate, dwParam,
1046 pbData, pdwDataLen, dwFlags);
1047 }
1048
1049 /******************************************************************************
1050 * CryptGetProvParam (ADVAPI32.@)
1051 */
1052 BOOL WINAPI CryptGetProvParam (HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData,
1053 DWORD *pdwDataLen, DWORD dwFlags)
1054 {
1055 PCRYPTPROV prov = (PCRYPTPROV)hProv;
1056
1057 TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hProv, dwParam, pbData, pdwDataLen, dwFlags);
1058
1059 return prov->pFuncs->pCPGetProvParam(prov->hPrivate, dwParam, pbData, pdwDataLen, dwFlags);
1060 }
1061
1062 /******************************************************************************
1063 * CryptGetUserKey (ADVAPI32.@)
1064 */
1065 BOOL WINAPI CryptGetUserKey (HCRYPTPROV hProv, DWORD dwKeySpec, HCRYPTKEY *phUserKey)
1066 {
1067 PCRYPTPROV prov = (PCRYPTPROV)hProv;
1068 PCRYPTKEY key;
1069
1070 TRACE("(0x%lx, %ld, %p)\n", hProv, dwKeySpec, phUserKey);
1071
1072 if (!prov)
1073 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1074 if (!phUserKey)
1075 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1076 if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
1077 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1078
1079 key->pProvider = prov;
1080
1081 if (prov->pFuncs->pCPGetUserKey(prov->hPrivate, dwKeySpec, &key->hPrivate))
1082 {
1083 *phUserKey = (HCRYPTKEY)key;
1084 return TRUE;
1085 }
1086
1087 /* CSP Error */
1088 CRYPT_Free(key);
1089 return FALSE;
1090 }
1091
1092 /******************************************************************************
1093 * CryptHashData (ADVAPI32.@)
1094 */
1095 BOOL WINAPI CryptHashData (HCRYPTHASH hHash, BYTE *pbData, DWORD dwDataLen, DWORD dwFlags)
1096 {
1097 PCRYPTHASH hash = (PCRYPTHASH)hHash;
1098 PCRYPTPROV prov;
1099
1100 TRACE("(0x%lx, %p, %ld, %08ld)\n", hHash, pbData, dwDataLen, dwFlags);
1101
1102 if (!hash)
1103 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1104 if (!pbData || !dwDataLen)
1105 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1106
1107 prov = hash->pProvider;
1108 return prov->pFuncs->pCPHashData(prov->hPrivate, hash->hPrivate, pbData, dwDataLen, dwFlags);
1109 }
1110
1111 /******************************************************************************
1112 * CryptHashSessionKey (ADVAPI32.@)
1113 */
1114 BOOL WINAPI CryptHashSessionKey (HCRYPTHASH hHash, HCRYPTKEY hKey, DWORD dwFlags)
1115 {
1116 PCRYPTHASH hash = (PCRYPTHASH)hHash;
1117 PCRYPTKEY key = (PCRYPTKEY)hKey;
1118 PCRYPTPROV prov;
1119
1120 TRACE("(0x%lx, 0x%lx, %08ld)\n", hHash, hKey, dwFlags);
1121
1122 if (!hash || !key)
1123 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1124
1125 prov = hash->pProvider;
1126 return prov->pFuncs->pCPHashSessionKey(prov->hPrivate, hash->hPrivate, key->hPrivate, dwFlags);
1127 }
1128
1129 /******************************************************************************
1130 * CryptImportKey (ADVAPI32.@)
1131 */
1132 BOOL WINAPI CryptImportKey (HCRYPTPROV hProv, BYTE *pbData, DWORD dwDataLen,
1133 HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey)
1134 {
1135 PCRYPTPROV prov = (PCRYPTPROV)hProv;
1136 PCRYPTKEY pubkey = (PCRYPTKEY)hPubKey, importkey;
1137
1138 TRACE("(0x%lx, %p, %ld, 0x%lx, %08ld, %p)\n", hProv, pbData, dwDataLen, hPubKey, dwFlags, phKey);
1139
1140 if (!prov || !pbData || !dwDataLen || !phKey)
1141 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1142
1143 if ( !(importkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
1144 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1145
1146 importkey->pProvider = prov;
1147 if (prov->pFuncs->pCPImportKey(prov->hPrivate, pbData, dwDataLen,
1148 pubkey ? pubkey->hPrivate : 0, dwFlags, &importkey->hPrivate))
1149 {
1150 *phKey = (HCRYPTKEY)importkey;
1151 return TRUE;
1152 }
1153
1154 CRYPT_Free(importkey);
1155 return FALSE;
1156 }
1157
1158 /******************************************************************************
1159 * CryptSignHashA
1160 *
1161 * Note: Since the sDesciption (string) is supposed to be NULL and
1162 * is only retained for compatibility no string conversions are required
1163 * and only one implementation is required for both ANSI and Unicode.
1164 * We still need to export both:
1165 *
1166 * CryptSignHashA (ADVAPI32.@)
1167 * CryptSignHashW (ADVAPI32.@)
1168 */
1169 BOOL WINAPI CryptSignHashA (HCRYPTHASH hHash, DWORD dwKeySpec, LPCSTR sDescription,
1170 DWORD dwFlags, BYTE *pbSignature, DWORD *pdwSigLen)
1171 {
1172 PCRYPTHASH hash = (PCRYPTHASH)hHash;
1173 PCRYPTPROV prov;
1174
1175 TRACE("(0x%lx, %ld, %08ld, %p, %p)\n", hHash, dwKeySpec, dwFlags, pbSignature, pdwSigLen);
1176 if (sDescription)
1177 WARN("The sDescription parameter is not supported (and no longer used). Ignoring.\n");
1178
1179 if (!hash)
1180 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1181 if (!pdwSigLen)
1182 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1183
1184 prov = hash->pProvider;
1185 return prov->pFuncs->pCPSignHash(prov->hPrivate, hash->hPrivate, dwKeySpec, NULL,
1186 dwFlags, pbSignature, pdwSigLen);
1187 }
1188
1189 /******************************************************************************
1190 * CryptSetHashParam (ADVAPI32.@)
1191 */
1192 BOOL WINAPI CryptSetHashParam (HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
1193 {
1194 PCRYPTPROV prov;
1195 PCRYPTHASH hash = (PCRYPTHASH)hHash;
1196
1197 TRACE("(0x%lx, %ld, %p, %08ld)\n", hHash, dwParam, pbData, dwFlags);
1198
1199 if (!hash || !pbData)
1200 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1201
1202 prov = hash->pProvider;
1203 return prov->pFuncs->pCPSetHashParam(prov->hPrivate, hash->hPrivate,
1204 dwParam, pbData, dwFlags);
1205 }
1206
1207 /******************************************************************************
1208 * CryptSetKeyParam (ADVAPI32.@)
1209 */
1210 BOOL WINAPI CryptSetKeyParam (HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
1211 {
1212 PCRYPTPROV prov;
1213 PCRYPTKEY key = (PCRYPTKEY)hKey;
1214
1215 TRACE("(0x%lx, %ld, %p, %08ld)\n", hKey, dwParam, pbData, dwFlags);
1216
1217 if (!key || !pbData)
1218 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1219
1220 prov = key->pProvider;
1221 return prov->pFuncs->pCPSetKeyParam(prov->hPrivate, key->hPrivate,
1222 dwParam, pbData, dwFlags);
1223 }
1224
1225 /******************************************************************************
1226 * CryptSetProviderA (ADVAPI32.@)
1227 */
1228 BOOL WINAPI CryptSetProviderA (LPCSTR pszProvName, DWORD dwProvType)
1229 {
1230 TRACE("(%s, %ld)\n", pszProvName, dwProvType);
1231 return CryptSetProviderExA(pszProvName, dwProvType, NULL, CRYPT_USER_DEFAULT);
1232 }
1233
1234 /******************************************************************************
1235 * CryptSetProviderW (ADVAPI32.@)
1236 */
1237 BOOL WINAPI CryptSetProviderW (LPCWSTR pszProvName, DWORD dwProvType)
1238 {
1239 TRACE("(%s, %ld)\n", debugstr_w(pszProvName), dwProvType);
1240 return CryptSetProviderExW(pszProvName, dwProvType, NULL, CRYPT_USER_DEFAULT);
1241 }
1242
1243 /******************************************************************************
1244 * CryptSetProviderExA (ADVAPI32.@)
1245 */
1246 BOOL WINAPI CryptSetProviderExA (LPCSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags)
1247 {
1248 HKEY hKey;
1249 PSTR keyname;
1250
1251 TRACE("(%s, %ld, %p, %08ld)\n", pszProvName, dwProvType, pdwReserved, dwFlags);
1252
1253 if (!pszProvName || pdwReserved)
1254 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1255 if (dwProvType > MAXPROVTYPES)
1256 CRYPT_ReturnLastError(NTE_BAD_PROV_TYPE);
1257 if (dwFlags & ~(CRYPT_MACHINE_DEFAULT | CRYPT_USER_DEFAULT | CRYPT_DELETE_DEFAULT)
1258 || dwFlags == CRYPT_DELETE_DEFAULT)
1259 CRYPT_ReturnLastError(NTE_BAD_FLAGS);
1260
1261 if (dwFlags & CRYPT_DELETE_DEFAULT)
1262 {
1263 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)) )
1264 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1265 RegDeleteKeyA( (dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, keyname);
1266 CRYPT_Free(keyname);
1267 return TRUE;
1268 }
1269
1270 if ( !(keyname = CRYPT_GetProvKeyName(pszProvName)) )
1271 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1272 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, keyname, &hKey))
1273 {
1274 CRYPT_Free(keyname);
1275 CRYPT_ReturnLastError(NTE_BAD_PROVIDER);
1276 }
1277 CRYPT_Free(keyname);
1278 RegCloseKey(hKey);
1279 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)) )
1280 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1281 RegCreateKeyA( (dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, keyname, &hKey);
1282 CRYPT_Free(keyname);
1283 if (RegSetValueExA(hKey, "Name", 0, REG_SZ, pszProvName, strlen(pszProvName) +1))
1284 return FALSE;
1285 return TRUE;
1286 }
1287
1288 /******************************************************************************
1289 * CryptSetProviderExW (ADVAPI32.@)
1290 */
1291 BOOL WINAPI CryptSetProviderExW (LPCWSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags)
1292 {
1293 BOOL ret = FALSE;
1294 PSTR str = NULL;
1295
1296 TRACE("(%s, %ld, %p, %08ld)\n", debugstr_w(pszProvName), dwProvType, pdwReserved, dwFlags);
1297
1298 if (CRYPT_UnicodeToANSI(pszProvName, &str, -1))
1299 {
1300 ret = CryptSetProviderExA(str, dwProvType, pdwReserved, dwFlags);
1301 CRYPT_Free(str);
1302 }
1303 return ret;
1304 }
1305
1306 /******************************************************************************
1307 * CryptSetProvParam (ADVAPI32.@)
1308 */
1309 BOOL WINAPI CryptSetProvParam (HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
1310 {
1311 PCRYPTPROV prov = (PCRYPTPROV)hProv;
1312
1313 TRACE("(0x%lx, %ld, %p, %08ld)\n", hProv, dwParam, pbData, dwFlags);
1314
1315 if (!prov)
1316 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1317 if (dwFlags & PP_USE_HARDWARE_RNG)
1318 {
1319 FIXME("PP_USE_HARDWARE_RNG: What do I do with this?\n");
1320 FIXME("\tLetting the CSP decide.\n");
1321 }
1322 if (dwFlags & PP_CLIENT_HWND)
1323 {
1324 /* FIXME: Should verify the parameter */
1325 if (pbData /* && IsWindow((HWND)pbData) */)
1326 {
1327 crypt_hWindow = (HWND)(pbData);
1328 return TRUE;
1329 } else {
1330 SetLastError(ERROR_INVALID_PARAMETER);
1331 return FALSE;
1332 }
1333 }
1334 /* All other flags go to the CSP */
1335 return prov->pFuncs->pCPSetProvParam(prov->hPrivate, dwParam, pbData, dwFlags);
1336 }
1337
1338 /******************************************************************************
1339 * CryptVerifySignatureA
1340 *
1341 * Note: Since the sDesciption (string) is supposed to be NULL and
1342 * is only retained for compatibility no string conversions are required
1343 * and only one implementation is required for both ANSI and Unicode.
1344 * We still need to export both:
1345 *
1346 * CryptVerifySignatureA (ADVAPI32.@)
1347 * CryptVerifySignatureW (ADVAPI32.@)
1348 */
1349 BOOL WINAPI CryptVerifySignatureA (HCRYPTHASH hHash, BYTE *pbSignature, DWORD dwSigLen,
1350 HCRYPTKEY hPubKey, LPCSTR sDescription, DWORD dwFlags)
1351 {
1352 PCRYPTHASH hash = (PCRYPTHASH)hHash;
1353 PCRYPTKEY key = (PCRYPTKEY)hPubKey;
1354 PCRYPTPROV prov;
1355
1356 TRACE("(0x%lx, %p, %ld, 0x%lx, %08ld)\n", hHash, pbSignature,
1357 dwSigLen, hPubKey, dwFlags);
1358 if (sDescription)
1359 WARN("The sDescription parameter is not supported (and no longer used). Ignoring.\n");
1360
1361 if (!hash || !key)
1362 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1363 if (!pbSignature || !dwSigLen)
1364 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1365
1366 prov = hash->pProvider;
1367 return prov->pFuncs->pCPVerifySignature(prov->hPrivate, hash->hPrivate, pbSignature, dwSigLen,
1368 key->hPrivate, NULL, dwFlags);
1369 }
1370
1371
1372 /*
1373 These functions have nearly identical prototypes to CryptProtectMemory and CryptUnprotectMemory,
1374 in crypt32.dll.
1375 */
1376
1377 /******************************************************************************
1378 * SystemFunction040 (ADVAPI32.@)
1379 *
1380 * PARAMS:
1381 * memory : pointer to memory to encrypt
1382 * length : length of region to encrypt, in bytes. must be multiple of RTL_ENCRYPT_MEMORY_SIZE
1383 * flags : RTL_ENCRYPT_OPTION_SAME_PROCESS | RTL_ENCRYPT_OPTION_CROSS_PROCESS, | RTL_ENCRYPT_OPTION_SAME_LOGON
1384 * control whether other processes are able to decrypt the memory. The same value must be given
1385 * when decrypting the memory.
1386 */
1387 NTSTATUS WINAPI SystemFunction040(PVOID memory, ULONG length, ULONG flags) /* RtlEncryptMemory */
1388 {
1389 FIXME("(%p, %lx, %lx): stub [RtlEncryptMemory]\n", memory, length, flags);
1390 return STATUS_SUCCESS;
1391 }
1392
1393 /******************************************************************************
1394 * SystemFunction041 (ADVAPI32.@)
1395 *
1396 * PARAMS:
1397 * memory : pointer to memory to decrypt
1398 * length : length of region to decrypt, in bytes. must be multiple of RTL_ENCRYPT_MEMORY_SIZE
1399 * flags : RTL_ENCRYPT_OPTION_SAME_PROCESS | RTL_ENCRYPT_OPTION_CROSS_PROCESS, | RTL_ENCRYPT_OPTION_SAME_LOGON
1400 * control whether other processes are able to decrypt the memory. The same value must be given
1401 * when encrypting the memory.
1402 */
1403 NTSTATUS WINAPI SystemFunction041(PVOID memory, ULONG length, ULONG flags) /* RtlDecryptMemory */
1404 {
1405 FIXME("(%p, %lx, %lx): stub [RtlDecryptMemory]\n", memory, length, flags);
1406 return STATUS_SUCCESS;
1407 }
Maarten's multimedia branch