git.oblomov.eu Git - wine/blob - dlls/advapi32/crypt.c

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