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