git.oblomov.eu Git - wine/blob - dlls/rsaenh/tests/rsaenh.c

   1 /*
   2  * Unit tests for rsaenh functions
   3  *
   4  * Copyright (c) 2004 Michael Jung
   5  * Copyright (c) 2006 Juan Lang
   6  * Copyright (c) 2007 Vijay Kiran Kamuju
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <string.h>
  24 #include <stdio.h>
  25 #include "wine/test.h"
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winerror.h"
  29 #include "wincrypt.h"
  30 #include "winreg.h"
  31
  32 static HCRYPTPROV hProv;
  33 static const char szContainer[] = "winetest";
  34 static const char szProvider[] = MS_ENHANCED_PROV_A;
  35
  36 typedef struct _ctdatatype {
  37        unsigned char origstr[32];
  38        unsigned char decstr[32];
  39        int strlen;
  40        int enclen;
  41        int buflen;
  42 } cryptdata;
  43
  44 static const cryptdata cTestData[4] = {
  45        {"abcdefghijkl",
  46        {'a','b','c','d','e','f','g','h',0x2,0x2,'k','l',0},
  47        12,8,16},
  48        {"abcdefghij",
  49        {'a','b','c','d','e','f','g','h',0x2,0x2,0},
  50        10,8,16},
  51        {"abcdefgh",
  52        {'a','b','c','d','e','f','g','h',0},
  53        8,8,16},
  54        {"abcdefghijkl",
  55        {'a','b','c','d','e','f','g','h','i','j','k','l',0},
  56        12,12,16}
  57 };
  58
  59 /*
  60  * 1. Take the MD5 Hash of the container name (with an extra null byte)
  61  * 2. Turn the hash into a 4 DWORD hex value
  62  * 3. Append a '_'
  63  * 4. Add the MachineGuid
  64  *
  65  */
  66 static void uniquecontainer(char *unique)
  67 {
  68     /* MD5 hash of "winetest\0" in 4 DWORD hex */
  69     static const char szContainer_md5[] = "9d20fd8d05ed2b8455d125d0bf6d6a70";
  70     static const char szCryptography[] = "Software\\Microsoft\\Cryptography";
  71     static const char szMachineGuid[] = "MachineGuid";
  72     HKEY hkey;
  73     char guid[MAX_PATH];
  74     DWORD size = MAX_PATH;
  75
  76     /* Get the MachineGUID */
  77     RegOpenKeyA(HKEY_LOCAL_MACHINE, szCryptography, &hkey);
  78     RegQueryValueExA(hkey, szMachineGuid, NULL, NULL, (LPBYTE)guid, &size);
  79     RegCloseKey(hkey);
  80
  81     lstrcpy(unique, szContainer_md5);
  82     lstrcat(unique, "_");
  83     lstrcat(unique, guid);
  84 }
  85
  86 static void printBytes(const char *heading, const BYTE *pb, size_t cb)
  87 {
  88     size_t i;
  89     printf("%s: ",heading);
  90     for(i=0;i<cb;i++)
  91         printf("0x%02x,",pb[i]);
  92     putchar('\n');
  93 }
  94
  95 static BOOL (WINAPI *pCryptDuplicateHash) (HCRYPTHASH, DWORD*, DWORD, HCRYPTHASH*);
  96
  97 /*
  98 static void trace_hex(BYTE *pbData, DWORD dwLen) {
  99     char szTemp[256];
 100     DWORD i, j;
 101
 102     for (i = 0; i < dwLen-7; i+=8) {
 103         sprintf(szTemp, "0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x,\n",
 104             pbData[i], pbData[i+1], pbData[i+2], pbData[i+3], pbData[i+4], pbData[i+5],
 105             pbData[i+6], pbData[i+7]);
 106         trace(szTemp);
 107     }
 108     for (j=0; i<dwLen; j++,i++) {
 109         sprintf(szTemp+6*j, "0x%02x, \n", pbData[i]);
 110     }
 111     trace(szTemp);
 112 }
 113 */
 114
 115 static int init_base_environment(void)
 116 {
 117     HCRYPTKEY hKey;
 118     BOOL result;
 119
 120     pCryptDuplicateHash = (void *)GetProcAddress(GetModuleHandleA("advapi32.dll"), "CryptDuplicateHash");
 121
 122     hProv = (HCRYPTPROV)INVALID_HANDLE_VALUE;
 123
 124     result = CryptAcquireContext(&hProv, szContainer, szProvider, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
 125     ok(!result && GetLastError()==NTE_BAD_FLAGS, "%d, %08x\n", result, GetLastError());
 126
 127     if (!CryptAcquireContext(&hProv, szContainer, szProvider, PROV_RSA_FULL, 0))
 128     {
 129         ok(GetLastError()==NTE_BAD_KEYSET, "%08x\n", GetLastError());
 130         if (GetLastError()!=NTE_BAD_KEYSET) return 0;
 131         result = CryptAcquireContext(&hProv, szContainer, szProvider, PROV_RSA_FULL,
 132                                      CRYPT_NEWKEYSET);
 133         ok(result, "%08x\n", GetLastError());
 134         if (!result) return 0;
 135         result = CryptGenKey(hProv, AT_KEYEXCHANGE, 0, &hKey);
 136         ok(result, "%08x\n", GetLastError());
 137         if (result) CryptDestroyKey(hKey);
 138         result = CryptGenKey(hProv, AT_SIGNATURE, 0, &hKey);
 139         ok(result, "%08x\n", GetLastError());
 140         if (result) CryptDestroyKey(hKey);
 141     }
 142     return 1;
 143 }
 144
 145 static void clean_up_base_environment(void)
 146 {
 147     BOOL result;
 148
 149     result = CryptReleaseContext(hProv, 1);
 150     ok(!result && GetLastError()==NTE_BAD_FLAGS, "%08x\n", GetLastError());
 151
 152     CryptAcquireContext(&hProv, szContainer, szProvider, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
 153 }
 154
 155 static int init_aes_environment(void)
 156 {
 157     HCRYPTKEY hKey;
 158     BOOL result;
 159
 160     pCryptDuplicateHash = (void *)GetProcAddress(GetModuleHandleA("advapi32.dll"), "CryptDuplicateHash");
 161
 162     hProv = (HCRYPTPROV)INVALID_HANDLE_VALUE;
 163
 164     /* we are using NULL as provider name for RSA_AES provider as the provider
 165      * names are different in Windows XP and Vista. Its different as to what
 166      * its defined in the SDK on Windows XP.
 167      * This provider is available on Windows XP, Windows 2003 and Vista.      */
 168
 169     result = CryptAcquireContext(&hProv, szContainer, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT);
 170     ok(!result && GetLastError()==NTE_BAD_FLAGS, "%d, %08x\n", result, GetLastError());
 171
 172     if (!CryptAcquireContext(&hProv, szContainer, NULL, PROV_RSA_AES, 0))
 173     {
 174         ok(GetLastError()==NTE_BAD_KEYSET, "%08x\n", GetLastError());
 175         if (GetLastError()!=NTE_BAD_KEYSET) return 0;
 176         result = CryptAcquireContext(&hProv, szContainer, NULL, PROV_RSA_AES,
 177                                      CRYPT_NEWKEYSET);
 178         ok(result, "%08x\n", GetLastError());
 179         if (!result) return 0;
 180         result = CryptGenKey(hProv, AT_KEYEXCHANGE, 0, &hKey);
 181         ok(result, "%08x\n", GetLastError());
 182         if (result) CryptDestroyKey(hKey);
 183         result = CryptGenKey(hProv, AT_SIGNATURE, 0, &hKey);
 184         ok(result, "%08x\n", GetLastError());
 185         if (result) CryptDestroyKey(hKey);
 186     }
 187     return 1;
 188 }
 189
 190 static void clean_up_aes_environment(void)
 191 {
 192     BOOL result;
 193
 194     result = CryptReleaseContext(hProv, 1);
 195     ok(!result && GetLastError()==NTE_BAD_FLAGS, "%08x\n", GetLastError());
 196
 197     CryptAcquireContext(&hProv, szContainer, NULL, PROV_RSA_AES, CRYPT_DELETEKEYSET);
 198 }
 199
 200 static void test_prov(void)
 201 {
 202     BOOL result;
 203     DWORD dwLen, dwInc;
 204
 205     dwLen = (DWORD)sizeof(DWORD);
 206     SetLastError(0xdeadbeef);
 207     result = CryptGetProvParam(hProv, PP_SIG_KEYSIZE_INC, (BYTE*)&dwInc, &dwLen, 0);
 208     if (!result && GetLastError() == NTE_BAD_TYPE)
 209         skip("PP_SIG_KEYSIZE_INC is not supported (win9x or NT)\n");
 210     else
 211         ok(result && dwInc==8, "%08x, %d\n", GetLastError(), dwInc);
 212
 213     dwLen = (DWORD)sizeof(DWORD);
 214     SetLastError(0xdeadbeef);
 215     result = CryptGetProvParam(hProv, PP_KEYX_KEYSIZE_INC, (BYTE*)&dwInc, &dwLen, 0);
 216     if (!result && GetLastError() == NTE_BAD_TYPE)
 217         skip("PP_KEYX_KEYSIZE_INC is not supported (win9x or NT)\n");
 218     else
 219         ok(result && dwInc==8, "%08x, %d\n", GetLastError(), dwInc);
 220 }
 221
 222 static void test_gen_random(void)
 223 {
 224     BOOL result;
 225     BYTE rnd1[16], rnd2[16];
 226
 227     memset(rnd1, 0, sizeof(rnd1));
 228     memset(rnd2, 0, sizeof(rnd2));
 229
 230     result = CryptGenRandom(hProv, sizeof(rnd1), rnd1);
 231     if (!result && GetLastError() == NTE_FAIL) {
 232         /* rsaenh compiled without OpenSSL */
 233         return;
 234     }
 235
 236     ok(result, "%08x\n", GetLastError());
 237
 238     result = CryptGenRandom(hProv, sizeof(rnd2), rnd2);
 239     ok(result, "%08x\n", GetLastError());
 240
 241     ok(memcmp(rnd1, rnd2, sizeof(rnd1)), "CryptGenRandom generates non random data\n");
 242 }
 243
 244 static BOOL derive_key(ALG_ID aiAlgid, HCRYPTKEY *phKey, DWORD len)
 245 {
 246     HCRYPTHASH hHash;
 247     BOOL result;
 248     unsigned char pbData[2000];
 249     int i;
 250
 251     *phKey = 0;
 252     for (i=0; i<2000; i++) pbData[i] = (unsigned char)i;
 253     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 254     if (!result) {
 255         /* rsaenh compiled without OpenSSL */
 256         ok(GetLastError()==NTE_BAD_ALGID, "%08x\n", GetLastError());
 257         return FALSE;
 258     }
 259     ok(result, "%08x\n", GetLastError());
 260     if (!result) return FALSE;
 261     result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 262     ok(result, "%08x\n", GetLastError());
 263     if (!result) return FALSE;
 264     result = CryptDeriveKey(hProv, aiAlgid, hHash, (len << 16) | CRYPT_EXPORTABLE, phKey);
 265     ok(result, "%08x\n", GetLastError());
 266     if (!result) return FALSE;
 267     len = 2000;
 268     result = CryptGetHashParam(hHash, HP_HASHVAL, pbData, &len, 0);
 269     ok(result, "%08x\n", GetLastError());
 270     CryptDestroyHash(hHash);
 271     return TRUE;
 272 }
 273
 274 static void test_hashes(void)
 275 {
 276     static const unsigned char md2hash[16] = {
 277         0x12, 0xcb, 0x1b, 0x08, 0xc8, 0x48, 0xa4, 0xa9,
 278         0xaa, 0xf3, 0xf1, 0x9f, 0xfc, 0x29, 0x28, 0x68 };
 279     static const unsigned char md4hash[16] = {
 280         0x8e, 0x2a, 0x58, 0xbf, 0xf2, 0xf5, 0x26, 0x23,
 281         0x79, 0xd2, 0x92, 0x36, 0x1b, 0x23, 0xe3, 0x81 };
 282     static const unsigned char empty_md5hash[16] = {
 283         0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04,
 284         0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e };
 285     static const unsigned char md5hash[16] = {
 286         0x15, 0x76, 0xa9, 0x4d, 0x6c, 0xb3, 0x34, 0xdd,
 287         0x12, 0x6c, 0xb1, 0xc2, 0x7f, 0x19, 0xe0, 0xf2 };
 288     static const unsigned char sha1hash[20] = {
 289         0xf1, 0x0c, 0xcf, 0xde, 0x60, 0xc1, 0x7d, 0xb2, 0x6e, 0x7d,
 290         0x85, 0xd3, 0x56, 0x65, 0xc7, 0x66, 0x1d, 0xbb, 0xeb, 0x2c };
 291     unsigned char pbData[2048];
 292     BOOL result;
 293     HCRYPTHASH hHash, hHashClone;
 294     BYTE pbHashValue[36];
 295     DWORD hashlen, len;
 296     int i;
 297
 298     for (i=0; i<2048; i++) pbData[i] = (unsigned char)i;
 299
 300     /* MD2 Hashing */
 301     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 302     if (!result) {
 303         /* rsaenh compiled without OpenSSL */
 304         ok(GetLastError() == NTE_BAD_ALGID, "%08x\n", GetLastError());
 305     } else {
 306         result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 307         ok(result, "%08x\n", GetLastError());
 308
 309         len = sizeof(DWORD);
 310         result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 311            ok(result && (hashlen == 16), "%08x, hashlen: %d\n", GetLastError(), hashlen);
 312
 313         len = 16;
 314         result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 315         ok(result, "%08x\n", GetLastError());
 316
 317         ok(!memcmp(pbHashValue, md2hash, 16), "Wrong MD2 hash!\n");
 318
 319         result = CryptDestroyHash(hHash);
 320         ok(result, "%08x\n", GetLastError());
 321     }
 322
 323     /* MD4 Hashing */
 324     result = CryptCreateHash(hProv, CALG_MD4, 0, 0, &hHash);
 325     ok(result, "%08x\n", GetLastError());
 326
 327     result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 328     ok(result, "%08x\n", GetLastError());
 329
 330     len = sizeof(DWORD);
 331     result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 332     ok(result && (hashlen == 16), "%08x, hashlen: %d\n", GetLastError(), hashlen);
 333
 334     len = 16;
 335     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 336     ok(result, "%08x\n", GetLastError());
 337
 338     ok(!memcmp(pbHashValue, md4hash, 16), "Wrong MD4 hash!\n");
 339
 340     result = CryptDestroyHash(hHash);
 341     ok(result, "%08x\n", GetLastError());
 342
 343     /* MD5 Hashing */
 344     result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
 345     ok(result, "%08x\n", GetLastError());
 346
 347     len = sizeof(DWORD);
 348     result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 349     ok(result && (hashlen == 16), "%08x, hashlen: %d\n", GetLastError(), hashlen);
 350
 351     result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 352     ok(result, "%08x\n", GetLastError());
 353
 354     len = 16;
 355     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 356     ok(result, "%08x\n", GetLastError());
 357
 358     ok(!memcmp(pbHashValue, md5hash, 16), "Wrong MD5 hash!\n");
 359
 360     result = CryptDestroyHash(hHash);
 361     ok(result, "%08x\n", GetLastError());
 362
 363     result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
 364     ok(result, "%08x\n", GetLastError());
 365
 366     /* The hash is available even if CryptHashData hasn't been called */
 367     len = 16;
 368     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 369     ok(result, "%08x\n", GetLastError());
 370
 371     ok(!memcmp(pbHashValue, empty_md5hash, 16), "Wrong MD5 hash!\n");
 372
 373     /* It's also stable:  getting it twice results in the same value */
 374     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 375     ok(result, "%08x\n", GetLastError());
 376
 377     ok(!memcmp(pbHashValue, empty_md5hash, 16), "Wrong MD5 hash!\n");
 378
 379     /* Can't add data after the hash been retrieved */
 380     SetLastError(0xdeadbeef);
 381     result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 382     ok(!result && GetLastError() == NTE_BAD_HASH_STATE, "%08x\n", GetLastError());
 383
 384     /* You can still retrieve the hash, its value just hasn't changed */
 385     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 386     ok(result, "%08x\n", GetLastError());
 387
 388     ok(!memcmp(pbHashValue, empty_md5hash, 16), "Wrong MD5 hash!\n");
 389
 390     result = CryptDestroyHash(hHash);
 391     ok(result, "%08x\n", GetLastError());
 392
 393     /* SHA1 Hashing */
 394     result = CryptCreateHash(hProv, CALG_SHA, 0, 0, &hHash);
 395     ok(result, "%08x\n", GetLastError());
 396
 397     result = CryptHashData(hHash, (BYTE*)pbData, 5, 0);
 398     ok(result, "%08x\n", GetLastError());
 399
 400     if(pCryptDuplicateHash) {
 401         result = pCryptDuplicateHash(hHash, 0, 0, &hHashClone);
 402         ok(result, "%08x\n", GetLastError());
 403
 404         result = CryptHashData(hHashClone, (BYTE*)pbData+5, sizeof(pbData)-5, 0);
 405         ok(result, "%08x\n", GetLastError());
 406
 407         len = sizeof(DWORD);
 408         result = CryptGetHashParam(hHashClone, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 409         ok(result && (hashlen == 20), "%08x, hashlen: %d\n", GetLastError(), hashlen);
 410
 411         len = 20;
 412         result = CryptGetHashParam(hHashClone, HP_HASHVAL, pbHashValue, &len, 0);
 413         ok(result, "%08x\n", GetLastError());
 414
 415         ok(!memcmp(pbHashValue, sha1hash, 20), "Wrong SHA1 hash!\n");
 416
 417         result = CryptDestroyHash(hHashClone);
 418         ok(result, "%08x\n", GetLastError());
 419     }
 420
 421     result = CryptDestroyHash(hHash);
 422     ok(result, "%08x\n", GetLastError());
 423 }
 424
 425 static void test_block_cipher_modes(void)
 426 {
 427     static const BYTE plain[23] = {
 428         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
 429         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
 430     static const BYTE ecb[24] = {
 431         0xc0, 0x9a, 0xe4, 0x2f, 0x0a, 0x47, 0x67, 0x11, 0xf2, 0xb2, 0x5d, 0x5f,
 432         0x08, 0xff, 0x49, 0xa4, 0x45, 0x3a, 0x68, 0x14, 0xca, 0x18, 0xe5, 0xf4 };
 433     static const BYTE cbc[24] = {
 434         0xc0, 0x9a, 0xe4, 0x2f, 0x0a, 0x47, 0x67, 0x11, 0x10, 0xf5, 0xda, 0x61,
 435         0x4e, 0x3d, 0xab, 0xc0, 0x97, 0x85, 0x01, 0x12, 0x97, 0xa4, 0xf7, 0xd3 };
 436     static const BYTE cfb[24] = {
 437         0x29, 0xb5, 0x67, 0x85, 0x0b, 0x1b, 0xec, 0x07, 0x67, 0x2d, 0xa1, 0xa4,
 438         0x1a, 0x47, 0x24, 0x6a, 0x54, 0xe1, 0xe0, 0x92, 0xf9, 0x0e, 0xf6, 0xeb };
 439     HCRYPTKEY hKey;
 440     BOOL result;
 441     BYTE abData[24];
 442     DWORD dwMode, dwLen;
 443
 444     result = derive_key(CALG_RC2, &hKey, 40);
 445     if (!result) return;
 446
 447     memcpy(abData, plain, sizeof(abData));
 448
 449     dwMode = CRYPT_MODE_ECB;
 450     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 451     ok(result, "%08x\n", GetLastError());
 452
 453     dwLen = 23;
 454     result = CryptEncrypt(hKey, 0, TRUE, 0, NULL, &dwLen, 24);
 455     ok(result, "CryptEncrypt failed: %08x\n", GetLastError());
 456     ok(dwLen == 24, "Unexpected length %d\n", dwLen);
 457
 458     SetLastError(ERROR_SUCCESS);
 459     dwLen = 23;
 460     result = CryptEncrypt(hKey, 0, TRUE, 0, abData, &dwLen, 24);
 461     ok(result && dwLen == 24 && !memcmp(ecb, abData, sizeof(ecb)),
 462        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 463
 464     result = CryptDecrypt(hKey, 0, TRUE, 0, abData, &dwLen);
 465     ok(result && dwLen == 23 && !memcmp(plain, abData, sizeof(plain)),
 466        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 467
 468     dwMode = CRYPT_MODE_CBC;
 469     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 470     ok(result, "%08x\n", GetLastError());
 471
 472     dwLen = 23;
 473     result = CryptEncrypt(hKey, 0, TRUE, 0, NULL, &dwLen, 24);
 474     ok(result, "CryptEncrypt failed: %08x\n", GetLastError());
 475     ok(dwLen == 24, "Unexpected length %d\n", dwLen);
 476
 477     dwLen = 23;
 478     result = CryptEncrypt(hKey, 0, TRUE, 0, abData, &dwLen, 24);
 479     ok(result && dwLen == 24 && !memcmp(cbc, abData, sizeof(cbc)),
 480        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 481
 482     result = CryptDecrypt(hKey, 0, TRUE, 0, abData, &dwLen);
 483     ok(result && dwLen == 23 && !memcmp(plain, abData, sizeof(plain)),
 484        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 485
 486     dwMode = CRYPT_MODE_CFB;
 487     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 488     ok(result, "%08x\n", GetLastError());
 489
 490     dwLen = 16;
 491     result = CryptEncrypt(hKey, 0, FALSE, 0, abData, &dwLen, 24);
 492     ok(result && dwLen == 16, "%08x, dwLen: %d\n", GetLastError(), dwLen);
 493
 494     dwLen = 7;
 495     result = CryptEncrypt(hKey, 0, TRUE, 0, abData+16, &dwLen, 8);
 496     ok(result && dwLen == 8 && !memcmp(cfb, abData, sizeof(cfb)),
 497        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 498
 499     dwLen = 8;
 500     result = CryptDecrypt(hKey, 0, FALSE, 0, abData, &dwLen);
 501     ok(result && dwLen == 8, "%08x, dwLen: %d\n", GetLastError(), dwLen);
 502
 503     dwLen = 16;
 504     result = CryptDecrypt(hKey, 0, TRUE, 0, abData+8, &dwLen);
 505     ok(result && dwLen == 15 && !memcmp(plain, abData, sizeof(plain)),
 506        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 507
 508     dwMode = CRYPT_MODE_OFB;
 509     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 510     ok(result, "%08x\n", GetLastError());
 511
 512     dwLen = 23;
 513     result = CryptEncrypt(hKey, 0, TRUE, 0, abData, &dwLen, 24);
 514     ok(!result && GetLastError() == NTE_BAD_ALGID, "%08x\n", GetLastError());
 515
 516     CryptDestroyKey(hKey);
 517 }
 518
 519 static void test_3des112(void)
 520 {
 521     HCRYPTKEY hKey;
 522     BOOL result;
 523     DWORD dwLen;
 524     unsigned char pbData[16];
 525     int i;
 526
 527     result = derive_key(CALG_3DES_112, &hKey, 0);
 528     if (!result) {
 529         /* rsaenh compiled without OpenSSL */
 530         ok(GetLastError() == NTE_BAD_ALGID, "%08x\n", GetLastError());
 531         return;
 532     }
 533
 534     for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
 535
 536     dwLen = 13;
 537     result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, 16);
 538     ok(result, "%08x\n", GetLastError());
 539
 540     result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 541     ok(result, "%08x\n", GetLastError());
 542
 543     for (i=0; i<4; i++)
 544     {
 545       memcpy(pbData,cTestData[i].origstr,cTestData[i].strlen);
 546
 547       dwLen = cTestData[i].enclen;
 548       result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, cTestData[i].buflen);
 549       ok(result, "%08x\n", GetLastError());
 550       ok(dwLen==cTestData[i].buflen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].buflen);
 551
 552       result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 553       ok(result, "%08x\n", GetLastError());
 554       ok(dwLen==cTestData[i].enclen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].enclen);
 555       ok(memcmp(pbData,cTestData[i].decstr,cTestData[1].enclen)==0,"decryption incorrect %d\n",i);
 556       if((dwLen != cTestData[i].enclen) ||
 557          memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen))
 558       {
 559           printBytes("expected",cTestData[i].decstr,cTestData[i].strlen);
 560           printBytes("got",pbData,dwLen);
 561       }
 562     }
 563     result = CryptDestroyKey(hKey);
 564     ok(result, "%08x\n", GetLastError());
 565 }
 566
 567 static void test_des(void)
 568 {
 569     HCRYPTKEY hKey;
 570     BOOL result;
 571     DWORD dwLen, dwMode;
 572     unsigned char pbData[16];
 573     int i;
 574
 575     result = derive_key(CALG_DES, &hKey, 56);
 576     if (!result) {
 577         /* rsaenh compiled without OpenSSL */
 578         ok(GetLastError()==NTE_BAD_ALGID, "%08x\n", GetLastError());
 579         return;
 580     }
 581
 582     dwMode = CRYPT_MODE_ECB;
 583     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 584     ok(result, "%08x\n", GetLastError());
 585
 586     dwLen = sizeof(DWORD);
 587     result = CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0);
 588     ok(result, "%08x\n", GetLastError());
 589
 590     for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
 591
 592     dwLen = 13;
 593     result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, 16);
 594     ok(result, "%08x\n", GetLastError());
 595
 596     result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 597     ok(result, "%08x\n", GetLastError());
 598
 599     for (i=0; i<4; i++)
 600     {
 601       memcpy(pbData,cTestData[i].origstr,cTestData[i].strlen);
 602
 603       dwLen = cTestData[i].enclen;
 604       result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, cTestData[i].buflen);
 605       ok(result, "%08x\n", GetLastError());
 606       ok(dwLen==cTestData[i].buflen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].buflen);
 607
 608       result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 609       ok(result, "%08x\n", GetLastError());
 610       ok(dwLen==cTestData[i].enclen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].enclen);
 611       ok(memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen)==0,"decryption incorrect %d\n",i);
 612       if((dwLen != cTestData[i].enclen) ||
 613          memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen))
 614       {
 615           printBytes("expected",cTestData[i].decstr,cTestData[i].strlen);
 616           printBytes("got",pbData,dwLen);
 617       }
 618     }
 619
 620     result = CryptDestroyKey(hKey);
 621     ok(result, "%08x\n", GetLastError());
 622 }
 623
 624 static void test_3des(void)
 625 {
 626     HCRYPTKEY hKey;
 627     BOOL result;
 628     DWORD dwLen;
 629     unsigned char pbData[16];
 630     static const BYTE des3[16] = {
 631         0x7b, 0xba, 0xdd, 0xa2, 0x39, 0xd3, 0x7b, 0xb3,
 632         0xc7, 0x51, 0x81, 0x41, 0x53, 0xe8, 0xcf, 0xeb };
 633     int i;
 634
 635     result = derive_key(CALG_3DES, &hKey, 0);
 636     if (!result) return;
 637
 638     for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
 639
 640     dwLen = 13;
 641     result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, 16);
 642     ok(result, "%08x\n", GetLastError());
 643
 644     ok(!memcmp(pbData, des3, sizeof(des3)), "3DES encryption failed!\n");
 645
 646     result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 647     ok(result, "%08x\n", GetLastError());
 648
 649     for (i=0; i<4; i++)
 650     {
 651       memcpy(pbData,cTestData[i].origstr,cTestData[i].strlen);
 652
 653       dwLen = cTestData[i].enclen;
 654       result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, cTestData[i].buflen);
 655       ok(result, "%08x\n", GetLastError());
 656       ok(dwLen==cTestData[i].buflen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].buflen);
 657
 658       result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 659       ok(result, "%08x\n", GetLastError());
 660       ok(dwLen==cTestData[i].enclen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].enclen);
 661       ok(memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen)==0,"decryption incorrect %d\n",i);
 662       if((dwLen != cTestData[i].enclen) ||
 663          memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen))
 664       {
 665           printBytes("expected",cTestData[i].decstr,cTestData[i].strlen);
 666           printBytes("got",pbData,dwLen);
 667       }
 668     }
 669     result = CryptDestroyKey(hKey);
 670     ok(result, "%08x\n", GetLastError());
 671 }
 672
 673 static void test_aes(int keylen)
 674 {
 675     HCRYPTKEY hKey;
 676     BOOL result;
 677     DWORD dwLen;
 678     unsigned char pbData[16];
 679     int i;
 680
 681     switch (keylen)
 682     {
 683         case 256:
 684             result = derive_key(CALG_AES_256, &hKey, 0);
 685             break;
 686         case 192:
 687             result = derive_key(CALG_AES_192, &hKey, 0);
 688             break;
 689         default:
 690         case 128:
 691             result = derive_key(CALG_AES_128, &hKey, 0);
 692             break;
 693     }
 694     if (!result) return;
 695
 696     for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
 697
 698     dwLen = 13;
 699     result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, 16);
 700     ok(result, "%08x\n", GetLastError());
 701
 702     result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 703     ok(result, "%08x\n", GetLastError());
 704
 705     for (i=0; i<4; i++)
 706     {
 707       memcpy(pbData,cTestData[i].origstr,cTestData[i].strlen);
 708
 709       dwLen = cTestData[i].enclen;
 710       result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, cTestData[i].buflen);
 711       ok(result, "%08x\n", GetLastError());
 712       ok(dwLen==cTestData[i].buflen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].buflen);
 713
 714       result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 715       ok(result, "%08x\n", GetLastError());
 716       ok(dwLen==cTestData[i].enclen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].enclen);
 717       ok(memcmp(pbData,cTestData[i].decstr,cTestData[1].enclen)==0,"decryption incorrect %d\n",i);
 718       if((dwLen != cTestData[i].enclen) ||
 719          memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen))
 720       {
 721           printBytes("expected",cTestData[i].decstr,cTestData[i].strlen);
 722           printBytes("got",pbData,dwLen);
 723       }
 724     }
 725     result = CryptDestroyKey(hKey);
 726     ok(result, "%08x\n", GetLastError());
 727 }
 728
 729 static void test_rc2(void)
 730 {
 731     static const BYTE rc2encrypted[16] = {
 732         0x02, 0x34, 0x7d, 0xf6, 0x1d, 0xc5, 0x9b, 0x8b,
 733         0x2e, 0x0d, 0x63, 0x80, 0x72, 0xc1, 0xc2, 0xb1 };
 734     static const BYTE rc2_128_encrypted[] = {
 735         0x82,0x81,0xf7,0xff,0xdd,0xd7,0x88,0x8c,0x2a,0x2a,0xc0,0xce,0x4c,0x89,
 736         0xb6,0x66 };
 737     HCRYPTHASH hHash;
 738     HCRYPTKEY hKey;
 739     BOOL result;
 740     DWORD dwLen, dwKeyLen, dwDataLen, dwMode, dwModeBits;
 741     BYTE *pbTemp;
 742     unsigned char pbData[2000], pbHashValue[16];
 743     int i;
 744
 745     for (i=0; i<2000; i++) pbData[i] = (unsigned char)i;
 746
 747     /* MD2 Hashing */
 748     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 749     if (!result) {
 750         ok(GetLastError()==NTE_BAD_ALGID, "%08x\n", GetLastError());
 751     } else {
 752         CRYPT_INTEGER_BLOB salt;
 753
 754         result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 755         ok(result, "%08x\n", GetLastError());
 756
 757         dwLen = 16;
 758         result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &dwLen, 0);
 759         ok(result, "%08x\n", GetLastError());
 760
 761         result = CryptDeriveKey(hProv, CALG_RC2, hHash, 56 << 16, &hKey);
 762         ok(result, "%08x\n", GetLastError());
 763
 764         dwLen = sizeof(DWORD);
 765         result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
 766         ok(result, "%08x\n", GetLastError());
 767
 768         dwMode = CRYPT_MODE_CBC;
 769         result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 770         ok(result, "%08x\n", GetLastError());
 771
 772         dwLen = sizeof(DWORD);
 773         result = CryptGetKeyParam(hKey, KP_MODE_BITS, (BYTE*)&dwModeBits, &dwLen, 0);
 774         ok(result, "%08x\n", GetLastError());
 775
 776         dwLen = sizeof(DWORD);
 777         result = CryptGetKeyParam(hKey, KP_PERMISSIONS, (BYTE*)&dwModeBits, &dwLen, 0);
 778         ok(result, "%08x\n", GetLastError());
 779
 780         dwLen = sizeof(DWORD);
 781         result = CryptGetKeyParam(hKey, KP_BLOCKLEN, (BYTE*)&dwModeBits, &dwLen, 0);
 782         ok(result, "%08x\n", GetLastError());
 783
 784         result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0);
 785         ok(result, "%08x\n", GetLastError());
 786         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 787         CryptGetKeyParam(hKey, KP_IV, pbTemp, &dwLen, 0);
 788         HeapFree(GetProcessHeap(), 0, pbTemp);
 789
 790         result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0);
 791         ok(result, "%08x\n", GetLastError());
 792         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 793         CryptGetKeyParam(hKey, KP_SALT, pbTemp, &dwLen, 0);
 794         HeapFree(GetProcessHeap(), 0, pbTemp);
 795
 796         dwLen = sizeof(DWORD);
 797         CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0);
 798
 799         result = CryptDestroyHash(hHash);
 800         ok(result, "%08x\n", GetLastError());
 801
 802         dwDataLen = 13;
 803         result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, 24);
 804         ok(result, "%08x\n", GetLastError());
 805
 806         ok(!memcmp(pbData, rc2encrypted, 8), "RC2 encryption failed!\n");
 807
 808         result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0);
 809         ok(result, "%08x\n", GetLastError());
 810         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 811         CryptGetKeyParam(hKey, KP_IV, pbTemp, &dwLen, 0);
 812         HeapFree(GetProcessHeap(), 0, pbTemp);
 813
 814         result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen);
 815         ok(result, "%08x\n", GetLastError());
 816
 817         /* What sizes salt can I set? */
 818         salt.pbData = pbData;
 819         for (i=0; i<24; i++)
 820         {
 821             salt.cbData = i;
 822             result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0);
 823             ok(result, "setting salt failed for size %d: %08x\n", i, GetLastError());
 824         }
 825         salt.cbData = 25;
 826         SetLastError(0xdeadbeef);
 827         result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0);
 828         ok(!result && GetLastError() == NTE_BAD_DATA, "%08x\n", GetLastError());
 829
 830         result = CryptDestroyKey(hKey);
 831         ok(result, "%08x\n", GetLastError());
 832     }
 833
 834     /* Again, but test setting the effective key len */
 835     for (i=0; i<2000; i++) pbData[i] = (unsigned char)i;
 836
 837     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 838     if (!result) {
 839         ok(GetLastError()==NTE_BAD_ALGID, "%08x\n", GetLastError());
 840     } else {
 841         result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 842         ok(result, "%08x\n", GetLastError());
 843
 844         dwLen = 16;
 845         result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &dwLen, 0);
 846         ok(result, "%08x\n", GetLastError());
 847
 848         result = CryptDeriveKey(hProv, CALG_RC2, hHash, 56 << 16, &hKey);
 849         ok(result, "%08x\n", GetLastError());
 850
 851         SetLastError(0xdeadbeef);
 852         result = CryptSetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, NULL, 0);
 853         ok(!result && GetLastError()==ERROR_INVALID_PARAMETER, "%08x\n", GetLastError());
 854         dwKeyLen = 0;
 855         SetLastError(0xdeadbeef);
 856         result = CryptSetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (LPBYTE)&dwKeyLen, 0);
 857         ok(!result && GetLastError()==NTE_BAD_DATA, "%08x\n", GetLastError());
 858         dwKeyLen = 1025;
 859         SetLastError(0xdeadbeef);
 860         result = CryptSetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (LPBYTE)&dwKeyLen, 0);
 861
 862         dwLen = sizeof(dwKeyLen);
 863         CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE *)&dwKeyLen, &dwLen, 0);
 864         ok(dwKeyLen == 56, "%d (%08x)\n", dwKeyLen, GetLastError());
 865         CryptGetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (BYTE *)&dwKeyLen, &dwLen, 0);
 866         ok(dwKeyLen == 56, "%d (%08x)\n", dwKeyLen, GetLastError());
 867
 868         dwKeyLen = 128;
 869         result = CryptSetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (LPBYTE)&dwKeyLen, 0);
 870         ok(result, "%d\n", GetLastError());
 871
 872         dwLen = sizeof(dwKeyLen);
 873         CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE *)&dwKeyLen, &dwLen, 0);
 874         ok(dwKeyLen == 56, "%d (%08x)\n", dwKeyLen, GetLastError());
 875         CryptGetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (BYTE *)&dwKeyLen, &dwLen, 0);
 876         ok(dwKeyLen == 128, "%d (%08x)\n", dwKeyLen, GetLastError());
 877
 878         result = CryptDestroyHash(hHash);
 879         ok(result, "%08x\n", GetLastError());
 880
 881         dwDataLen = 13;
 882         result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, 24);
 883         ok(result, "%08x\n", GetLastError());
 884
 885         ok(!memcmp(pbData, rc2_128_encrypted, sizeof(rc2_128_encrypted)),
 886                 "RC2 encryption failed!\n");
 887
 888         /* Oddly enough this succeeds, though it should have no effect */
 889         dwKeyLen = 40;
 890         result = CryptSetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (LPBYTE)&dwKeyLen, 0);
 891         ok(result, "%d\n", GetLastError());
 892
 893         result = CryptDestroyKey(hKey);
 894         ok(result, "%08x\n", GetLastError());
 895     }
 896 }
 897
 898 static void test_rc4(void)
 899 {
 900     static const BYTE rc4[16] = {
 901         0x17, 0x0c, 0x44, 0x8e, 0xae, 0x90, 0xcd, 0xb0,
 902         0x7f, 0x87, 0xf5, 0x7a, 0xec, 0xb2, 0x2e, 0x35 };
 903     BOOL result;
 904     HCRYPTHASH hHash;
 905     HCRYPTKEY hKey;
 906     DWORD dwDataLen = 5, dwKeyLen, dwLen = sizeof(DWORD), dwMode;
 907     unsigned char pbData[2000], *pbTemp;
 908     unsigned char pszBuffer[256];
 909     int i;
 910
 911     for (i=0; i<2000; i++) pbData[i] = (unsigned char)i;
 912
 913     /* MD2 Hashing */
 914     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 915     if (!result) {
 916         /* rsaenh compiled without OpenSSL */
 917         ok(GetLastError() == NTE_BAD_ALGID, "%08x\n", GetLastError());
 918     } else {
 919         CRYPT_INTEGER_BLOB salt;
 920
 921         result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 922            ok(result, "%08x\n", GetLastError());
 923
 924         dwLen = 16;
 925         result = CryptGetHashParam(hHash, HP_HASHVAL, pszBuffer, &dwLen, 0);
 926         ok(result, "%08x\n", GetLastError());
 927
 928         result = CryptDeriveKey(hProv, CALG_RC4, hHash, 56 << 16, &hKey);
 929         ok(result, "%08x\n", GetLastError());
 930
 931         dwLen = sizeof(DWORD);
 932         result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
 933         ok(result, "%08x\n", GetLastError());
 934
 935         dwLen = sizeof(DWORD);
 936         result = CryptGetKeyParam(hKey, KP_BLOCKLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
 937         ok(result, "%08x\n", GetLastError());
 938
 939         result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0);
 940         ok(result, "%08x\n", GetLastError());
 941         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 942         CryptGetKeyParam(hKey, KP_IV, pbTemp, &dwLen, 0);
 943         HeapFree(GetProcessHeap(), 0, pbTemp);
 944
 945         result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0);
 946         ok(result, "%08x\n", GetLastError());
 947         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 948         CryptGetKeyParam(hKey, KP_SALT, pbTemp, &dwLen, 0);
 949         HeapFree(GetProcessHeap(), 0, pbTemp);
 950
 951         dwLen = sizeof(DWORD);
 952         CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0);
 953
 954         result = CryptDestroyHash(hHash);
 955         ok(result, "%08x\n", GetLastError());
 956
 957         dwDataLen = 16;
 958         result = CryptEncrypt(hKey, 0, TRUE, 0, NULL, &dwDataLen, 24);
 959         ok(result, "%08x\n", GetLastError());
 960         dwDataLen = 16;
 961         result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, 24);
 962         ok(result, "%08x\n", GetLastError());
 963
 964         ok(!memcmp(pbData, rc4, dwDataLen), "RC4 encryption failed!\n");
 965
 966         result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen);
 967         ok(result, "%08x\n", GetLastError());
 968
 969         /* What sizes salt can I set? */
 970         salt.pbData = pbData;
 971         for (i=0; i<24; i++)
 972         {
 973             salt.cbData = i;
 974             result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0);
 975             ok(result, "setting salt failed for size %d: %08x\n", i, GetLastError());
 976         }
 977         salt.cbData = 25;
 978         SetLastError(0xdeadbeef);
 979         result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0);
 980         ok(!result && GetLastError() == NTE_BAD_DATA, "%08x\n", GetLastError());
 981
 982         result = CryptDestroyKey(hKey);
 983         ok(result, "%08x\n", GetLastError());
 984     }
 985 }
 986
 987 static void test_hmac(void) {
 988     HCRYPTKEY hKey;
 989     HCRYPTHASH hHash;
 990     BOOL result;
 991     /* Using CALG_MD2 here fails on Windows 2003, why ? */
 992     HMAC_INFO hmacInfo = { CALG_MD5, NULL, 0, NULL, 0 };
 993     DWORD dwLen;
 994     BYTE abData[256];
 995     static const BYTE hmac[16] = {
 996         0x1a, 0x7d, 0x49, 0xc5, 0x9b, 0x2d, 0x0b, 0x9c,
 997         0xcf, 0x10, 0x6b, 0xb6, 0x7d, 0x0f, 0x13, 0x32 };
 998     int i;
 999
1000     for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abData[i] = (BYTE)i;
1001
1002     if (!derive_key(CALG_RC2, &hKey, 56)) return;
1003
1004     result = CryptCreateHash(hProv, CALG_HMAC, hKey, 0, &hHash);
1005     ok(result, "%08x\n", GetLastError());
1006     if (!result) return;
1007
1008     result = CryptSetHashParam(hHash, HP_HMAC_INFO, (BYTE*)&hmacInfo, 0);
1009     ok(result, "%08x\n", GetLastError());
1010
1011     result = CryptHashData(hHash, (BYTE*)abData, sizeof(abData), 0);
1012     ok(result, "%08x\n", GetLastError());
1013
1014     dwLen = sizeof(abData)/sizeof(BYTE);
1015     result = CryptGetHashParam(hHash, HP_HASHVAL, abData, &dwLen, 0);
1016     ok(result, "%08x\n", GetLastError());
1017
1018     ok(!memcmp(abData, hmac, sizeof(hmac)), "HMAC failed!\n");
1019
1020     result = CryptDestroyHash(hHash);
1021     ok(result, "%08x\n", GetLastError());
1022
1023     result = CryptDestroyKey(hKey);
1024     ok(result, "%08x\n", GetLastError());
1025
1026     /* Provoke errors */
1027     result = CryptCreateHash(hProv, CALG_HMAC, 0, 0, &hHash);
1028     ok(!result && GetLastError() == NTE_BAD_KEY, "%08x\n", GetLastError());
1029 }
1030
1031 static void test_mac(void) {
1032     HCRYPTKEY hKey;
1033     HCRYPTHASH hHash;
1034     BOOL result;
1035     DWORD dwLen;
1036     BYTE abData[256], abEnc[264];
1037     static const BYTE mac[8] = { 0x0d, 0x3e, 0x15, 0x6b, 0x85, 0x63, 0x5c, 0x11 };
1038     int i;
1039
1040     for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abData[i] = (BYTE)i;
1041     for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abEnc[i] = (BYTE)i;
1042
1043     if (!derive_key(CALG_RC2, &hKey, 56)) return;
1044
1045     dwLen = 256;
1046     result = CryptEncrypt(hKey, 0, TRUE, 0, abEnc, &dwLen, 264);
1047     ok (result && dwLen == 264, "%08x, dwLen: %d\n", GetLastError(), dwLen);
1048
1049     result = CryptCreateHash(hProv, CALG_MAC, hKey, 0, &hHash);
1050     ok(result, "%08x\n", GetLastError());
1051     if (!result) return;
1052
1053     result = CryptHashData(hHash, (BYTE*)abData, sizeof(abData), 0);
1054     ok(result, "%08x\n", GetLastError());
1055
1056     dwLen = sizeof(abData)/sizeof(BYTE);
1057     result = CryptGetHashParam(hHash, HP_HASHVAL, abData, &dwLen, 0);
1058     ok(result && dwLen == 8, "%08x, dwLen: %d\n", GetLastError(), dwLen);
1059
1060     ok(!memcmp(abData, mac, sizeof(mac)), "MAC failed!\n");
1061
1062     result = CryptDestroyHash(hHash);
1063     ok(result, "%08x\n", GetLastError());
1064
1065     result = CryptDestroyKey(hKey);
1066     ok(result, "%08x\n", GetLastError());
1067
1068     /* Provoke errors */
1069     if (!derive_key(CALG_RC4, &hKey, 56)) return;
1070
1071     result = CryptCreateHash(hProv, CALG_MAC, hKey, 0, &hHash);
1072     ok(!result && GetLastError() == NTE_BAD_KEY, "%08x\n", GetLastError());
1073
1074     result = CryptDestroyKey(hKey);
1075     ok(result, "%08x\n", GetLastError());
1076 }
1077
1078 static BYTE abPlainPrivateKey[596] = {
1079     0x07, 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00,
1080     0x52, 0x53, 0x41, 0x32, 0x00, 0x04, 0x00, 0x00,
1081     0x01, 0x00, 0x01, 0x00, 0x9b, 0x64, 0xef, 0xce,
1082     0x31, 0x7c, 0xad, 0x56, 0xe2, 0x1e, 0x9b, 0x96,
1083     0xb3, 0xf0, 0x29, 0x88, 0x6e, 0xa8, 0xc2, 0x11,
1084     0x33, 0xd6, 0xcc, 0x8c, 0x69, 0xb2, 0x1a, 0xfd,
1085     0xfc, 0x23, 0x21, 0x30, 0x4d, 0x29, 0x45, 0xb6,
1086     0x3a, 0x67, 0x11, 0x80, 0x1a, 0x91, 0xf2, 0x9f,
1087     0x01, 0xac, 0xc0, 0x11, 0x50, 0x5f, 0xcd, 0xb9,
1088     0xad, 0x76, 0x9f, 0x6e, 0x91, 0x55, 0x71, 0xda,
1089     0x97, 0x96, 0x96, 0x22, 0x75, 0xb4, 0x83, 0x44,
1090     0x89, 0x9e, 0xf8, 0x44, 0x40, 0x7c, 0xd6, 0xcd,
1091     0x9d, 0x88, 0xd6, 0x88, 0xbc, 0x56, 0xb7, 0x64,
1092     0xe9, 0x2c, 0x24, 0x2f, 0x0d, 0x78, 0x55, 0x1c,
1093     0xb2, 0x67, 0xb1, 0x5e, 0xbc, 0x0c, 0xcf, 0x1c,
1094     0xe9, 0xd3, 0x9e, 0xa2, 0x15, 0x24, 0x73, 0xd6,
1095     0xdb, 0x6f, 0x83, 0xb2, 0xf8, 0xbc, 0xe7, 0x47,
1096     0x3b, 0x01, 0xef, 0x49, 0x08, 0x98, 0xd6, 0xa3,
1097     0xf9, 0x25, 0x57, 0xe9, 0x39, 0x3c, 0x53, 0x30,
1098     0x1b, 0xf2, 0xc9, 0x62, 0x31, 0x43, 0x5d, 0x84,
1099     0x24, 0x30, 0x21, 0x9a, 0xad, 0xdb, 0x62, 0x91,
1100     0xc8, 0x07, 0xd9, 0x2f, 0xd6, 0xb5, 0x37, 0x6f,
1101     0xfe, 0x7a, 0x12, 0xbc, 0xd9, 0xd2, 0x2b, 0xbf,
1102     0xd7, 0xb1, 0xfa, 0x7d, 0xc0, 0x48, 0xdd, 0x74,
1103     0xdd, 0x55, 0x04, 0xa1, 0x8b, 0xc1, 0x0a, 0xc4,
1104     0xa5, 0x57, 0x62, 0xee, 0x08, 0x8b, 0xf9, 0x19,
1105     0x6c, 0x52, 0x06, 0xf8, 0x73, 0x0f, 0x24, 0xc9,
1106     0x71, 0x9f, 0xc5, 0x45, 0x17, 0x3e, 0xae, 0x06,
1107     0x81, 0xa2, 0x96, 0x40, 0x06, 0xbf, 0xeb, 0x9e,
1108     0x80, 0x2b, 0x27, 0x20, 0x8f, 0x38, 0xcf, 0xeb,
1109     0xff, 0x3b, 0x38, 0x41, 0x35, 0x69, 0x66, 0x13,
1110     0x1d, 0x3c, 0x01, 0x3b, 0xf6, 0x37, 0xca, 0x9c,
1111     0x61, 0x74, 0x98, 0xcf, 0xc9, 0x6e, 0xe8, 0x90,
1112     0xc7, 0xb7, 0x33, 0xc0, 0x07, 0x3c, 0xf8, 0xc8,
1113     0xf6, 0xf2, 0xd7, 0xf0, 0x21, 0x62, 0x58, 0x8a,
1114     0x55, 0xbf, 0xa1, 0x2d, 0x3d, 0xa6, 0x69, 0xc5,
1115     0x02, 0x19, 0x31, 0xf0, 0x94, 0x0f, 0x45, 0x5c,
1116     0x95, 0x1b, 0x53, 0xbc, 0xf5, 0xb0, 0x1a, 0x8f,
1117     0xbf, 0x40, 0xe0, 0xc7, 0x73, 0xe7, 0x72, 0x6e,
1118     0xeb, 0xb1, 0x0f, 0x38, 0xc5, 0xf8, 0xee, 0x04,
1119     0xed, 0x34, 0x1a, 0x10, 0xf9, 0x53, 0x34, 0xf3,
1120     0x3e, 0xe6, 0x5c, 0xd1, 0x47, 0x65, 0xcd, 0xbd,
1121     0xf1, 0x06, 0xcb, 0xb4, 0xb1, 0x26, 0x39, 0x9f,
1122     0x71, 0xfe, 0x3d, 0xf8, 0x62, 0xab, 0x22, 0x8b,
1123     0x0e, 0xdc, 0xb9, 0xe8, 0x74, 0x06, 0xfc, 0x8c,
1124     0x25, 0xa1, 0xa9, 0xcf, 0x07, 0xf9, 0xac, 0x21,
1125     0x01, 0x7b, 0x1c, 0xdc, 0x94, 0xbd, 0x47, 0xe1,
1126     0xa0, 0x86, 0x59, 0x35, 0x6a, 0x6f, 0xb9, 0x70,
1127     0x26, 0x7c, 0x3c, 0xfd, 0xbd, 0x81, 0x39, 0x36,
1128     0x42, 0xc2, 0xbd, 0xbe, 0x84, 0x27, 0x9a, 0x69,
1129     0x81, 0xda, 0x99, 0x27, 0xc2, 0x4f, 0x62, 0x33,
1130     0xf4, 0x79, 0x30, 0xc5, 0x63, 0x54, 0x71, 0xf1,
1131     0x47, 0x22, 0x25, 0x9b, 0x6c, 0x00, 0x2f, 0x1c,
1132     0xf4, 0x1f, 0x85, 0xbc, 0xf6, 0x67, 0x6a, 0xe3,
1133     0xf6, 0x55, 0x8a, 0xef, 0xd0, 0x0b, 0xd3, 0xa2,
1134     0xc5, 0x51, 0x70, 0x15, 0x0a, 0xf0, 0x98, 0x4c,
1135     0xb7, 0x19, 0x62, 0x0e, 0x2d, 0x2a, 0x4a, 0x7d,
1136     0x7a, 0x0a, 0xc4, 0x17, 0xe3, 0x5d, 0x20, 0x52,
1137     0xa9, 0x98, 0xc3, 0xaa, 0x11, 0xf6, 0xbf, 0x4c,
1138     0x94, 0x99, 0x81, 0x89, 0xf0, 0x7f, 0x66, 0xaa,
1139     0xc8, 0x88, 0xd7, 0x31, 0x84, 0x71, 0xb6, 0x64,
1140     0x09, 0x76, 0x0b, 0x7f, 0x1a, 0x1f, 0x2e, 0xfe,
1141     0xcd, 0x59, 0x2a, 0x54, 0x11, 0x84, 0xd4, 0x6a,
1142     0x61, 0xdf, 0xaa, 0x76, 0x66, 0x9d, 0x82, 0x11,
1143     0x56, 0x3d, 0xd2, 0x52, 0xe6, 0x42, 0x5a, 0x77,
1144     0x92, 0x98, 0x34, 0xf3, 0x56, 0x6c, 0x96, 0x10,
1145     0x40, 0x59, 0x16, 0xcb, 0x77, 0x61, 0xe3, 0xbf,
1146     0x4b, 0xd4, 0x39, 0xfb, 0xb1, 0x4e, 0xc1, 0x74,
1147     0xec, 0x7a, 0xea, 0x3d, 0x68, 0xbb, 0x0b, 0xe6,
1148     0xc6, 0x06, 0xbf, 0xdd, 0x7f, 0x94, 0x42, 0xc0,
1149     0x0f, 0xe4, 0x92, 0x33, 0x6c, 0x6e, 0x1b, 0xba,
1150     0x73, 0xf9, 0x79, 0x84, 0xdf, 0x45, 0x00, 0xe4,
1151     0x94, 0x88, 0x9d, 0x08, 0x89, 0xcf, 0xf2, 0xa4,
1152     0xc5, 0x47, 0x45, 0x85, 0x86, 0xa5, 0xcc, 0xa8,
1153     0xf2, 0x5d, 0x58, 0x07
1154 };
1155
1156 static void test_import_private(void)
1157 {
1158     DWORD dwLen;
1159     HCRYPTKEY hKeyExchangeKey, hSessionKey;
1160     BOOL result;
1161     static BYTE abSessionKey[148] = {
1162         0x01, 0x02, 0x00, 0x00, 0x01, 0x68, 0x00, 0x00,
1163         0x00, 0xa4, 0x00, 0x00, 0xb8, 0xa4, 0xdf, 0x5e,
1164         0x9e, 0xb1, 0xbf, 0x85, 0x3d, 0x24, 0x2d, 0x1e,
1165         0x69, 0xb7, 0x67, 0x13, 0x8e, 0x78, 0xf2, 0xdf,
1166         0xc6, 0x69, 0xce, 0x46, 0x7e, 0xf2, 0xf2, 0x33,
1167         0x20, 0x6f, 0xa1, 0xa5, 0x59, 0x83, 0x25, 0xcb,
1168         0x3a, 0xb1, 0x8a, 0x12, 0x63, 0x02, 0x3c, 0xfb,
1169         0x4a, 0xfa, 0xef, 0x8e, 0xf7, 0x29, 0x57, 0xb1,
1170         0x9e, 0xa7, 0xf3, 0x02, 0xfd, 0xca, 0xdf, 0x5a,
1171         0x1f, 0x71, 0xb6, 0x26, 0x09, 0x24, 0x39, 0xda,
1172         0xc0, 0xde, 0x2a, 0x0e, 0xcd, 0x1f, 0xe5, 0xb6,
1173         0x4f, 0x82, 0xa0, 0xa9, 0x90, 0xd3, 0xd9, 0x6a,
1174         0x43, 0x14, 0x2a, 0xf7, 0xac, 0xd5, 0xa0, 0x54,
1175         0x93, 0xc4, 0xb9, 0xe7, 0x24, 0x84, 0x4d, 0x69,
1176         0x5e, 0xcc, 0x2a, 0x32, 0xb5, 0xfb, 0xe4, 0xb4,
1177         0x08, 0xd5, 0x36, 0x58, 0x59, 0x40, 0xfb, 0x29,
1178         0x7f, 0xa7, 0x17, 0x25, 0xc4, 0x0d, 0x78, 0x37,
1179         0x04, 0x8c, 0x49, 0x92
1180     };
1181     static BYTE abEncryptedMessage[12] = {
1182         0x40, 0x64, 0x28, 0xe8, 0x8a, 0xe7, 0xa4, 0xd4,
1183         0x1c, 0xfd, 0xde, 0x71
1184     };
1185
1186     dwLen = (DWORD)sizeof(abPlainPrivateKey);
1187     result = CryptImportKey(hProv, abPlainPrivateKey, dwLen, 0, 0, &hKeyExchangeKey);
1188     if (!result) {
1189         /* rsaenh compiled without OpenSSL */
1190         ok(GetLastError() == NTE_FAIL, "%08x\n", GetLastError());
1191         return;
1192     }
1193
1194     dwLen = (DWORD)sizeof(abSessionKey);
1195     result = CryptImportKey(hProv, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey);
1196     ok(result, "%08x\n", GetLastError());
1197     if (!result) return;
1198
1199     dwLen = (DWORD)sizeof(abEncryptedMessage);
1200     result = CryptDecrypt(hSessionKey, 0, TRUE, 0, abEncryptedMessage, &dwLen);
1201     ok(result && dwLen == 12 && !memcmp(abEncryptedMessage, "Wine rocks!",12),
1202        "%08x, len: %d\n", GetLastError(), dwLen);
1203     CryptDestroyKey(hSessionKey);
1204
1205     if (!derive_key(CALG_RC4, &hSessionKey, 56)) return;
1206
1207     dwLen = (DWORD)sizeof(abSessionKey);
1208     result = CryptExportKey(hSessionKey, hKeyExchangeKey, SIMPLEBLOB, 0, abSessionKey, &dwLen);
1209     ok(result, "%08x\n", GetLastError());
1210     CryptDestroyKey(hSessionKey);
1211     if (!result) return;
1212
1213     dwLen = (DWORD)sizeof(abSessionKey);
1214     result = CryptImportKey(hProv, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey);
1215     ok(result, "%08x\n", GetLastError());
1216     if (!result) return;
1217
1218     CryptDestroyKey(hSessionKey);
1219     CryptDestroyKey(hKeyExchangeKey);
1220 }
1221
1222 static void test_verify_signature(void) {
1223     HCRYPTHASH hHash;
1224     HCRYPTKEY hPubSignKey;
1225     BYTE abData[] = "Wine rocks!";
1226     BOOL result;
1227     BYTE abPubKey[148] = {
1228         0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
1229         0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00,
1230         0x01, 0x00, 0x01, 0x00, 0x71, 0x64, 0x9f, 0x19,
1231         0x89, 0x1c, 0x21, 0xcc, 0x36, 0xa3, 0xc9, 0x27,
1232         0x08, 0x8a, 0x09, 0xc6, 0xbe, 0xeb, 0xd3, 0xf8,
1233         0x19, 0xa9, 0x92, 0x57, 0xe4, 0xb9, 0x5d, 0xda,
1234         0x88, 0x93, 0xe4, 0x6b, 0x38, 0x77, 0x14, 0x8a,
1235         0x96, 0xc0, 0xb6, 0x4e, 0x42, 0xf5, 0x01, 0xdc,
1236         0xf0, 0xeb, 0x3c, 0xc7, 0x7b, 0xc4, 0xfd, 0x7c,
1237         0xde, 0x93, 0x34, 0x0a, 0x92, 0xe5, 0x97, 0x9c,
1238         0x3e, 0x65, 0xb8, 0x91, 0x2f, 0xe3, 0xf3, 0x89,
1239         0xcd, 0x6c, 0x26, 0xa4, 0x6c, 0xc7, 0x6d, 0x0b,
1240         0x2c, 0xa2, 0x0b, 0x29, 0xe2, 0xfc, 0x30, 0xfa,
1241         0x20, 0xdb, 0x4c, 0xb8, 0x91, 0xb8, 0x69, 0x63,
1242         0x96, 0x41, 0xc2, 0xb4, 0x60, 0xeb, 0xcd, 0xff,
1243         0x3a, 0x1f, 0x94, 0xb1, 0x23, 0xcf, 0x0f, 0x49,
1244         0xad, 0xd5, 0x33, 0x85, 0x71, 0xaf, 0x12, 0x87,
1245         0x84, 0xef, 0xa0, 0xea, 0xe1, 0xc1, 0xd4, 0xc7,
1246         0xe1, 0x21, 0x50, 0xac
1247     };
1248     /* md2 with hash oid */
1249     BYTE abSignatureMD2[128] = {
1250         0x4a, 0x4e, 0xb7, 0x5e, 0x32, 0xda, 0xdb, 0x67,
1251         0x9f, 0x77, 0x84, 0x32, 0x00, 0xba, 0x5f, 0x6b,
1252         0x0d, 0xcf, 0xd9, 0x99, 0xbd, 0x96, 0x31, 0xda,
1253         0x23, 0x4c, 0xd9, 0x4a, 0x90, 0x84, 0x20, 0x59,
1254         0x51, 0xdc, 0xd4, 0x93, 0x3a, 0xae, 0x0a, 0x0a,
1255         0xa1, 0x76, 0xfa, 0xb5, 0x68, 0xee, 0xc7, 0x34,
1256         0x41, 0xd3, 0xe7, 0x5a, 0x0e, 0x22, 0x61, 0x40,
1257         0xea, 0x24, 0x56, 0xf1, 0x91, 0x5a, 0xf7, 0xa7,
1258         0x5b, 0xf4, 0x98, 0x6b, 0xc3, 0xef, 0xad, 0xc0,
1259         0x5e, 0x6b, 0x87, 0x76, 0xcb, 0x1f, 0x62, 0x06,
1260         0x7c, 0xf6, 0x48, 0x97, 0x81, 0x8d, 0xef, 0x51,
1261         0x51, 0xdc, 0x21, 0x91, 0x57, 0x1e, 0x79, 0x6f,
1262         0x49, 0xb5, 0xde, 0x31, 0x07, 0x45, 0x99, 0x46,
1263         0xc3, 0x4f, 0xca, 0x2d, 0x0e, 0x4c, 0x10, 0x25,
1264         0xcb, 0x1a, 0x98, 0x63, 0x41, 0x93, 0x47, 0xc0,
1265         0xb2, 0xbc, 0x10, 0x3c, 0xe7, 0xd4, 0x3c, 0x1e
1266     };
1267     /* md2 without hash oid */
1268     BYTE abSignatureMD2NoOID[128] = {
1269         0x0c, 0x21, 0x3e, 0x60, 0xf9, 0xd0, 0x36, 0x2d,
1270         0xe1, 0x10, 0x45, 0x45, 0x85, 0x03, 0x29, 0x19,
1271         0xef, 0x19, 0xd9, 0xa6, 0x7e, 0x9c, 0x0d, 0xbd,
1272         0x03, 0x0e, 0xb9, 0x51, 0x9e, 0x74, 0x79, 0xc4,
1273         0xde, 0x25, 0xf2, 0x35, 0x74, 0x55, 0xbc, 0x65,
1274         0x7e, 0x33, 0x28, 0xa8, 0x1e, 0x72, 0xaa, 0x99,
1275         0xdd, 0xf5, 0x26, 0x20, 0x29, 0xf8, 0xa6, 0xdf,
1276         0x28, 0x4b, 0x1c, 0xdb, 0xa1, 0x41, 0x56, 0xbc,
1277         0xf9, 0x9c, 0x66, 0xc0, 0x37, 0x41, 0x55, 0xa0,
1278         0xe2, 0xec, 0xbf, 0x71, 0xf0, 0x5d, 0x25, 0x01,
1279         0x75, 0x91, 0xe2, 0x81, 0xb2, 0x9f, 0x57, 0xa7,
1280         0x5c, 0xd2, 0xfa, 0x66, 0xdb, 0x71, 0x2b, 0x1f,
1281         0xad, 0x30, 0xde, 0xea, 0x49, 0x73, 0x30, 0x6a,
1282         0x22, 0x54, 0x49, 0x4e, 0xae, 0xf6, 0x88, 0xc9,
1283         0xff, 0x71, 0xba, 0xbf, 0x27, 0xc5, 0xfa, 0x06,
1284         0xe2, 0x91, 0x71, 0x8a, 0x7e, 0x0c, 0xc2, 0x07
1285     };
1286     /* md4 with hash oid */
1287     BYTE abSignatureMD4[128] = {
1288         0x1c, 0x78, 0xaa, 0xea, 0x74, 0xf4, 0x83, 0x51,
1289         0xae, 0x66, 0xe3, 0xa9, 0x1c, 0x03, 0x39, 0x1b,
1290         0xac, 0x7e, 0x4e, 0x85, 0x7e, 0x1c, 0x38, 0xd2,
1291         0x82, 0x43, 0xb3, 0x6f, 0x6f, 0x46, 0x45, 0x8e,
1292         0x17, 0x74, 0x58, 0x29, 0xca, 0xe1, 0x03, 0x13,
1293         0x45, 0x79, 0x34, 0xdf, 0x5c, 0xd6, 0xc3, 0xf9,
1294         0x7a, 0x1c, 0x9d, 0xff, 0x6f, 0x03, 0x7d, 0x0f,
1295         0x59, 0x1a, 0x2d, 0x0e, 0x94, 0xb4, 0x75, 0x96,
1296         0xd1, 0x48, 0x63, 0x6e, 0xb2, 0xc4, 0x5c, 0xd9,
1297         0xab, 0x49, 0xb4, 0x90, 0xd9, 0x57, 0x04, 0x6e,
1298         0x4c, 0xb6, 0xea, 0x00, 0x94, 0x4a, 0x34, 0xa0,
1299         0xd9, 0x63, 0xef, 0x2c, 0xde, 0x5b, 0xb9, 0xbe,
1300         0x35, 0xc8, 0xc1, 0x31, 0xb5, 0x31, 0x15, 0x18,
1301         0x90, 0x39, 0xf5, 0x2a, 0x34, 0x6d, 0xb4, 0xab,
1302         0x09, 0x34, 0x69, 0x54, 0x4d, 0x11, 0x2f, 0xf3,
1303         0xa2, 0x36, 0x0e, 0xa8, 0x45, 0xe7, 0x36, 0xac
1304     };
1305     /* md4 without hash oid */
1306     BYTE abSignatureMD4NoOID[128] = {
1307         0xd3, 0x60, 0xb2, 0xb0, 0x22, 0x0a, 0x99, 0xda,
1308         0x04, 0x85, 0x64, 0xc6, 0xc6, 0xdb, 0x11, 0x24,
1309         0xe9, 0x68, 0x2d, 0xf7, 0x09, 0xef, 0xb6, 0xa0,
1310         0xa2, 0xfe, 0x45, 0xee, 0x85, 0x49, 0xcd, 0x36,
1311         0xf7, 0xc7, 0x9d, 0x2b, 0x4c, 0x68, 0xda, 0x85,
1312         0x8c, 0x50, 0xcc, 0x4f, 0x4b, 0xe1, 0x82, 0xc3,
1313         0xbe, 0xa3, 0xf1, 0x78, 0x6b, 0x60, 0x42, 0x3f,
1314         0x67, 0x22, 0x14, 0xe4, 0xe1, 0xa4, 0x6e, 0xa9,
1315         0x4e, 0xf1, 0xd4, 0xb0, 0xce, 0x82, 0xac, 0x06,
1316         0xba, 0x2c, 0xbc, 0xf7, 0xcb, 0xf6, 0x0c, 0x3f,
1317         0xf6, 0x79, 0xfe, 0xb3, 0xd8, 0x5a, 0xbc, 0xdb,
1318         0x05, 0x41, 0xa4, 0x07, 0x57, 0x9e, 0xa2, 0x96,
1319         0xfc, 0x60, 0x4b, 0xf7, 0x6f, 0x86, 0x26, 0x1f,
1320         0xc2, 0x2c, 0x67, 0x08, 0xcd, 0x7f, 0x91, 0xe9,
1321         0x16, 0xb5, 0x0e, 0xd9, 0xc4, 0xc4, 0x97, 0xeb,
1322         0x91, 0x3f, 0x20, 0x6c, 0xf0, 0x68, 0x86, 0x7f
1323     };
1324     /* md5 with hash oid */
1325     BYTE abSignatureMD5[128] = {
1326         0x4f, 0xe0, 0x8c, 0x9b, 0x43, 0xdd, 0x02, 0xe5,
1327         0xf4, 0xa1, 0xdd, 0x88, 0x4c, 0x9c, 0x40, 0x0f,
1328         0x6c, 0x43, 0x86, 0x64, 0x00, 0xe6, 0xac, 0xf7,
1329         0xd0, 0x92, 0xaa, 0xc4, 0x62, 0x9a, 0x48, 0x98,
1330         0x1a, 0x56, 0x6d, 0x75, 0xec, 0x04, 0x89, 0xec,
1331         0x69, 0x93, 0xd6, 0x61, 0x37, 0xb2, 0x36, 0xb5,
1332         0xb2, 0xba, 0xf2, 0xf5, 0x21, 0x0c, 0xf1, 0x04,
1333         0xc8, 0x2d, 0xf5, 0xa0, 0x8d, 0x6d, 0x10, 0x0b,
1334         0x68, 0x63, 0xf2, 0x08, 0x68, 0xdc, 0xbd, 0x95,
1335         0x25, 0x7d, 0xee, 0x63, 0x5c, 0x3b, 0x98, 0x4c,
1336         0xea, 0x41, 0xdc, 0x6a, 0x8b, 0x6c, 0xbb, 0x29,
1337         0x2b, 0x1c, 0x5c, 0x8b, 0x7d, 0x94, 0x24, 0xa9,
1338         0x7a, 0x62, 0x94, 0xf3, 0x3a, 0x6a, 0xb2, 0x4c,
1339         0x33, 0x59, 0x00, 0xcd, 0x7d, 0x37, 0x79, 0x90,
1340         0x31, 0xd1, 0xd9, 0x84, 0x12, 0xe5, 0x08, 0x5e,
1341         0xb3, 0x60, 0x61, 0x27, 0x78, 0x37, 0x63, 0x01
1342     };
1343     /* md5 without hash oid */
1344     BYTE abSignatureMD5NoOID[128] = {
1345         0xc6, 0xad, 0x5c, 0x2b, 0x9b, 0xe0, 0x99, 0x2f,
1346         0x5e, 0x55, 0x04, 0x32, 0x65, 0xe0, 0xb5, 0x75,
1347         0x01, 0x9a, 0x11, 0x4d, 0x0e, 0x9a, 0xe1, 0x9f,
1348         0xc7, 0xbf, 0x77, 0x6d, 0xa9, 0xfd, 0xcc, 0x9d,
1349         0x8b, 0xd1, 0x31, 0xed, 0x5a, 0xd2, 0xe5, 0x5f,
1350         0x42, 0x3b, 0xb5, 0x3c, 0x32, 0x30, 0x88, 0x49,
1351         0xcb, 0x67, 0xb8, 0x2e, 0xc9, 0xf5, 0x2b, 0xc8,
1352         0x35, 0x71, 0xb5, 0x1b, 0x32, 0x3f, 0x44, 0x4c,
1353         0x66, 0x93, 0xcb, 0xe8, 0x48, 0x7c, 0x14, 0x23,
1354         0xfb, 0x12, 0xa5, 0xb7, 0x86, 0x94, 0x6b, 0x19,
1355         0x17, 0x20, 0xc6, 0xb8, 0x09, 0xe8, 0xbb, 0xdb,
1356         0x00, 0x2b, 0x96, 0x4a, 0x93, 0x00, 0x26, 0xd3,
1357         0x07, 0xa0, 0x06, 0xce, 0x5a, 0x13, 0x69, 0x6b,
1358         0x62, 0x5a, 0x56, 0x61, 0x6a, 0xd8, 0x11, 0x3b,
1359         0xd5, 0x67, 0xc7, 0x4d, 0xf6, 0x66, 0x63, 0xc5,
1360         0xe3, 0x8f, 0x7c, 0x7c, 0xb1, 0x3e, 0x55, 0x43
1361     };
1362     /* sha with hash oid */
1363     BYTE abSignatureSHA[128] = {
1364         0x5a, 0x4c, 0x66, 0xc9, 0x30, 0x67, 0xcb, 0x91,
1365         0x3c, 0x4d, 0xd5, 0x8d, 0xea, 0x4e, 0x85, 0xcd,
1366         0xd9, 0x68, 0x3a, 0xf3, 0x24, 0x3c, 0x99, 0x24,
1367         0x25, 0x32, 0x93, 0x3d, 0xd6, 0x2f, 0x86, 0x94,
1368         0x23, 0x09, 0xee, 0x02, 0xd4, 0x15, 0xdc, 0x5f,
1369         0x0e, 0x44, 0x45, 0x13, 0x5f, 0x18, 0x5d, 0x1a,
1370         0xd7, 0x0b, 0xd1, 0x23, 0xd6, 0x35, 0x98, 0x52,
1371         0x57, 0x45, 0x74, 0x92, 0xe3, 0x50, 0xb4, 0x20,
1372         0x28, 0x2a, 0x11, 0xbf, 0x49, 0xb4, 0x2c, 0xc5,
1373         0xd4, 0x1a, 0x27, 0x4e, 0xdf, 0xa0, 0xb5, 0x7a,
1374         0xc8, 0x14, 0xdd, 0x9b, 0xb6, 0xca, 0xd6, 0xff,
1375         0xb2, 0x6b, 0xd8, 0x98, 0x67, 0x80, 0xab, 0x53,
1376         0x52, 0xbb, 0xe1, 0x2a, 0xce, 0x79, 0x2f, 0x00,
1377         0x53, 0x26, 0xd8, 0xa7, 0x43, 0xca, 0x72, 0x0e,
1378         0x68, 0x97, 0x37, 0x71, 0x87, 0xc2, 0x6a, 0x98,
1379         0xbb, 0x6c, 0xa0, 0x01, 0xff, 0x04, 0x9d, 0xa6
1380     };
1381     /* sha without hash oid */
1382     BYTE abSignatureSHANoOID[128] = {
1383         0x86, 0xa6, 0x2b, 0x9a, 0x04, 0xda, 0x47, 0xc6,
1384         0x4f, 0x97, 0x8a, 0x8a, 0xf4, 0xfa, 0x63, 0x1a,
1385         0x32, 0x89, 0x56, 0x41, 0x37, 0x91, 0x15, 0x2f,
1386         0x2d, 0x1c, 0x8f, 0xdc, 0x88, 0x40, 0xbb, 0x37,
1387         0x3e, 0x06, 0x33, 0x1b, 0xde, 0xda, 0x7c, 0x65,
1388         0x91, 0x35, 0xca, 0x45, 0x17, 0x0e, 0x24, 0xbe,
1389         0x9e, 0xf6, 0x4e, 0x8a, 0xa4, 0x3e, 0xca, 0xe6,
1390         0x11, 0x36, 0xb8, 0x3a, 0xf0, 0xde, 0x71, 0xfe,
1391         0xdd, 0xb3, 0xcb, 0x6c, 0x39, 0xe0, 0x5f, 0x0c,
1392         0x9e, 0xa8, 0x40, 0x26, 0x9c, 0x81, 0xe9, 0xc4,
1393         0x15, 0x90, 0xbf, 0x4f, 0xd2, 0xc1, 0xa1, 0x80,
1394         0x52, 0xfd, 0xf6, 0x3d, 0x99, 0x1b, 0x9c, 0x8a,
1395         0x27, 0x1b, 0x0c, 0x9a, 0xf3, 0xf9, 0xa2, 0x00,
1396         0x3e, 0x5b, 0xdf, 0xc2, 0xb4, 0x71, 0xa5, 0xbd,
1397         0xf8, 0xae, 0x63, 0xbb, 0x4a, 0xc9, 0xdd, 0x67,
1398         0xc1, 0x3e, 0x93, 0xee, 0xf1, 0x1f, 0x24, 0x5b
1399     };
1400
1401     result = CryptImportKey(hProv, abPubKey, 148, 0, 0, &hPubSignKey);
1402     ok(result, "%08x\n", GetLastError());
1403     if (!result) return;
1404
1405     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
1406     ok(result, "%08x\n", GetLastError());
1407     if (!result) return;
1408
1409     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1410     ok(result, "%08x\n", GetLastError());
1411     if (!result) return;
1412
1413     /*check that a NULL pointer signature is correctly handled*/
1414     result = CryptVerifySignature(hHash, NULL, 128, hPubSignKey, NULL, 0);
1415     ok(!result && ERROR_INVALID_PARAMETER == GetLastError(),
1416      "Expected ERROR_INVALID_PARAMETER error, got %08x\n", GetLastError());
1417     if (result) return;
1418
1419     /* check that we get a bad signature error when the signature is too short*/
1420     result = CryptVerifySignature(hHash, abSignatureMD2, 64, hPubSignKey, NULL, 0);
1421     ok(!result && NTE_BAD_SIGNATURE == GetLastError(),
1422      "Expected NTE_BAD_SIGNATURE error, got %08x\n", GetLastError());
1423     if (result) return;
1424
1425     result = CryptVerifySignature(hHash, abSignatureMD2, 128, hPubSignKey, NULL, 0);
1426     ok(result, "%08x\n", GetLastError());
1427     if (!result) return;
1428
1429     result = CryptVerifySignature(hHash, abSignatureMD2NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1430     ok(result, "%08x\n", GetLastError());
1431     if (!result) return;
1432
1433     /* Next test fails on WinXP SP2. It seems that CPVerifySignature doesn't care about
1434      * the OID at all. */
1435     /*result = CryptVerifySignature(hHash, abSignatureMD2NoOID, 128, hPubSignKey, NULL, 0);
1436     ok(!result && GetLastError()==NTE_BAD_SIGNATURE, "%08lx\n", GetLastError());
1437     if (result) return;*/
1438
1439     CryptDestroyHash(hHash);
1440
1441     result = CryptCreateHash(hProv, CALG_MD4, 0, 0, &hHash);
1442     ok(result, "%08x\n", GetLastError());
1443     if (!result) return;
1444
1445     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1446     ok(result, "%08x\n", GetLastError());
1447     if (!result) return;
1448
1449     result = CryptVerifySignature(hHash, abSignatureMD4, 128, hPubSignKey, NULL, 0);
1450     ok(result, "%08x\n", GetLastError());
1451     if (!result) return;
1452
1453     result = CryptVerifySignature(hHash, abSignatureMD4NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1454     ok(result, "%08x\n", GetLastError());
1455     if (!result) return;
1456
1457     CryptDestroyHash(hHash);
1458
1459     result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
1460     ok(result, "%08x\n", GetLastError());
1461     if (!result) return;
1462
1463     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1464     ok(result, "%08x\n", GetLastError());
1465     if (!result) return;
1466
1467     result = CryptVerifySignature(hHash, abSignatureMD5, 128, hPubSignKey, NULL, 0);
1468     ok(result, "%08x\n", GetLastError());
1469     if (!result) return;
1470
1471     result = CryptVerifySignature(hHash, abSignatureMD5NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1472     ok(result, "%08x\n", GetLastError());
1473     if (!result) return;
1474
1475     CryptDestroyHash(hHash);
1476
1477     result = CryptCreateHash(hProv, CALG_SHA, 0, 0, &hHash);
1478     ok(result, "%08x\n", GetLastError());
1479     if (!result) return;
1480
1481     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1482     ok(result, "%08x\n", GetLastError());
1483     if (!result) return;
1484
1485     result = CryptVerifySignature(hHash, abSignatureSHA, 128, hPubSignKey, NULL, 0);
1486     ok(result, "%08x\n", GetLastError());
1487     if (!result) return;
1488
1489     result = CryptVerifySignature(hHash, abSignatureSHANoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1490     ok(result, "%08x\n", GetLastError());
1491     if (!result) return;
1492
1493     CryptDestroyHash(hHash);
1494     CryptDestroyKey(hPubSignKey);
1495 }
1496
1497 static void test_rsa_encrypt(void)
1498 {
1499     HCRYPTKEY hRSAKey;
1500     BYTE abData[2048] = "Wine rocks!";
1501     BOOL result;
1502     DWORD dwLen;
1503
1504     /* It is allowed to use the key exchange key for encryption/decryption */
1505     result = CryptGetUserKey(hProv, AT_KEYEXCHANGE, &hRSAKey);
1506     ok (result, "%08x\n", GetLastError());
1507     if (!result) return;
1508
1509     dwLen = 12;
1510     result = CryptEncrypt(hRSAKey, 0, TRUE, 0, NULL, &dwLen, (DWORD)sizeof(abData));
1511     ok(result, "CryptEncrypt failed: %08x\n", GetLastError());
1512     ok(dwLen == 128, "Unexpected length %d\n", dwLen);
1513     dwLen = 12;
1514     result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, (DWORD)sizeof(abData));
1515     ok (result, "%08x\n", GetLastError());
1516     if (!result) return;
1517
1518     result = CryptDecrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen);
1519     ok (result && dwLen == 12 && !memcmp(abData, "Wine rocks!", 12), "%08x\n", GetLastError());
1520
1521     CryptDestroyKey(hRSAKey);
1522
1523     /* It is not allowed to use the signature key for encryption/decryption */
1524     result = CryptGetUserKey(hProv, AT_SIGNATURE, &hRSAKey);
1525     ok (result, "%08x\n", GetLastError());
1526     if (!result) return;
1527
1528     dwLen = 12;
1529     result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, (DWORD)sizeof(abData));
1530     ok (!result && GetLastError() == NTE_BAD_KEY, "%08x\n", GetLastError());
1531
1532     CryptDestroyKey(hRSAKey);
1533 }
1534
1535 static void test_import_export(void)
1536 {
1537     DWORD dwLen, dwDataLen;
1538     HCRYPTKEY hPublicKey;
1539     BOOL result;
1540     ALG_ID algID;
1541     BYTE emptyKey[2048];
1542     static BYTE abPlainPublicKey[84] = {
1543         0x06, 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00,
1544         0x52, 0x53, 0x41, 0x31, 0x00, 0x02, 0x00, 0x00,
1545         0x01, 0x00, 0x01, 0x00, 0x11, 0x11, 0x11, 0x11,
1546         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1547         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1548         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1549         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1550         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1551         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1552         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1553         0x11, 0x11, 0x11, 0x11
1554     };
1555
1556     dwLen=84;
1557     result = CryptImportKey(hProv, abPlainPublicKey, dwLen, 0, 0, &hPublicKey);
1558     ok(result, "failed to import the public key\n");
1559
1560     dwDataLen=sizeof(algID);
1561     result = CryptGetKeyParam(hPublicKey, KP_ALGID, (LPBYTE)&algID, &dwDataLen, 0);
1562     ok(result, "failed to get the KP_ALGID from the imported public key\n");
1563     ok(algID == CALG_RSA_KEYX, "Expected CALG_RSA_KEYX, got %x\n", algID);
1564
1565     result = CryptExportKey(hPublicKey, 0, PUBLICKEYBLOB, 0, emptyKey, &dwLen);
1566     ok(result, "failed to export the fresh imported public key\n");
1567     ok(dwLen == 84, "Expected exported key to be 84 bytes long but got %d bytes.\n",dwLen);
1568     ok(!memcmp(emptyKey, abPlainPublicKey, dwLen), "exported key is different from the imported key\n");
1569
1570     CryptDestroyKey(hPublicKey);
1571 }
1572
1573 static void test_schannel_provider(void)
1574 {
1575     HCRYPTPROV hProv;
1576     HCRYPTKEY hRSAKey, hMasterSecret, hServerWriteKey, hServerWriteMACKey;
1577     HCRYPTHASH hMasterHash, hTLS1PRF, hHMAC;
1578     BOOL result;
1579     DWORD dwLen;
1580     SCHANNEL_ALG saSChannelAlg;
1581     CRYPT_DATA_BLOB data_blob;
1582     HMAC_INFO hmacInfo = { CALG_MD5, NULL, 0, NULL, 0 };
1583     BYTE abTLS1Master[140] = {
1584         0x01, 0x02, 0x00, 0x00, 0x06, 0x4c, 0x00, 0x00,
1585         0x00, 0xa4, 0x00, 0x00, 0x5b, 0x13, 0xc7, 0x68,
1586         0xd8, 0x55, 0x23, 0x5d, 0xbc, 0xa6, 0x9d, 0x97,
1587         0x0e, 0xcd, 0x6b, 0xcf, 0xc0, 0xdc, 0xc5, 0x53,
1588         0x28, 0xa0, 0xca, 0xc1, 0x63, 0x4e, 0x3a, 0x24,
1589         0x22, 0xe5, 0x4d, 0x15, 0xbb, 0xa5, 0x06, 0xc3,
1590         0x98, 0x25, 0xdc, 0x35, 0xd3, 0xdb, 0xab, 0xb8,
1591         0x44, 0x1b, 0xfe, 0x63, 0x88, 0x7c, 0x2e, 0x6d,
1592         0x34, 0xd9, 0x0f, 0x7e, 0x2f, 0xc2, 0xb2, 0x6e,
1593         0x56, 0xfa, 0xab, 0xb2, 0x88, 0xf6, 0x15, 0x6e,
1594         0xa8, 0xcd, 0x70, 0x16, 0x94, 0x61, 0x07, 0x40,
1595         0x9e, 0x25, 0x22, 0xf8, 0x64, 0x9f, 0xcc, 0x0b,
1596         0xf1, 0x92, 0x4d, 0xfe, 0xc3, 0x5d, 0x52, 0xdb,
1597         0x0f, 0xff, 0x12, 0x0f, 0x49, 0x43, 0x7d, 0xc6,
1598         0x52, 0x61, 0xb0, 0x06, 0xc8, 0x1b, 0x90, 0xac,
1599         0x09, 0x7e, 0x4b, 0x95, 0x69, 0x3b, 0x0d, 0x41,
1600         0x1b, 0x4c, 0x65, 0x75, 0x4d, 0x85, 0x16, 0xc4,
1601         0xd3, 0x1e, 0x82, 0xb3
1602     };
1603     BYTE abServerSecret[33] = "Super Secret Server Secret 12345";
1604     BYTE abClientSecret[33] = "Super Secret Client Secret 12345";
1605     BYTE abHashedHandshakes[37] = "123456789012345678901234567890123456";
1606     BYTE abClientFinished[16] = "client finished";
1607     BYTE abData[16] = "Wine rocks!";
1608     BYTE abMD5Hash[16];
1609     static const BYTE abEncryptedData[16] = {
1610         0x13, 0xd2, 0xdd, 0xeb, 0x6c, 0x3f, 0xbe, 0xb2,
1611         0x04, 0x86, 0xb5, 0xe5, 0x08, 0xe5, 0xf3, 0x0d
1612     };
1613     static const BYTE abPRF[16] = {
1614         0xa8, 0xb2, 0xa6, 0xef, 0x83, 0x4e, 0x74, 0xb1,
1615         0xf3, 0xb1, 0x51, 0x5a, 0x1a, 0x2b, 0x11, 0x31
1616     };
1617     static const BYTE abMD5[16] = {
1618         0xe1, 0x65, 0x3f, 0xdb, 0xbb, 0x3d, 0x99, 0x3c,
1619         0x3d, 0xca, 0x6a, 0x6f, 0xfa, 0x15, 0x4e, 0xaa
1620     };
1621
1622     result = CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT|CRYPT_NEWKEYSET);
1623     ok (result, "%08x\n", GetLastError());
1624     if (result)
1625         CryptReleaseContext(hProv, 0);
1626
1627     result = CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT);
1628     ok (result, "%08x\n", GetLastError());
1629     if (!result) return;
1630
1631     /* To get deterministic results, we import the TLS1 master secret (which
1632      * is typically generated from a random generator). Therefore, we need
1633      * an RSA key. */
1634     dwLen = (DWORD)sizeof(abPlainPrivateKey);
1635     result = CryptImportKey(hProv, abPlainPrivateKey, dwLen, 0, 0, &hRSAKey);
1636     ok (result, "%08x\n", GetLastError());
1637     if (!result) return;
1638
1639     dwLen = (DWORD)sizeof(abTLS1Master);
1640     result = CryptImportKey(hProv, abTLS1Master, dwLen, hRSAKey, 0, &hMasterSecret);
1641     ok (result, "%08x\n", GetLastError());
1642     if (!result) return;
1643
1644     /* Setting the TLS1 client and server random parameters, as well as the
1645      * MAC and encryption algorithm parameters. */
1646     data_blob.cbData = 33;
1647     data_blob.pbData = abClientSecret;
1648     result = CryptSetKeyParam(hMasterSecret, KP_CLIENT_RANDOM, (BYTE*)&data_blob, 0);
1649     ok (result, "%08x\n", GetLastError());
1650     if (!result) return;
1651
1652     data_blob.cbData = 33;
1653     data_blob.pbData = abServerSecret;
1654     result = CryptSetKeyParam(hMasterSecret, KP_SERVER_RANDOM, (BYTE*)&data_blob, 0);
1655     ok (result, "%08x\n", GetLastError());
1656     if (!result) return;
1657
1658     saSChannelAlg.dwUse = SCHANNEL_ENC_KEY;
1659     saSChannelAlg.Algid = CALG_DES;
1660     saSChannelAlg.cBits = 64;
1661     saSChannelAlg.dwFlags = 0;
1662     saSChannelAlg.dwReserved = 0;
1663     result = CryptSetKeyParam(hMasterSecret, KP_SCHANNEL_ALG, (PBYTE)&saSChannelAlg, 0);
1664     ok (result, "%08x\n", GetLastError());
1665     if (!result) return;
1666
1667     saSChannelAlg.dwUse = SCHANNEL_MAC_KEY;
1668     saSChannelAlg.Algid = CALG_MD5;
1669     saSChannelAlg.cBits = 128;
1670     saSChannelAlg.dwFlags = 0;
1671     saSChannelAlg.dwReserved = 0;
1672     result = CryptSetKeyParam(hMasterSecret, KP_SCHANNEL_ALG, (PBYTE)&saSChannelAlg, 0);
1673     ok (result, "%08x\n", GetLastError());
1674     if (!result) return;
1675
1676     /* Deriving a hash from the master secret. This is due to the CryptoAPI architecture.
1677      * (Keys can only be derived from hashes, not from other keys.) */
1678     result = CryptCreateHash(hProv, CALG_SCHANNEL_MASTER_HASH, hMasterSecret, 0, &hMasterHash);
1679     ok (result, "%08x\n", GetLastError());
1680     if (!result) return;
1681
1682     /* Deriving the server write encryption key from the master hash */
1683     result = CryptDeriveKey(hProv, CALG_SCHANNEL_ENC_KEY, hMasterHash, CRYPT_SERVER, &hServerWriteKey);
1684     ok (result, "%08x\n", GetLastError());
1685     if (!result) return;
1686
1687     /* Encrypting some data with the server write encryption key and checking the result. */
1688     dwLen = 12;
1689     result = CryptEncrypt(hServerWriteKey, 0, TRUE, 0, abData, &dwLen, 16);
1690     ok (result && (dwLen == 16) && !memcmp(abData, abEncryptedData, 16), "%08x\n", GetLastError());
1691
1692     /* Second test case: Test the TLS1 pseudo random number function. */
1693     result = CryptCreateHash(hProv, CALG_TLS1PRF, hMasterSecret, 0, &hTLS1PRF);
1694     ok (result, "%08x\n", GetLastError());
1695     if (!result) return;
1696
1697     /* Set the label and seed parameters for the random number function */
1698     data_blob.cbData = 36;
1699     data_blob.pbData = abHashedHandshakes;
1700     result = CryptSetHashParam(hTLS1PRF, HP_TLS1PRF_SEED, (BYTE*)&data_blob, 0);
1701     ok (result, "%08x\n", GetLastError());
1702     if (!result) return;
1703
1704     data_blob.cbData = 15;
1705     data_blob.pbData = abClientFinished;
1706     result = CryptSetHashParam(hTLS1PRF, HP_TLS1PRF_LABEL, (BYTE*)&data_blob, 0);
1707     ok (result, "%08x\n", GetLastError());
1708     if (!result) return;
1709
1710     /* Generate some pseudo random bytes and check if they are correct. */
1711     dwLen = (DWORD)sizeof(abData);
1712     result = CryptGetHashParam(hTLS1PRF, HP_HASHVAL, abData, &dwLen, 0);
1713     ok (result && (dwLen==(DWORD)sizeof(abData)) && !memcmp(abData, abPRF, sizeof(abData)),
1714         "%08x\n", GetLastError());
1715
1716     /* Third test case. Derive the server write mac key. Derive an HMAC object from this one.
1717      * Hash some data with the HMAC. Compare results. */
1718     result = CryptDeriveKey(hProv, CALG_SCHANNEL_MAC_KEY, hMasterHash, CRYPT_SERVER, &hServerWriteMACKey);
1719     ok (result, "%08x\n", GetLastError());
1720     if (!result) return;
1721
1722     result = CryptCreateHash(hProv, CALG_HMAC, hServerWriteMACKey, 0, &hHMAC);
1723     ok (result, "%08x\n", GetLastError());
1724     if (!result) return;
1725
1726     result = CryptSetHashParam(hHMAC, HP_HMAC_INFO, (PBYTE)&hmacInfo, 0);
1727     ok (result, "%08x\n", GetLastError());
1728     if (!result) return;
1729
1730     result = CryptHashData(hHMAC, abData, (DWORD)sizeof(abData), 0);
1731     ok (result, "%08x\n", GetLastError());
1732     if (!result) return;
1733
1734     dwLen = (DWORD)sizeof(abMD5Hash);
1735     result = CryptGetHashParam(hHMAC, HP_HASHVAL, abMD5Hash, &dwLen, 0);
1736     ok (result && (dwLen == 16) && !memcmp(abMD5Hash, abMD5, 16), "%08x\n", GetLastError());
1737
1738     CryptDestroyHash(hHMAC);
1739     CryptDestroyHash(hTLS1PRF);
1740     CryptDestroyHash(hMasterHash);
1741     CryptDestroyKey(hServerWriteMACKey);
1742     CryptDestroyKey(hServerWriteKey);
1743     CryptDestroyKey(hRSAKey);
1744     CryptDestroyKey(hMasterSecret);
1745     CryptReleaseContext(hProv, 0);
1746     CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_DELETEKEYSET);
1747 }
1748
1749 static void test_enum_container(void)
1750 {
1751     BYTE abContainerName[MAX_PATH + 2]; /* Larger than maximum name len */
1752     DWORD dwBufferLen;
1753     BOOL result, fFound = FALSE;
1754
1755     /* If PP_ENUMCONTAINERS is queried with CRYPT_FIRST and abData == NULL, it returns
1756      * the maximum legal length of container names (which is MAX_PATH + 1 == 261) */
1757     result = CryptGetProvParam(hProv, PP_ENUMCONTAINERS, NULL, &dwBufferLen, CRYPT_FIRST);
1758     ok (result && dwBufferLen == MAX_PATH + 1, "%08x\n", GetLastError());
1759
1760     /* If the result fits into abContainerName dwBufferLen is left untouched */
1761     dwBufferLen = (DWORD)sizeof(abContainerName);
1762     result = CryptGetProvParam(hProv, PP_ENUMCONTAINERS, abContainerName, &dwBufferLen, CRYPT_FIRST);
1763     ok (result && dwBufferLen == (DWORD)sizeof(abContainerName), "%08x\n", GetLastError());
1764
1765     /* We only check, if the currently open 'winetest' container is among the enumerated. */
1766     do {
1767         if (!strcmp((const char*)abContainerName, "winetest")) fFound = TRUE;
1768         dwBufferLen = (DWORD)sizeof(abContainerName);
1769     } while (CryptGetProvParam(hProv, PP_ENUMCONTAINERS, abContainerName, &dwBufferLen, 0));
1770
1771     ok (fFound && GetLastError() == ERROR_NO_MORE_ITEMS, "%d, %08x\n", fFound, GetLastError());
1772 }
1773
1774 static BYTE signBlob[] = {
1775 0x07,0x02,0x00,0x00,0x00,0x24,0x00,0x00,0x52,0x53,0x41,0x32,0x00,0x02,0x00,0x00,
1776 0x01,0x00,0x01,0x00,0xf1,0x82,0x9e,0x84,0xb5,0x79,0x9a,0xbe,0x4d,0x06,0x20,0x21,
1777 0xb1,0x89,0x0c,0xca,0xb0,0x35,0x72,0x18,0xc6,0x92,0xa8,0xe2,0xb1,0xe1,0xf6,0x56,
1778 0x53,0x99,0x47,0x10,0x6e,0x1c,0x81,0xaf,0xb8,0xf9,0x5f,0xfe,0x76,0x7f,0x2c,0x93,
1779 0xec,0x54,0x7e,0x5e,0xc2,0x25,0x3c,0x50,0x56,0x10,0x20,0x72,0x4a,0x93,0x03,0x12,
1780 0x29,0x98,0xcc,0xc9,0x47,0xbf,0xbf,0x93,0xcc,0xb0,0xe5,0x53,0x14,0xc8,0x7e,0x1f,
1781 0xa4,0x03,0x2d,0x8e,0x84,0x7a,0xd2,0xeb,0xf7,0x92,0x5e,0xa2,0xc7,0x6b,0x35,0x7d,
1782 0xcb,0x60,0xae,0xfb,0x07,0x78,0x11,0x73,0xb5,0x79,0xe5,0x7e,0x96,0xe3,0x50,0x95,
1783 0x80,0x0e,0x1c,0xf6,0x56,0xc6,0xe9,0x0a,0xaf,0x03,0xc6,0xdc,0x9a,0x81,0xcf,0x7a,
1784 0x63,0x16,0x43,0xcd,0xab,0x74,0xa1,0x7d,0xe7,0xe0,0x75,0x6d,0xbd,0x19,0xae,0x0b,
1785 0xa3,0x7f,0x6a,0x7b,0x05,0x4e,0xbc,0xec,0x18,0xfc,0x19,0xc2,0x00,0xf0,0x6a,0x2e,
1786 0xc4,0x31,0x73,0xba,0x07,0xcc,0x9d,0x57,0xeb,0xc7,0x7c,0x00,0x7d,0x5d,0x11,0x16,
1787 0x42,0x4b,0xe5,0x3a,0xf5,0xc7,0xf8,0xee,0xc3,0x2c,0x0d,0x86,0x03,0xe2,0xaf,0xb2,
1788 0xd2,0x91,0xdb,0x71,0xcd,0xdf,0x81,0x5f,0x06,0xfc,0x48,0x0d,0xb6,0x88,0x9f,0xc1,
1789 0x5e,0x24,0xa2,0x05,0x4f,0x30,0x2e,0x8f,0x8b,0x0d,0x76,0xa1,0x84,0xda,0x7b,0x44,
1790 0x70,0x85,0xf1,0x50,0xb1,0x21,0x3d,0xe2,0x57,0x3d,0xd0,0x01,0x93,0x49,0x8e,0xc5,
1791 0x0b,0x8b,0x0d,0x7b,0x08,0xe9,0x14,0xec,0x20,0x0d,0xea,0x02,0x00,0x63,0xe8,0x0a,
1792 0x52,0xe8,0xfb,0x21,0xbd,0x37,0xde,0x4c,0x4d,0xc2,0xf6,0xb9,0x0d,0x2a,0xc3,0xe2,
1793 0xc9,0xdf,0x48,0x3e,0x55,0x3d,0xe3,0xc0,0x22,0x37,0xf9,0x52,0xc0,0xd7,0x61,0x22,
1794 0xb6,0x85,0x86,0x07 };
1795
1796 static void test_null_provider(void)
1797 {
1798     HCRYPTPROV prov;
1799     HCRYPTKEY key;
1800     BOOL result;
1801     DWORD keySpec, dataLen,dwParam;
1802     char szName[MAX_PATH];
1803
1804     result = CryptAcquireContext(NULL, szContainer, NULL, 0, 0);
1805     ok(!result && GetLastError() == NTE_BAD_PROV_TYPE,
1806      "Expected NTE_BAD_PROV_TYPE, got %08x\n", GetLastError());
1807     result = CryptAcquireContext(NULL, szContainer, NULL, PROV_RSA_FULL, 0);
1808     ok(!result && (GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == NTE_BAD_KEYSET),
1809      "Expected ERROR_INVALID_PARAMETER or NTE_BAD_KEYSET, got %08x\n", GetLastError());
1810     result = CryptAcquireContext(NULL, szContainer, NULL, PROV_RSA_FULL,
1811      CRYPT_DELETEKEYSET);
1812     ok(!result && ( GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == NTE_BAD_KEYSET),
1813      "Expected ERROR_INVALID_PARAMETER or NTE_BAD_KEYSET, got %08x\n", GetLastError());
1814     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1815      CRYPT_DELETEKEYSET);
1816     ok(!result && GetLastError() == NTE_BAD_KEYSET,
1817      "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
1818     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL, 0);
1819     ok(!result && GetLastError() == NTE_BAD_KEYSET,
1820      "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
1821
1822     /* Delete the default container. */
1823     CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
1824     /* Once you've deleted the default container you can't open it as if it
1825      * already exists.
1826      */
1827     result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, 0);
1828     ok(!result && GetLastError() == NTE_BAD_KEYSET,
1829      "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
1830     /* But you can always open the default container for CRYPT_VERIFYCONTEXT. */
1831     result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL,
1832      CRYPT_VERIFYCONTEXT);
1833     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
1834     if (!result) return;
1835     dataLen = sizeof(keySpec);
1836     result = CryptGetProvParam(prov, PP_KEYSPEC, (LPBYTE)&keySpec, &dataLen, 0);
1837     if (result)
1838         ok(keySpec == (AT_KEYEXCHANGE | AT_SIGNATURE),
1839          "Expected AT_KEYEXCHANGE | AT_SIGNATURE, got %08x\n", keySpec);
1840     /* Even though PP_KEYSPEC says both AT_KEYEXCHANGE and AT_SIGNATURE are
1841      * supported, you can't get the keys from this container.
1842      */
1843     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1844     ok(!result && GetLastError() == NTE_NO_KEY,
1845      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1846     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1847     ok(!result && GetLastError() == NTE_NO_KEY,
1848      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1849     result = CryptReleaseContext(prov, 0);
1850     ok(result, "CryptReleaseContext failed: %08x\n", GetLastError());
1851     /* You can create a new default container. */
1852     result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL,
1853      CRYPT_NEWKEYSET);
1854     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
1855     /* But you still can't get the keys (until one's been generated.) */
1856     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1857     ok(!result && GetLastError() == NTE_NO_KEY,
1858      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1859     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1860     ok(!result && GetLastError() == NTE_NO_KEY,
1861      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1862     CryptReleaseContext(prov, 0);
1863     CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
1864
1865     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1866      CRYPT_DELETEKEYSET);
1867     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL, 0);
1868     ok(!result && GetLastError() == NTE_BAD_KEYSET,
1869      "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
1870     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1871      CRYPT_VERIFYCONTEXT);
1872     ok(!result && GetLastError() == NTE_BAD_FLAGS,
1873      "Expected NTE_BAD_FLAGS, got %08x\n", GetLastError());
1874     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1875      CRYPT_NEWKEYSET);
1876     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
1877     if (!result) return;
1878     /* Test provider parameters getter */
1879     dataLen = sizeof(dwParam);
1880     result = CryptGetProvParam(prov, PP_PROVTYPE, (LPBYTE)&dwParam, &dataLen, 0);
1881     ok(result && dataLen == sizeof(dwParam) && dwParam == PROV_RSA_FULL,
1882         "Expected PROV_RSA_FULL, got 0x%08X\n",dwParam);
1883     dataLen = sizeof(dwParam);
1884     result = CryptGetProvParam(prov, PP_KEYSET_TYPE, (LPBYTE)&dwParam, &dataLen, 0);
1885     ok(result && dataLen == sizeof(dwParam) && dwParam == 0,
1886         "Expected 0, got 0x%08X\n",dwParam);
1887     dataLen = sizeof(dwParam);
1888     result = CryptGetProvParam(prov, PP_KEYSTORAGE, (LPBYTE)&dwParam, &dataLen, 0);
1889     ok(result && dataLen == sizeof(dwParam) && (dwParam & CRYPT_SEC_DESCR),
1890         "Expected CRYPT_SEC_DESCR to be set, got 0x%08X\n",dwParam);
1891     dataLen = sizeof(keySpec);
1892     SetLastError(0xdeadbeef);
1893     result = CryptGetProvParam(prov, PP_KEYSPEC, (LPBYTE)&keySpec, &dataLen, 0);
1894     if (!result && GetLastError() == NTE_BAD_TYPE)
1895         skip("PP_KEYSPEC is not supported (win9x or NT)\n");
1896     else
1897         ok(result && keySpec == (AT_KEYEXCHANGE | AT_SIGNATURE),
1898             "Expected AT_KEYEXCHANGE | AT_SIGNATURE, got %08x\n", keySpec);
1899     /* PP_CONTAINER parameter */
1900     dataLen = sizeof(szName);
1901     result = CryptGetProvParam(prov, PP_CONTAINER, (LPBYTE)szName, &dataLen, 0);
1902     ok(result && dataLen == strlen(szContainer)+1 && strcmp(szContainer,szName) == 0,
1903         "failed getting PP_CONTAINER. result = %s. Error 0x%08X. returned length = %d\n",
1904         (result)? "TRUE":"FALSE",GetLastError(),dataLen);
1905     /* PP_UNIQUE_CONTAINER parameter */
1906     dataLen = sizeof(szName);
1907     SetLastError(0xdeadbeef);
1908     result = CryptGetProvParam(prov, PP_UNIQUE_CONTAINER, (LPBYTE)szName, &dataLen, 0);
1909     if (!result && GetLastError() == NTE_BAD_TYPE)
1910     {
1911         skip("PP_UNIQUE_CONTAINER is not supported (win9x or NT)\n");
1912     }
1913     else
1914     {
1915         char container[MAX_PATH];
1916
1917         ok(result, "failed getting PP_UNIQUE_CONTAINER : 0x%08X\n", GetLastError());
1918         uniquecontainer(container);
1919         todo_wine
1920         {
1921             ok(dataLen == strlen(container)+1, "Expected a param length of 70, got %d\n", dataLen);
1922             ok(!strcmp(container, szName), "Wrong container name : %s\n", szName);
1923         }
1924     }
1925     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1926     ok(!result && GetLastError() == NTE_NO_KEY,
1927      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1928     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1929     ok(!result && GetLastError() == NTE_NO_KEY,
1930      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1931
1932     /* Importing a key exchange blob.. */
1933     result = CryptImportKey(prov, abPlainPrivateKey, sizeof(abPlainPrivateKey),
1934      0, 0, &key);
1935     ok(result, "CryptImportKey failed: %08x\n", GetLastError());
1936     CryptDestroyKey(key);
1937     /* allows access to the key exchange key.. */
1938     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1939     ok(result, "CryptGetUserKey failed: %08x\n", GetLastError());
1940     CryptDestroyKey(key);
1941     /* but not to the private key. */
1942     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1943     ok(!result && GetLastError() == NTE_NO_KEY,
1944      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1945     CryptReleaseContext(prov, 0);
1946     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1947      CRYPT_DELETEKEYSET);
1948
1949     /* Whereas importing a sign blob.. */
1950     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1951      CRYPT_NEWKEYSET);
1952     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
1953     if (!result) return;
1954     result = CryptImportKey(prov, signBlob, sizeof(signBlob), 0, 0, &key);
1955     ok(result, "CryptGenKey failed: %08x\n", GetLastError());
1956     CryptDestroyKey(key);
1957     /* doesn't allow access to the key exchange key.. */
1958     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1959     ok(!result && GetLastError() == NTE_NO_KEY,
1960      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1961     /* but does to the private key. */
1962     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1963     ok(result, "CryptGetUserKey failed: %08x\n", GetLastError());
1964     CryptDestroyKey(key);
1965     CryptReleaseContext(prov, 0);
1966
1967     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1968      CRYPT_DELETEKEYSET);
1969
1970
1971     /* test for the bug in accessing the user key in a container
1972      */
1973     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1974      CRYPT_NEWKEYSET);
1975     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
1976     result = CryptGenKey(prov, AT_KEYEXCHANGE, 0, &key);
1977     ok(result, "CryptGenKey with AT_KEYEXCHANGE failed with error %08x\n", GetLastError());
1978     CryptDestroyKey(key);
1979     CryptReleaseContext(prov,0);
1980     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,0);
1981     ok(result, "CryptAcquireContext failed: 0x%08x\n", GetLastError());
1982     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1983     ok (result, "CryptGetUserKey failed with error %08x\n", GetLastError());
1984     CryptDestroyKey(key);
1985     CryptReleaseContext(prov, 0);
1986
1987     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1988      CRYPT_DELETEKEYSET);
1989
1990     /* test the machine key set */
1991     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1992      CRYPT_DELETEKEYSET|CRYPT_MACHINE_KEYSET);
1993     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1994      CRYPT_NEWKEYSET|CRYPT_MACHINE_KEYSET);
1995     ok(result, "CryptAcquireContext with CRYPT_MACHINE_KEYSET failed: %08x\n", GetLastError());
1996     CryptReleaseContext(prov, 0);
1997     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1998      CRYPT_MACHINE_KEYSET);
1999     ok(result, "CryptAcquireContext with CRYPT_MACHINE_KEYSET failed: %08x\n", GetLastError());
2000     CryptReleaseContext(prov,0);
2001     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2002        CRYPT_DELETEKEYSET|CRYPT_MACHINE_KEYSET);
2003     ok(result, "CryptAcquireContext with CRYPT_DELETEKEYSET|CRYPT_MACHINE_KEYSET failed: %08x\n",
2004                 GetLastError());
2005     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2006      CRYPT_MACHINE_KEYSET);
2007     ok(!result && GetLastError() == NTE_BAD_KEYSET ,
2008         "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
2009
2010 }
2011
2012 START_TEST(rsaenh)
2013 {
2014     if (!init_base_environment())
2015         return;
2016     test_prov();
2017     test_gen_random();
2018     test_hashes();
2019     test_rc4();
2020     test_rc2();
2021     test_des();
2022     test_3des112();
2023     test_3des();
2024     test_hmac();
2025     test_mac();
2026     test_block_cipher_modes();
2027     test_import_private();
2028     test_verify_signature();
2029     test_rsa_encrypt();
2030     test_import_export();
2031     test_enum_container();
2032     clean_up_base_environment();
2033     test_schannel_provider();
2034     test_null_provider();
2035     if (!init_aes_environment())
2036         return;
2037     test_aes(128);
2038     test_aes(192);
2039     test_aes(256);
2040     clean_up_aes_environment();
2041 }