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