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(DWORD *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         *phHash = (HCRYPTHASH)hash;
 474         if (prov->pFuncs->pCPCreateHash(prov->hPrivate, Algid,
 475                         key ? key->hPrivate : 0, 0, &hash->hPrivate))
 476                 return TRUE;
 477
 478         /* CSP error! */
 479         CRYPT_Free(hash);
 480         return FALSE;
 481 }
 482
 483 /******************************************************************************
 484  * CryptDecrypt (ADVAPI32.@)
 485  */
 486 BOOL WINAPI CryptDecrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final,
 487                 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
 488 {
 489         PCRYPTPROV prov;
 490         PCRYPTKEY key = (PCRYPTKEY)hKey;
 491         PCRYPTHASH hash = (PCRYPTHASH)hHash;
 492
 493         TRACE("(0x%lx, 0x%lx, %d, %08lx, %p, %p)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen);
 494
 495         if (!key || !pbData || !pdwDataLen)
 496                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 497
 498         prov = key->pProvider;
 499         return prov->pFuncs->pCPDecrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
 500                         Final, dwFlags, pbData, pdwDataLen);
 501 }
 502
 503 /******************************************************************************
 504  * CryptDeriveKey (ADVAPI32.@)
 505  */
 506 BOOL WINAPI CryptDeriveKey (HCRYPTPROV hProv, ALG_ID Algid, HCRYPTHASH hBaseData,
 507                 DWORD dwFlags, HCRYPTKEY *phKey)
 508 {
 509         PCRYPTPROV prov = (PCRYPTPROV)hProv;
 510         PCRYPTHASH hash = (PCRYPTHASH)hBaseData;
 511         PCRYPTKEY key;
 512
 513         TRACE("(0x%lx, %d, 0x%ld, %08ld, %p)\n", hProv, Algid, hBaseData, dwFlags, phKey);
 514
 515         if (!prov || !hash)
 516                 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
 517         if (!phKey)
 518                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 519         if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
 520                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
 521
 522         key->pProvider = prov;
 523         if (prov->pFuncs->pCPDeriveKey(prov->hPrivate, Algid, hash->hPrivate, dwFlags, &key->hPrivate))
 524                 return TRUE;
 525
 526         /* CSP error! */
 527         CRYPT_Free(key);
 528         return FALSE;
 529 }
 530
 531 /******************************************************************************
 532  * CryptDestroyHash (ADVAPI32.@)
 533  */
 534 BOOL WINAPI CryptDestroyHash (HCRYPTHASH hHash)
 535 {
 536         PCRYPTHASH hash = (PCRYPTHASH)hHash;
 537         PCRYPTPROV prov;
 538         BOOL ret;
 539
 540         TRACE("(0x%lx)\n", hHash);
 541
 542         if (!hash)
 543                 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
 544
 545         prov = hash->pProvider;
 546         ret = prov->pFuncs->pCPDestroyHash(prov->hPrivate, hash->hPrivate);
 547         CRYPT_Free(hash);
 548         return ret;
 549 }
 550
 551 /******************************************************************************
 552  *  CryptDestroyKey (ADVAPI32.@)
 553  */
 554 BOOL WINAPI CryptDestroyKey (HCRYPTKEY hKey)
 555 {
 556         PCRYPTKEY key = (PCRYPTKEY)hKey;
 557         PCRYPTPROV prov;
 558         BOOL ret;
 559
 560         TRACE("(0x%lx)\n", hKey);
 561
 562         if (!key)
 563                 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
 564
 565         prov = key->pProvider;
 566         ret = prov->pFuncs->pCPDestroyKey(prov->hPrivate, key->hPrivate);
 567         CRYPT_Free(key);
 568         return ret;
 569 }
 570
 571 /******************************************************************************
 572  * CryptDuplicateHash (ADVAPI32.@)
 573  */
 574 BOOL WINAPI CryptDuplicateHash (HCRYPTHASH hHash, DWORD *pdwReserved,
 575                 DWORD dwFlags, HCRYPTHASH *phHash)
 576 {
 577         PCRYPTPROV prov;
 578         PCRYPTHASH orghash, newhash;
 579
 580         TRACE("(0x%lx, %p, %08ld, %p)\n", hHash, pdwReserved, dwFlags, phHash);
 581
 582         orghash = (PCRYPTHASH)hHash;
 583         if (!orghash || pdwReserved || !phHash)
 584                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 585
 586         prov = orghash->pProvider;
 587         if (!prov->pFuncs->pCPDuplicateHash)
 588                 CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED);
 589
 590         if ( !(newhash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
 591                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
 592
 593         newhash->pProvider = prov;
 594         if (prov->pFuncs->pCPDuplicateHash(prov->hPrivate, orghash->hPrivate, pdwReserved, dwFlags, &newhash->hPrivate))
 595         {
 596                 *phHash = (HCRYPTHASH)newhash;
 597                 return TRUE;
 598         }
 599         CRYPT_Free(newhash);
 600         return FALSE;
 601 }
 602
 603 /******************************************************************************
 604  * CryptDuplicateKey (ADVAPI32.@)
 605  */
 606 BOOL WINAPI CryptDuplicateKey (HCRYPTKEY hKey, DWORD *pdwReserved, DWORD dwFlags, HCRYPTKEY *phKey)
 607 {
 608         PCRYPTPROV prov;
 609         PCRYPTKEY orgkey, newkey;
 610
 611         TRACE("(0x%lx, %p, %08ld, %p)\n", hKey, pdwReserved, dwFlags, phKey);
 612
 613         orgkey = (PCRYPTKEY)hKey;
 614         if (!orgkey || pdwReserved || !phKey)
 615                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 616
 617         prov = orgkey->pProvider;
 618         if (!prov->pFuncs->pCPDuplicateKey)
 619                 CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED);
 620
 621         if ( !(newkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
 622                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
 623
 624         newkey->pProvider = prov;
 625         if (prov->pFuncs->pCPDuplicateKey(prov->hPrivate, orgkey->hPrivate, pdwReserved, dwFlags, &newkey->hPrivate))
 626         {
 627                 *phKey = (HCRYPTKEY)newkey;
 628                 return TRUE;
 629         }
 630         CRYPT_Free(newkey);
 631         return FALSE;
 632 }
 633
 634 /******************************************************************************
 635  * CryptEncrypt (ADVAPI32.@)
 636  */
 637 BOOL WINAPI CryptEncrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final,
 638                 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen)
 639 {
 640         PCRYPTPROV prov;
 641         PCRYPTKEY key = (PCRYPTKEY)hKey;
 642         PCRYPTHASH hash = (PCRYPTHASH)hHash;
 643
 644         TRACE("(0x%lx, 0x%lx, %d, %08ld, %p, %p, %ld)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen, dwBufLen);
 645
 646         if (!key || !pdwDataLen)
 647                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 648
 649         prov = key->pProvider;
 650         return prov->pFuncs->pCPEncrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
 651                         Final, dwFlags, pbData, pdwDataLen, dwBufLen);
 652 }
 653
 654 /******************************************************************************
 655  * CryptEnumProvidersA (ADVAPI32.@)
 656  */
 657 BOOL WINAPI CryptEnumProvidersA (DWORD dwIndex, DWORD *pdwReserved,
 658                 DWORD dwFlags, DWORD *pdwProvType, LPSTR pszProvName, DWORD *pcbProvName)
 659 {
 660         HKEY hKey;
 661
 662         TRACE("(%ld, %p, %ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
 663                         pdwProvType, pszProvName, pcbProvName);
 664
 665         if (pdwReserved || !pcbProvName) CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 666         if (dwFlags) CRYPT_ReturnLastError(NTE_BAD_FLAGS);
 667
 668         if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\Defaults\\Provider", &hKey))
 669                 CRYPT_ReturnLastError(NTE_FAIL);
 670
 671         if (!pszProvName)
 672         {
 673                 DWORD numkeys;
 674                 RegQueryInfoKeyA(hKey, NULL, NULL, NULL, &numkeys, pcbProvName, NULL, NULL, NULL, NULL, NULL, NULL);
 675                 (*pcbProvName)++;
 676                 if (dwIndex >= numkeys)
 677                         CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS);
 678         } else {
 679                 DWORD size = sizeof(DWORD);
 680                 HKEY subkey;
 681                 if (RegEnumKeyA(hKey, dwIndex, pszProvName, *pcbProvName))
 682                         return FALSE;
 683                 if (RegOpenKeyA(hKey, pszProvName, &subkey))
 684                         return FALSE;
 685                 if (RegQueryValueExA(subkey, "Type", NULL, NULL, (BYTE*)pdwProvType, &size))
 686                         return FALSE;
 687                 RegCloseKey(subkey);
 688         }
 689         RegCloseKey(hKey);
 690         return TRUE;
 691 }
 692
 693 /******************************************************************************
 694  * CryptEnumProvidersW (ADVAPI32.@)
 695  */
 696 BOOL WINAPI CryptEnumProvidersW (DWORD dwIndex, DWORD *pdwReserved,
 697                 DWORD dwFlags, DWORD *pdwProvType, LPWSTR pszProvName, DWORD *pcbProvName)
 698 {
 699         PSTR str = NULL;
 700         DWORD strlen;
 701         BOOL ret; /* = FALSE; */
 702
 703         TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
 704                         pdwProvType, pszProvName, pcbProvName);
 705
 706         strlen = *pcbProvName / sizeof(WCHAR);
 707         if ( pszProvName && (str = CRYPT_Alloc(strlen)) )
 708                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
 709         ret = CryptEnumProvidersA(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &strlen);
 710         if (str)
 711         {
 712                 CRYPT_ANSIToUnicode(str, &pszProvName, *pcbProvName);
 713                 CRYPT_Free(str);
 714         }
 715         *pcbProvName = strlen * sizeof(WCHAR);
 716         return ret;
 717 }
 718
 719 /******************************************************************************
 720  * CryptEnumProviderTypesA (ADVAPI32.@)
 721  */
 722 BOOL WINAPI CryptEnumProviderTypesA (DWORD dwIndex, DWORD *pdwReserved,
 723                 DWORD dwFlags, DWORD *pdwProvType, LPSTR pszTypeName, DWORD *pcbTypeName)
 724 {
 725         HKEY hKey, hSubkey;
 726         DWORD keylen, numkeys;
 727         PSTR keyname, ch;
 728
 729         TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex, pdwReserved,
 730                 dwFlags, pdwProvType, pszTypeName, pcbTypeName);
 731
 732         if (pdwReserved || !pdwProvType || !pcbTypeName)
 733                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 734         if (dwFlags) CRYPT_ReturnLastError(NTE_BAD_FLAGS);
 735
 736         if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\Defaults\\Provider Types", &hKey))
 737                 return FALSE;
 738
 739         RegQueryInfoKeyA(hKey, NULL, NULL, NULL, &numkeys, &keylen, NULL, NULL, NULL, NULL, NULL, NULL);
 740         if (dwIndex >= numkeys)
 741                 CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS);
 742         keylen++;
 743         if ( !(keyname = CRYPT_Alloc(keylen)) )
 744                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
 745         if ( RegEnumKeyA(hKey, dwIndex, keyname, keylen) )
 746                 return FALSE;
 747         RegOpenKeyA(hKey, keyname, &hSubkey);
 748         ch = keyname + strlen(keyname);
 749         /* Convert "Type 000" to 0, etc/ */
 750         *pdwProvType = *(--ch) - '0';
 751         *pdwProvType += (*(--ch) - '0') * 10;
 752         *pdwProvType += (*(--ch) - '0') * 100;
 753         CRYPT_Free(keyname);
 754         RegQueryValueA(hSubkey, "TypeName", pszTypeName, pcbTypeName);
 755         RegCloseKey(hSubkey);
 756         RegCloseKey(hKey);
 757         return TRUE;
 758 }
 759
 760 /******************************************************************************
 761  * CryptEnumProviderTypesW (ADVAPI32.@)
 762  */
 763 BOOL WINAPI CryptEnumProviderTypesW (DWORD dwIndex, DWORD *pdwReserved,
 764                 DWORD dwFlags, DWORD *pdwProvType, LPWSTR pszTypeName, DWORD *pcbTypeName)
 765 {
 766         PSTR str = NULL;
 767         DWORD strlen;
 768         BOOL ret;
 769
 770         TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
 771                         pdwProvType, pszTypeName, pcbTypeName);
 772         strlen = *pcbTypeName / sizeof(WCHAR);
 773         if ( pszTypeName && (str = CRYPT_Alloc(strlen)) )
 774                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
 775         ret = CryptEnumProviderTypesA(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &strlen);
 776         if (str)
 777         {
 778                 CRYPT_ANSIToUnicode(str, &pszTypeName, *pcbTypeName);
 779                 CRYPT_Free(str);
 780         }
 781         *pcbTypeName = strlen * sizeof(WCHAR);
 782         return ret;
 783 }
 784
 785 /******************************************************************************
 786  * CryptExportKey (ADVAPI32.@)
 787  */
 788 BOOL WINAPI CryptExportKey (HCRYPTKEY hKey, HCRYPTKEY hExpKey, DWORD dwBlobType,
 789                 DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
 790 {
 791         PCRYPTPROV prov;
 792         PCRYPTKEY key = (PCRYPTKEY)hKey, expkey = (PCRYPTKEY)hExpKey;
 793
 794         TRACE("(0x%lx, 0x%lx, %ld, %08ld, %p, %p)\n", hKey, hExpKey, dwBlobType, dwFlags, pbData, pdwDataLen);
 795
 796         if (!key || pdwDataLen)
 797                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 798
 799         prov = key->pProvider;
 800         return prov->pFuncs->pCPExportKey(prov->hPrivate, key->hPrivate, expkey ? expkey->hPrivate : 0,
 801                         dwBlobType, dwFlags, pbData, pdwDataLen);
 802 }
 803
 804 /******************************************************************************
 805  * CryptGenKey (ADVAPI32.@)
 806  */
 807 BOOL WINAPI CryptGenKey (HCRYPTPROV hProv, ALG_ID Algid, DWORD dwFlags, HCRYPTKEY *phKey)
 808 {
 809         PCRYPTPROV prov = (PCRYPTPROV)hProv;
 810         PCRYPTKEY key;
 811
 812         TRACE("(0x%lx, %d, %08ld, %p)\n", hProv, Algid, dwFlags, phKey);
 813
 814         if (!prov)
 815                 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
 816         if (!phKey)
 817                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 818         if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
 819                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
 820
 821         key->pProvider = prov;
 822
 823         *phKey = (HCRYPTKEY)key;
 824         if (prov->pFuncs->pCPGenKey(prov->hPrivate, Algid, dwFlags, &key->hPrivate))
 825                 return TRUE;
 826
 827         /* CSP error! */
 828         CRYPT_Free(key);
 829         return FALSE;
 830 }
 831
 832 /******************************************************************************
 833  * CryptGetDefaultProviderA (ADVAPI32.@)
 834  */
 835 BOOL WINAPI CryptGetDefaultProviderA (DWORD dwProvType, DWORD *pdwReserved,
 836                 DWORD dwFlags, LPSTR pszProvName, DWORD *pcbProvName)
 837 {
 838         HKEY hKey;
 839         PSTR keyname;
 840
 841         if (pdwReserved || !pcbProvName)
 842                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 843         if (dwFlags & ~(CRYPT_USER_DEFAULT | CRYPT_MACHINE_DEFAULT))
 844                 CRYPT_ReturnLastError(NTE_BAD_FLAGS);
 845         if (dwProvType < 0 || dwProvType > 999)
 846                 CRYPT_ReturnLastError(NTE_BAD_PROV_TYPE);
 847         if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)) )
 848                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
 849         if (RegOpenKeyA((dwFlags & CRYPT_USER_DEFAULT) ?  HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE ,keyname, &hKey))
 850         {
 851                 CRYPT_Free(keyname);
 852                 CRYPT_ReturnLastError(NTE_PROV_TYPE_NOT_DEF);
 853         }
 854         CRYPT_Free(keyname);
 855         if (RegQueryValueExA(hKey, "Name", NULL, NULL, pszProvName, pcbProvName))
 856         {
 857                 if (GetLastError() != ERROR_MORE_DATA)
 858                         SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
 859                 return FALSE;
 860         }
 861         RegCloseKey(hKey);
 862         return TRUE;
 863 }
 864
 865 /******************************************************************************
 866  * CryptGetDefaultProviderW (ADVAPI32.@)
 867  */
 868 BOOL WINAPI CryptGetDefaultProviderW (DWORD dwProvType, DWORD *pdwReserved,
 869                 DWORD dwFlags, LPWSTR pszProvName, DWORD *pcbProvName)
 870 {
 871         PSTR str = NULL;
 872         DWORD strlen;
 873         BOOL ret = FALSE;
 874
 875         TRACE("(%ld, %p, %08ld, %p, %p)\n", dwProvType, pdwReserved, dwFlags, pszProvName, pcbProvName);
 876
 877         strlen = *pcbProvName / sizeof(WCHAR);
 878         if ( pszProvName && !(str = CRYPT_Alloc(strlen)) )
 879                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
 880         ret = CryptGetDefaultProviderA(dwProvType, pdwReserved, dwFlags, str, &strlen);
 881         if (str)
 882         {
 883                 CRYPT_ANSIToUnicode(str, &pszProvName, *pcbProvName);
 884                 CRYPT_Free(str);
 885         }
 886         *pcbProvName = strlen * sizeof(WCHAR);
 887         return ret;
 888 }
 889
 890 /******************************************************************************
 891  * CryptGetHashParam (ADVAPI32.@)
 892  */
 893 BOOL WINAPI CryptGetHashParam (HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData,
 894                 DWORD *pdwDataLen, DWORD dwFlags)
 895 {
 896         PCRYPTPROV prov;
 897         PCRYPTHASH hash = (PCRYPTHASH)hHash;
 898
 899         TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hHash, dwParam, pbData, pdwDataLen, dwFlags);
 900
 901         if (!hash || !pdwDataLen)
 902                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 903
 904         prov = hash->pProvider;
 905         return prov->pFuncs->pCPGetHashParam(prov->hPrivate, hash->hPrivate, dwParam,
 906                         pbData, pdwDataLen, dwFlags);
 907 }
 908
 909 /******************************************************************************
 910  * CryptGetKeyParam (ADVAPI32.@)
 911  */
 912 BOOL WINAPI CryptGetKeyParam (HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData,
 913                 DWORD *pdwDataLen, DWORD dwFlags)
 914 {
 915         PCRYPTPROV prov;
 916         PCRYPTKEY key = (PCRYPTKEY)hKey;
 917
 918         TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hKey, dwParam, pbData, pdwDataLen, dwFlags);
 919
 920         if (!key || !pdwDataLen)
 921                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 922
 923         prov = key->pProvider;
 924         return prov->pFuncs->pCPGetKeyParam(prov->hPrivate, key->hPrivate, dwParam,
 925                         pbData, pdwDataLen, dwFlags);
 926 }
 927
 928 /******************************************************************************
 929  * CryptGetProvParam (ADVAPI32.@)
 930  */
 931 BOOL WINAPI CryptGetProvParam (HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData,
 932                 DWORD *pdwDataLen, DWORD dwFlags)
 933 {
 934         PCRYPTPROV prov = (PCRYPTPROV)hProv;
 935
 936         TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hProv, dwParam, pbData, pdwDataLen, dwFlags);
 937
 938         return prov->pFuncs->pCPGetProvParam(prov->hPrivate, dwParam, pbData, pdwDataLen, dwFlags);
 939 }
 940
 941 /******************************************************************************
 942  * CryptGetUserKey (ADVAPI32.@)
 943  */
 944 BOOL WINAPI CryptGetUserKey (HCRYPTPROV hProv, DWORD dwKeySpec, HCRYPTKEY *phUserKey)
 945 {
 946         PCRYPTPROV prov = (PCRYPTPROV)hProv;
 947         PCRYPTKEY key;
 948
 949         TRACE("(0x%lx, %ld, %p)\n", hProv, dwKeySpec, phUserKey);
 950
 951         if (!prov)
 952                 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
 953         if (!phUserKey)
 954                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 955         if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
 956                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
 957
 958         key->pProvider = prov;
 959
 960         *phUserKey = (HCRYPTKEY)key;
 961         if (prov->pFuncs->pCPGetUserKey(prov->hPrivate, dwKeySpec, &key->hPrivate))
 962                 return TRUE;
 963
 964         /* CSP Error */
 965         CRYPT_Free(key);
 966         return FALSE;
 967 }
 968
 969 /******************************************************************************
 970  * CryptHashData (ADVAPI32.@)
 971  */
 972 BOOL WINAPI CryptHashData (HCRYPTHASH hHash, BYTE *pbData, DWORD dwDataLen, DWORD dwFlags)
 973 {
 974         PCRYPTHASH hash = (PCRYPTHASH)hHash;
 975         PCRYPTPROV prov;
 976
 977         TRACE("(0x%lx, %p, %ld, %08ld)\n", hHash, pbData, dwDataLen, dwFlags);
 978
 979         if (!hash)
 980                 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
 981         if (!pbData || !dwDataLen)
 982                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
 983
 984         prov = hash->pProvider;
 985         return prov->pFuncs->pCPHashData(prov->hPrivate, hash->hPrivate, pbData, dwDataLen, dwFlags);
 986 }
 987
 988 /******************************************************************************
 989  * CryptHashSessionKey (ADVAPI32.@)
 990  */
 991 BOOL WINAPI CryptHashSessionKey (HCRYPTHASH hHash, HCRYPTKEY hKey, DWORD dwFlags)
 992 {
 993         PCRYPTHASH hash = (PCRYPTHASH)hHash;
 994         PCRYPTKEY key = (PCRYPTKEY)hKey;
 995         PCRYPTPROV prov;
 996
 997         TRACE("(0x%lx, 0x%lx, %08ld)\n", hHash, hKey, dwFlags);
 998
 999         if (!hash || !key)
1000                 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1001
1002         prov = hash->pProvider;
1003         return prov->pFuncs->pCPHashSessionKey(prov->hPrivate, hash->hPrivate, key->hPrivate, dwFlags);
1004 }
1005
1006 /******************************************************************************
1007  * CryptImportKey (ADVAPI32.@)
1008  */
1009 BOOL WINAPI CryptImportKey (HCRYPTPROV hProv, BYTE *pbData, DWORD dwDataLen,
1010                 HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey)
1011 {
1012         PCRYPTPROV prov = (PCRYPTPROV)hProv;
1013         PCRYPTKEY pubkey = (PCRYPTKEY)hPubKey, importkey;
1014
1015         TRACE("(0x%lx, %p, %ld, 0x%lx, %08ld, %p)\n", hProv, pbData, dwDataLen, hPubKey, dwFlags, phKey);
1016
1017         if (!prov || !pbData || !dwDataLen || !phKey)
1018                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1019
1020         if ( !(importkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
1021                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1022
1023         importkey->pProvider = prov;
1024         if (prov->pFuncs->pCPImportKey(prov->hPrivate, pbData, dwDataLen,
1025                         pubkey ? pubkey->hPrivate : 0, dwFlags, &importkey->hPrivate))
1026         {
1027                 *phKey = (HCRYPTKEY)importkey;
1028                 return TRUE;
1029         }
1030
1031         CRYPT_Free(importkey);
1032         return FALSE;
1033 }
1034
1035 /******************************************************************************
1036  * CryptSignHashA
1037  *
1038  * Note: Since the sDesciption (string) is supposed to be NULL and
1039  *      is only retained for compatibility no string conversions are required
1040  *      and only one implementation is required for both ANSI and Unicode.
1041  *      We still need to export both:
1042  *
1043  * CryptSignHashA (ADVAPI32.@)
1044  * CryptSignHashW (ADVAPI32.@)
1045  */
1046 BOOL WINAPI CryptSignHashA (HCRYPTHASH hHash, DWORD dwKeySpec, LPCSTR sDescription,
1047                 DWORD dwFlags, BYTE *pbSignature, DWORD *pdwSigLen)
1048 {
1049         PCRYPTHASH hash = (PCRYPTHASH)hHash;
1050         PCRYPTPROV prov;
1051
1052         TRACE("(0x%lx, %ld, %08ld, %p, %p)\n", hHash, dwKeySpec, dwFlags, pbSignature, pdwSigLen);
1053         if (sDescription)
1054                 WARN("The sDescription parameter is not supported (and no longer used).  Ignoring.\n");
1055
1056         if (!hash)
1057                 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1058         if (!pdwSigLen)
1059                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1060
1061         prov = hash->pProvider;
1062         return prov->pFuncs->pCPSignHash(prov->hPrivate, hash->hPrivate, dwKeySpec, NULL,
1063                 dwFlags, pbSignature, pdwSigLen);
1064 }
1065
1066 /******************************************************************************
1067  * CryptSetHashParam (ADVAPI32.@)
1068  */
1069 BOOL WINAPI CryptSetHashParam (HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
1070 {
1071         PCRYPTPROV prov;
1072         PCRYPTHASH hash = (PCRYPTHASH)hHash;
1073
1074         TRACE("(0x%lx, %ld, %p, %08ld)\n", hHash, dwParam, pbData, dwFlags);
1075
1076         if (!hash || !pbData)
1077                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1078
1079         prov = hash->pProvider;
1080         return prov->pFuncs->pCPSetHashParam(prov->hPrivate, hash->hPrivate,
1081                         dwParam, pbData, dwFlags);
1082 }
1083
1084 /******************************************************************************
1085  * CryptSetKeyParam (ADVAPI32.@)
1086  */
1087 BOOL WINAPI CryptSetKeyParam (HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
1088 {
1089         PCRYPTPROV prov;
1090         PCRYPTKEY key = (PCRYPTKEY)hKey;
1091
1092         TRACE("(0x%lx, %ld, %p, %08ld)\n", hKey, dwParam, pbData, dwFlags);
1093
1094         if (!key || !pbData)
1095                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1096
1097         prov = key->pProvider;
1098         return prov->pFuncs->pCPSetKeyParam(prov->hPrivate, key->hPrivate,
1099                         dwParam, pbData, dwFlags);
1100 }
1101
1102 /******************************************************************************
1103  * CryptSetProviderA (ADVAPI32.@)
1104  */
1105 BOOL WINAPI CryptSetProviderA (LPCSTR pszProvName, DWORD dwProvType)
1106 {
1107         TRACE("(%s, %ld)\n", pszProvName, dwProvType);
1108         return CryptSetProviderExA(pszProvName, dwProvType, NULL, CRYPT_USER_DEFAULT);
1109 }
1110
1111 /******************************************************************************
1112  * CryptSetProviderW (ADVAPI32.@)
1113  */
1114 BOOL WINAPI CryptSetProviderW (LPCWSTR pszProvName, DWORD dwProvType)
1115 {
1116         TRACE("(%s, %ld)\n", debugstr_w(pszProvName), dwProvType);
1117         return CryptSetProviderExW(pszProvName, dwProvType, NULL, CRYPT_USER_DEFAULT);
1118 }
1119
1120 /******************************************************************************
1121  * CryptSetProviderExA (ADVAPI32.@)
1122  */
1123 BOOL WINAPI CryptSetProviderExA (LPCSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags)
1124 {
1125         HKEY hKey;
1126         PSTR keyname;
1127
1128         TRACE("(%s, %ld, %p, %08ld)\n", pszProvName, dwProvType, pdwReserved, dwFlags);
1129
1130         if (!pszProvName || pdwReserved)
1131                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1132         if (dwProvType < 0 || dwProvType > MAXPROVTYPES)
1133                 CRYPT_ReturnLastError(NTE_BAD_PROV_TYPE);
1134         if (dwFlags & ~(CRYPT_MACHINE_DEFAULT | CRYPT_USER_DEFAULT | CRYPT_DELETE_DEFAULT)
1135                         || dwFlags == CRYPT_DELETE_DEFAULT)
1136                 CRYPT_ReturnLastError(NTE_BAD_FLAGS);
1137
1138         if (dwFlags & CRYPT_DELETE_DEFAULT)
1139         {
1140                 if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)) )
1141                         CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1142                 RegDeleteKeyA( (dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, keyname);
1143                 CRYPT_Free(keyname);
1144                 return TRUE;
1145         }
1146
1147         if ( !(keyname = CRYPT_GetProvKeyName(pszProvName)) )
1148                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1149         if (RegOpenKeyA(HKEY_LOCAL_MACHINE, keyname, &hKey))
1150         {
1151                 CRYPT_Free(keyname);
1152                 CRYPT_ReturnLastError(NTE_BAD_PROVIDER);
1153         }
1154         CRYPT_Free(keyname);
1155         RegCloseKey(hKey);
1156         if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)) )
1157                 CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
1158         RegCreateKeyA( (dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, keyname, &hKey);
1159         CRYPT_Free(keyname);
1160         if (RegSetValueExA(hKey, "Name", 0, REG_SZ, pszProvName, strlen(pszProvName) +1))
1161                 return FALSE;
1162         return TRUE;
1163 }
1164
1165 /******************************************************************************
1166  * CryptSetProviderExW (ADVAPI32.@)
1167  */
1168 BOOL WINAPI CryptSetProviderExW (LPCWSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags)
1169 {
1170         BOOL ret = FALSE;
1171         PSTR str = NULL;
1172
1173         TRACE("(%s, %ld, %p, %08ld)\n", debugstr_w(pszProvName), dwProvType, pdwReserved, dwFlags);
1174
1175         if (CRYPT_UnicodeToANSI(pszProvName, &str, -1))
1176         {
1177                 ret = CryptSetProviderExA(str, dwProvType, pdwReserved, dwFlags);
1178                 CRYPT_Free(str);
1179         }
1180         return ret;
1181 }
1182
1183 /******************************************************************************
1184  * CryptSetProvParam (ADVAPI32.@)
1185  */
1186 BOOL WINAPI CryptSetProvParam (HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
1187 {
1188         PCRYPTPROV prov = (PCRYPTPROV)hProv;
1189
1190         TRACE("(0x%lx, %ld, %p, %08ld)\n", hProv, dwParam, pbData, dwFlags);
1191
1192         if (!prov)
1193                 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1194         if (dwFlags & PP_USE_HARDWARE_RNG)
1195         {
1196                 FIXME("PP_USE_HARDWARE_RNG: What do I do with this?\n");
1197                 FIXME("\tLetting the CSP decide.\n");
1198         }
1199         if (dwFlags & PP_CLIENT_HWND)
1200         {
1201                 /* FIXME: Should verify the parameter */
1202                 if (pbData /* && IsWindow((HWND)pbData) */)
1203                 {
1204                         crypt_hWindow = (HWND)(pbData);
1205                         return TRUE;
1206                 } else {
1207                         SetLastError(ERROR_INVALID_PARAMETER);
1208                         return FALSE;
1209                 }
1210         }
1211         /* All other flags go to the CSP */
1212         return prov->pFuncs->pCPSetProvParam(prov->hPrivate, dwParam, pbData, dwFlags);
1213 }
1214
1215 /******************************************************************************
1216  * CryptVerifySignatureA
1217  *
1218  * Note: Since the sDesciption (string) is supposed to be NULL and
1219  *      is only retained for compatibility no string conversions are required
1220  *      and only one implementation is required for both ANSI and Unicode.
1221  *      We still need to export both:
1222  *
1223  * CryptVerifySignatureA (ADVAPI32.@)
1224  * CryptVerifySignatureW (ADVAPI32.@)
1225  */
1226 BOOL WINAPI CryptVerifySignatureA (HCRYPTHASH hHash, BYTE *pbSignature, DWORD dwSigLen,
1227                 HCRYPTKEY hPubKey, LPCSTR sDescription, DWORD dwFlags)
1228 {
1229         PCRYPTHASH hash = (PCRYPTHASH)hHash;
1230         PCRYPTKEY key = (PCRYPTKEY)hPubKey;
1231         PCRYPTPROV prov;
1232
1233         TRACE("(0x%lx, %p, %ld, 0x%lx, %08ld)\n", hHash, pbSignature,
1234                         dwSigLen, hPubKey, dwFlags);
1235         if (sDescription)
1236                 WARN("The sDescription parameter is not supported (and no longer used).  Ignoring.\n");
1237
1238         if (!hash || !key)
1239                 CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
1240         if (!pbSignature || !dwSigLen)
1241                 CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
1242
1243         prov = hash->pProvider;
1244         return prov->pFuncs->pCPVerifySignature(prov->hPrivate, hash->hPrivate, pbSignature, dwSigLen,
1245                 key->hPrivate, NULL, dwFlags);
1246 }