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(DWORD dwKeyFlags)
 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, dwKeyFlags, &hKey);
 136         ok(result, "%08x\n", GetLastError());
 137         if (result) CryptDestroyKey(hKey);
 138         result = CryptGenKey(hProv, AT_SIGNATURE, dwKeyFlags, &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     SetLastError(0xdeadbeef);
 150     result = CryptReleaseContext(hProv, 1);
 151     ok(!result || broken(result) /* Win98 */, "Expected failure\n");
 152     ok(GetLastError()==NTE_BAD_FLAGS, "Expected NTE_BAD_FLAGS, got %08x\n", GetLastError());
 153
 154     /* Just to prove that Win98 also released the CSP */
 155     SetLastError(0xdeadbeef);
 156     result = CryptReleaseContext(hProv, 0);
 157     ok(!result && GetLastError()==ERROR_INVALID_PARAMETER, "%08x\n", GetLastError());
 158
 159     CryptAcquireContext(&hProv, szContainer, szProvider, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
 160 }
 161
 162 static int init_aes_environment(void)
 163 {
 164     HCRYPTKEY hKey;
 165     BOOL result;
 166
 167     pCryptDuplicateHash = (void *)GetProcAddress(GetModuleHandleA("advapi32.dll"), "CryptDuplicateHash");
 168
 169     hProv = (HCRYPTPROV)INVALID_HANDLE_VALUE;
 170
 171     /* we are using NULL as provider name for RSA_AES provider as the provider
 172      * names are different in Windows XP and Vista. Its different as to what
 173      * its defined in the SDK on Windows XP.
 174      * This provider is available on Windows XP, Windows 2003 and Vista.      */
 175
 176     result = CryptAcquireContext(&hProv, szContainer, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT);
 177     if (!result && GetLastError() == NTE_PROV_TYPE_NOT_DEF)
 178     {
 179         win_skip("RSA_AES provider not supported\n");
 180         return 0;
 181     }
 182     ok(!result && GetLastError()==NTE_BAD_FLAGS, "%d, %08x\n", result, GetLastError());
 183
 184     if (!CryptAcquireContext(&hProv, szContainer, NULL, PROV_RSA_AES, 0))
 185     {
 186         ok(GetLastError()==NTE_BAD_KEYSET, "%08x\n", GetLastError());
 187         if (GetLastError()!=NTE_BAD_KEYSET) return 0;
 188         result = CryptAcquireContext(&hProv, szContainer, NULL, PROV_RSA_AES,
 189                                      CRYPT_NEWKEYSET);
 190         ok(result, "%08x\n", GetLastError());
 191         if (!result) return 0;
 192         result = CryptGenKey(hProv, AT_KEYEXCHANGE, 0, &hKey);
 193         ok(result, "%08x\n", GetLastError());
 194         if (result) CryptDestroyKey(hKey);
 195         result = CryptGenKey(hProv, AT_SIGNATURE, 0, &hKey);
 196         ok(result, "%08x\n", GetLastError());
 197         if (result) CryptDestroyKey(hKey);
 198     }
 199     return 1;
 200 }
 201
 202 static void clean_up_aes_environment(void)
 203 {
 204     BOOL result;
 205
 206     result = CryptReleaseContext(hProv, 1);
 207     ok(!result && GetLastError()==NTE_BAD_FLAGS, "%08x\n", GetLastError());
 208
 209     CryptAcquireContext(&hProv, szContainer, NULL, PROV_RSA_AES, CRYPT_DELETEKEYSET);
 210 }
 211
 212 static void test_prov(void)
 213 {
 214     BOOL result;
 215     DWORD dwLen, dwInc;
 216
 217     dwLen = (DWORD)sizeof(DWORD);
 218     SetLastError(0xdeadbeef);
 219     result = CryptGetProvParam(hProv, PP_SIG_KEYSIZE_INC, (BYTE*)&dwInc, &dwLen, 0);
 220     if (!result && GetLastError() == NTE_BAD_TYPE)
 221         skip("PP_SIG_KEYSIZE_INC is not supported (win9x or NT)\n");
 222     else
 223         ok(result && dwInc==8, "%08x, %d\n", GetLastError(), dwInc);
 224
 225     dwLen = (DWORD)sizeof(DWORD);
 226     SetLastError(0xdeadbeef);
 227     result = CryptGetProvParam(hProv, PP_KEYX_KEYSIZE_INC, (BYTE*)&dwInc, &dwLen, 0);
 228     if (!result && GetLastError() == NTE_BAD_TYPE)
 229         skip("PP_KEYX_KEYSIZE_INC is not supported (win9x or NT)\n");
 230     else
 231         ok(result && dwInc==8, "%08x, %d\n", GetLastError(), dwInc);
 232 }
 233
 234 static void test_gen_random(void)
 235 {
 236     BOOL result;
 237     BYTE rnd1[16], rnd2[16];
 238
 239     memset(rnd1, 0, sizeof(rnd1));
 240     memset(rnd2, 0, sizeof(rnd2));
 241
 242     result = CryptGenRandom(hProv, sizeof(rnd1), rnd1);
 243     if (!result && GetLastError() == NTE_FAIL) {
 244         /* rsaenh compiled without OpenSSL */
 245         return;
 246     }
 247
 248     ok(result, "%08x\n", GetLastError());
 249
 250     result = CryptGenRandom(hProv, sizeof(rnd2), rnd2);
 251     ok(result, "%08x\n", GetLastError());
 252
 253     ok(memcmp(rnd1, rnd2, sizeof(rnd1)), "CryptGenRandom generates non random data\n");
 254 }
 255
 256 static BOOL derive_key(ALG_ID aiAlgid, HCRYPTKEY *phKey, DWORD len)
 257 {
 258     HCRYPTHASH hHash;
 259     BOOL result;
 260     unsigned char pbData[2000];
 261     int i;
 262
 263     *phKey = 0;
 264     for (i=0; i<2000; i++) pbData[i] = (unsigned char)i;
 265     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 266     if (!result) {
 267         /* rsaenh compiled without OpenSSL */
 268         ok(GetLastError()==NTE_BAD_ALGID, "%08x\n", GetLastError());
 269         return FALSE;
 270     }
 271     ok(result, "%08x\n", GetLastError());
 272     if (!result) return FALSE;
 273     result = CryptHashData(hHash, pbData, sizeof(pbData), 0);
 274     ok(result, "%08x\n", GetLastError());
 275     if (!result) return FALSE;
 276     result = CryptDeriveKey(hProv, aiAlgid, hHash, (len << 16) | CRYPT_EXPORTABLE, phKey);
 277     ok(result, "%08x\n", GetLastError());
 278     if (!result) return FALSE;
 279     len = 2000;
 280     result = CryptGetHashParam(hHash, HP_HASHVAL, pbData, &len, 0);
 281     ok(result, "%08x\n", GetLastError());
 282     CryptDestroyHash(hHash);
 283     return TRUE;
 284 }
 285
 286 static void test_hashes(void)
 287 {
 288     static const unsigned char md2hash[16] = {
 289         0x12, 0xcb, 0x1b, 0x08, 0xc8, 0x48, 0xa4, 0xa9,
 290         0xaa, 0xf3, 0xf1, 0x9f, 0xfc, 0x29, 0x28, 0x68 };
 291     static const unsigned char md4hash[16] = {
 292         0x8e, 0x2a, 0x58, 0xbf, 0xf2, 0xf5, 0x26, 0x23,
 293         0x79, 0xd2, 0x92, 0x36, 0x1b, 0x23, 0xe3, 0x81 };
 294     static const unsigned char empty_md5hash[16] = {
 295         0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04,
 296         0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e };
 297     static const unsigned char md5hash[16] = {
 298         0x15, 0x76, 0xa9, 0x4d, 0x6c, 0xb3, 0x34, 0xdd,
 299         0x12, 0x6c, 0xb1, 0xc2, 0x7f, 0x19, 0xe0, 0xf2 };
 300     static const unsigned char sha1hash[20] = {
 301         0xf1, 0x0c, 0xcf, 0xde, 0x60, 0xc1, 0x7d, 0xb2, 0x6e, 0x7d,
 302         0x85, 0xd3, 0x56, 0x65, 0xc7, 0x66, 0x1d, 0xbb, 0xeb, 0x2c };
 303     unsigned char pbData[2048];
 304     BOOL result;
 305     HCRYPTHASH hHash, hHashClone;
 306     BYTE pbHashValue[36];
 307     DWORD hashlen, len;
 308     int i;
 309
 310     for (i=0; i<2048; i++) pbData[i] = (unsigned char)i;
 311
 312     /* MD2 Hashing */
 313     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 314     if (!result) {
 315         /* rsaenh compiled without OpenSSL */
 316         ok(GetLastError() == NTE_BAD_ALGID, "%08x\n", GetLastError());
 317     } else {
 318         result = CryptHashData(hHash, pbData, sizeof(pbData), 0);
 319         ok(result, "%08x\n", GetLastError());
 320
 321         len = sizeof(DWORD);
 322         result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 323            ok(result && (hashlen == 16), "%08x, hashlen: %d\n", GetLastError(), hashlen);
 324
 325         len = 16;
 326         result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 327         ok(result, "%08x\n", GetLastError());
 328
 329         ok(!memcmp(pbHashValue, md2hash, 16), "Wrong MD2 hash!\n");
 330
 331         result = CryptDestroyHash(hHash);
 332         ok(result, "%08x\n", GetLastError());
 333     }
 334
 335     /* MD4 Hashing */
 336     result = CryptCreateHash(hProv, CALG_MD4, 0, 0, &hHash);
 337     ok(result, "%08x\n", GetLastError());
 338
 339     result = CryptHashData(hHash, pbData, sizeof(pbData), 0);
 340     ok(result, "%08x\n", GetLastError());
 341
 342     len = sizeof(DWORD);
 343     result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 344     ok(result && (hashlen == 16), "%08x, hashlen: %d\n", GetLastError(), hashlen);
 345
 346     len = 16;
 347     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 348     ok(result, "%08x\n", GetLastError());
 349
 350     ok(!memcmp(pbHashValue, md4hash, 16), "Wrong MD4 hash!\n");
 351
 352     result = CryptDestroyHash(hHash);
 353     ok(result, "%08x\n", GetLastError());
 354
 355     /* MD5 Hashing */
 356     result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
 357     ok(result, "%08x\n", GetLastError());
 358
 359     len = sizeof(DWORD);
 360     result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 361     ok(result && (hashlen == 16), "%08x, hashlen: %d\n", GetLastError(), hashlen);
 362
 363     result = CryptHashData(hHash, pbData, sizeof(pbData), 0);
 364     ok(result, "%08x\n", GetLastError());
 365
 366     len = 16;
 367     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 368     ok(result, "%08x\n", GetLastError());
 369
 370     ok(!memcmp(pbHashValue, md5hash, 16), "Wrong MD5 hash!\n");
 371
 372     result = CryptDestroyHash(hHash);
 373     ok(result, "%08x\n", GetLastError());
 374
 375     result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
 376     ok(result, "%08x\n", GetLastError());
 377
 378     /* The hash is available even if CryptHashData hasn't been called */
 379     len = 16;
 380     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 381     ok(result, "%08x\n", GetLastError());
 382
 383     ok(!memcmp(pbHashValue, empty_md5hash, 16), "Wrong MD5 hash!\n");
 384
 385     /* It's also stable:  getting it twice results in the same value */
 386     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 387     ok(result, "%08x\n", GetLastError());
 388
 389     ok(!memcmp(pbHashValue, empty_md5hash, 16), "Wrong MD5 hash!\n");
 390
 391     /* Can't add data after the hash been retrieved */
 392     SetLastError(0xdeadbeef);
 393     result = CryptHashData(hHash, pbData, sizeof(pbData), 0);
 394     ok(!result, "Expected failure\n");
 395     ok(GetLastError() == NTE_BAD_HASH_STATE ||
 396        GetLastError() == NTE_BAD_ALGID, /* Win9x, WinMe, NT4 */
 397        "Expected NTE_BAD_HASH_STATE or NTE_BAD_ALGID, got %08x\n", GetLastError());
 398
 399     /* You can still retrieve the hash, its value just hasn't changed */
 400     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 401     ok(result, "%08x\n", GetLastError());
 402
 403     ok(!memcmp(pbHashValue, empty_md5hash, 16), "Wrong MD5 hash!\n");
 404
 405     result = CryptDestroyHash(hHash);
 406     ok(result, "%08x\n", GetLastError());
 407
 408     /* SHA1 Hashing */
 409     result = CryptCreateHash(hProv, CALG_SHA, 0, 0, &hHash);
 410     ok(result, "%08x\n", GetLastError());
 411
 412     result = CryptHashData(hHash, pbData, 5, 0);
 413     ok(result, "%08x\n", GetLastError());
 414
 415     if(pCryptDuplicateHash) {
 416         result = pCryptDuplicateHash(hHash, 0, 0, &hHashClone);
 417         ok(result, "%08x\n", GetLastError());
 418
 419         result = CryptHashData(hHashClone, (BYTE*)pbData+5, sizeof(pbData)-5, 0);
 420         ok(result, "%08x\n", GetLastError());
 421
 422         len = sizeof(DWORD);
 423         result = CryptGetHashParam(hHashClone, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 424         ok(result && (hashlen == 20), "%08x, hashlen: %d\n", GetLastError(), hashlen);
 425
 426         len = 20;
 427         result = CryptGetHashParam(hHashClone, HP_HASHVAL, pbHashValue, &len, 0);
 428         ok(result, "%08x\n", GetLastError());
 429
 430         ok(!memcmp(pbHashValue, sha1hash, 20), "Wrong SHA1 hash!\n");
 431
 432         result = CryptDestroyHash(hHashClone);
 433         ok(result, "%08x\n", GetLastError());
 434     }
 435
 436     result = CryptDestroyHash(hHash);
 437     ok(result, "%08x\n", GetLastError());
 438 }
 439
 440 static void test_block_cipher_modes(void)
 441 {
 442     static const BYTE plain[23] = {
 443         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
 444         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
 445     static const BYTE ecb[24] = {
 446         0xc0, 0x9a, 0xe4, 0x2f, 0x0a, 0x47, 0x67, 0x11, 0xf2, 0xb2, 0x5d, 0x5f,
 447         0x08, 0xff, 0x49, 0xa4, 0x45, 0x3a, 0x68, 0x14, 0xca, 0x18, 0xe5, 0xf4 };
 448     static const BYTE cbc[24] = {
 449         0xc0, 0x9a, 0xe4, 0x2f, 0x0a, 0x47, 0x67, 0x11, 0x10, 0xf5, 0xda, 0x61,
 450         0x4e, 0x3d, 0xab, 0xc0, 0x97, 0x85, 0x01, 0x12, 0x97, 0xa4, 0xf7, 0xd3 };
 451     static const BYTE cfb[24] = {
 452         0x29, 0xb5, 0x67, 0x85, 0x0b, 0x1b, 0xec, 0x07, 0x67, 0x2d, 0xa1, 0xa4,
 453         0x1a, 0x47, 0x24, 0x6a, 0x54, 0xe1, 0xe0, 0x92, 0xf9, 0x0e, 0xf6, 0xeb };
 454     HCRYPTKEY hKey;
 455     BOOL result;
 456     BYTE abData[24];
 457     DWORD dwMode, dwLen;
 458
 459     result = derive_key(CALG_RC2, &hKey, 40);
 460     if (!result) return;
 461
 462     memcpy(abData, plain, sizeof(plain));
 463
 464     dwMode = CRYPT_MODE_ECB;
 465     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 466     ok(result, "%08x\n", GetLastError());
 467
 468     dwLen = 23;
 469     result = CryptEncrypt(hKey, 0, TRUE, 0, NULL, &dwLen, 24);
 470     ok(result, "CryptEncrypt failed: %08x\n", GetLastError());
 471     ok(dwLen == 24, "Unexpected length %d\n", dwLen);
 472
 473     SetLastError(ERROR_SUCCESS);
 474     dwLen = 23;
 475     result = CryptEncrypt(hKey, 0, TRUE, 0, abData, &dwLen, 24);
 476     ok(result && dwLen == 24 && !memcmp(ecb, abData, sizeof(ecb)),
 477        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 478
 479     result = CryptDecrypt(hKey, 0, TRUE, 0, abData, &dwLen);
 480     ok(result && dwLen == 23 && !memcmp(plain, abData, sizeof(plain)),
 481        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 482
 483     dwMode = CRYPT_MODE_CBC;
 484     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 485     ok(result, "%08x\n", GetLastError());
 486
 487     dwLen = 23;
 488     result = CryptEncrypt(hKey, 0, TRUE, 0, NULL, &dwLen, 24);
 489     ok(result, "CryptEncrypt failed: %08x\n", GetLastError());
 490     ok(dwLen == 24, "Unexpected length %d\n", dwLen);
 491
 492     dwLen = 23;
 493     result = CryptEncrypt(hKey, 0, TRUE, 0, abData, &dwLen, 24);
 494     ok(result && dwLen == 24 && !memcmp(cbc, abData, sizeof(cbc)),
 495        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 496
 497     result = CryptDecrypt(hKey, 0, TRUE, 0, abData, &dwLen);
 498     ok(result && dwLen == 23 && !memcmp(plain, abData, sizeof(plain)),
 499        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 500
 501     dwMode = CRYPT_MODE_CFB;
 502     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 503     ok(result, "%08x\n", GetLastError());
 504
 505     dwLen = 16;
 506     result = CryptEncrypt(hKey, 0, FALSE, 0, abData, &dwLen, 24);
 507     ok(result && dwLen == 16, "%08x, dwLen: %d\n", GetLastError(), dwLen);
 508
 509     dwLen = 7;
 510     result = CryptEncrypt(hKey, 0, TRUE, 0, abData+16, &dwLen, 8);
 511     ok(result && dwLen == 8 && !memcmp(cfb, abData, sizeof(cfb)),
 512        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 513
 514     dwLen = 8;
 515     result = CryptDecrypt(hKey, 0, FALSE, 0, abData, &dwLen);
 516     ok(result && dwLen == 8, "%08x, dwLen: %d\n", GetLastError(), dwLen);
 517
 518     dwLen = 16;
 519     result = CryptDecrypt(hKey, 0, TRUE, 0, abData+8, &dwLen);
 520     ok(result && dwLen == 15 && !memcmp(plain, abData, sizeof(plain)),
 521        "%08x, dwLen: %d\n", GetLastError(), dwLen);
 522
 523     dwMode = CRYPT_MODE_OFB;
 524     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 525     ok(result, "%08x\n", GetLastError());
 526
 527     dwLen = 23;
 528     result = CryptEncrypt(hKey, 0, TRUE, 0, abData, &dwLen, 24);
 529     ok(!result && GetLastError() == NTE_BAD_ALGID, "%08x\n", GetLastError());
 530
 531     CryptDestroyKey(hKey);
 532 }
 533
 534 static void test_3des112(void)
 535 {
 536     HCRYPTKEY hKey;
 537     BOOL result;
 538     DWORD dwLen;
 539     unsigned char pbData[16];
 540     int i;
 541
 542     result = derive_key(CALG_3DES_112, &hKey, 0);
 543     if (!result) {
 544         /* rsaenh compiled without OpenSSL */
 545         ok(GetLastError() == NTE_BAD_ALGID, "%08x\n", GetLastError());
 546         return;
 547     }
 548
 549     for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
 550
 551     dwLen = 13;
 552     result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, 16);
 553     ok(result, "%08x\n", GetLastError());
 554
 555     result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 556     ok(result, "%08x\n", GetLastError());
 557
 558     for (i=0; i<4; i++)
 559     {
 560       memcpy(pbData,cTestData[i].origstr,cTestData[i].strlen);
 561
 562       dwLen = cTestData[i].enclen;
 563       result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, cTestData[i].buflen);
 564       ok(result, "%08x\n", GetLastError());
 565       ok(dwLen==cTestData[i].buflen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].buflen);
 566
 567       result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 568       ok(result, "%08x\n", GetLastError());
 569       ok(dwLen==cTestData[i].enclen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].enclen);
 570       ok(memcmp(pbData,cTestData[i].decstr,cTestData[1].enclen)==0,"decryption incorrect %d\n",i);
 571       if((dwLen != cTestData[i].enclen) ||
 572          memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen))
 573       {
 574           printBytes("expected",cTestData[i].decstr,cTestData[i].strlen);
 575           printBytes("got",pbData,dwLen);
 576       }
 577     }
 578     result = CryptDestroyKey(hKey);
 579     ok(result, "%08x\n", GetLastError());
 580 }
 581
 582 static void test_des(void)
 583 {
 584     HCRYPTKEY hKey;
 585     BOOL result;
 586     DWORD dwLen, dwMode;
 587     unsigned char pbData[16];
 588     int i;
 589
 590     result = derive_key(CALG_DES, &hKey, 56);
 591     if (!result) {
 592         /* rsaenh compiled without OpenSSL */
 593         ok(GetLastError()==NTE_BAD_ALGID, "%08x\n", GetLastError());
 594         return;
 595     }
 596
 597     dwMode = CRYPT_MODE_ECB;
 598     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 599     ok(result, "%08x\n", GetLastError());
 600
 601     dwLen = sizeof(DWORD);
 602     result = CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0);
 603     ok(result, "%08x\n", GetLastError());
 604
 605     for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
 606
 607     dwLen = 13;
 608     result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, 16);
 609     ok(result, "%08x\n", GetLastError());
 610
 611     result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 612     ok(result, "%08x\n", GetLastError());
 613
 614     for (i=0; i<4; i++)
 615     {
 616       memcpy(pbData,cTestData[i].origstr,cTestData[i].strlen);
 617
 618       dwLen = cTestData[i].enclen;
 619       result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, cTestData[i].buflen);
 620       ok(result, "%08x\n", GetLastError());
 621       ok(dwLen==cTestData[i].buflen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].buflen);
 622
 623       result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 624       ok(result, "%08x\n", GetLastError());
 625       ok(dwLen==cTestData[i].enclen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].enclen);
 626       ok(memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen)==0,"decryption incorrect %d\n",i);
 627       if((dwLen != cTestData[i].enclen) ||
 628          memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen))
 629       {
 630           printBytes("expected",cTestData[i].decstr,cTestData[i].strlen);
 631           printBytes("got",pbData,dwLen);
 632       }
 633     }
 634
 635     result = CryptDestroyKey(hKey);
 636     ok(result, "%08x\n", GetLastError());
 637 }
 638
 639 static void test_3des(void)
 640 {
 641     HCRYPTKEY hKey;
 642     BOOL result;
 643     DWORD dwLen;
 644     unsigned char pbData[16];
 645     static const BYTE des3[16] = {
 646         0x7b, 0xba, 0xdd, 0xa2, 0x39, 0xd3, 0x7b, 0xb3,
 647         0xc7, 0x51, 0x81, 0x41, 0x53, 0xe8, 0xcf, 0xeb };
 648     int i;
 649
 650     result = derive_key(CALG_3DES, &hKey, 0);
 651     if (!result) return;
 652
 653     for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
 654
 655     dwLen = 13;
 656     result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, 16);
 657     ok(result, "%08x\n", GetLastError());
 658
 659     ok(!memcmp(pbData, des3, sizeof(des3)), "3DES encryption failed!\n");
 660
 661     result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 662     ok(result, "%08x\n", GetLastError());
 663
 664     for (i=0; i<4; i++)
 665     {
 666       memcpy(pbData,cTestData[i].origstr,cTestData[i].strlen);
 667
 668       dwLen = cTestData[i].enclen;
 669       result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, cTestData[i].buflen);
 670       ok(result, "%08x\n", GetLastError());
 671       ok(dwLen==cTestData[i].buflen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].buflen);
 672
 673       result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 674       ok(result, "%08x\n", GetLastError());
 675       ok(dwLen==cTestData[i].enclen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].enclen);
 676       ok(memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen)==0,"decryption incorrect %d\n",i);
 677       if((dwLen != cTestData[i].enclen) ||
 678          memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen))
 679       {
 680           printBytes("expected",cTestData[i].decstr,cTestData[i].strlen);
 681           printBytes("got",pbData,dwLen);
 682       }
 683     }
 684     result = CryptDestroyKey(hKey);
 685     ok(result, "%08x\n", GetLastError());
 686 }
 687
 688 static void test_aes(int keylen)
 689 {
 690     HCRYPTKEY hKey;
 691     BOOL result;
 692     DWORD dwLen;
 693     unsigned char pbData[16];
 694     int i;
 695
 696     switch (keylen)
 697     {
 698         case 256:
 699             result = derive_key(CALG_AES_256, &hKey, 0);
 700             break;
 701         case 192:
 702             result = derive_key(CALG_AES_192, &hKey, 0);
 703             break;
 704         default:
 705         case 128:
 706             result = derive_key(CALG_AES_128, &hKey, 0);
 707             break;
 708     }
 709     if (!result) return;
 710
 711     for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
 712
 713     dwLen = 13;
 714     result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, 16);
 715     ok(result, "%08x\n", GetLastError());
 716
 717     result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 718     ok(result, "%08x\n", GetLastError());
 719
 720     for (i=0; i<4; i++)
 721     {
 722       memcpy(pbData,cTestData[i].origstr,cTestData[i].strlen);
 723
 724       dwLen = cTestData[i].enclen;
 725       result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, cTestData[i].buflen);
 726       ok(result, "%08x\n", GetLastError());
 727       ok(dwLen==cTestData[i].buflen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].buflen);
 728
 729       result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwLen);
 730       ok(result, "%08x\n", GetLastError());
 731       ok(dwLen==cTestData[i].enclen,"length incorrect, got %d, expected %d\n",dwLen,cTestData[i].enclen);
 732       ok(memcmp(pbData,cTestData[i].decstr,cTestData[1].enclen)==0,"decryption incorrect %d\n",i);
 733       if((dwLen != cTestData[i].enclen) ||
 734          memcmp(pbData,cTestData[i].decstr,cTestData[i].enclen))
 735       {
 736           printBytes("expected",cTestData[i].decstr,cTestData[i].strlen);
 737           printBytes("got",pbData,dwLen);
 738       }
 739     }
 740     result = CryptDestroyKey(hKey);
 741     ok(result, "%08x\n", GetLastError());
 742 }
 743
 744 static void test_rc2(void)
 745 {
 746     static const BYTE rc2_40_encrypted[16] = {
 747         0xc0, 0x9a, 0xe4, 0x2f, 0x0a, 0x47, 0x67, 0x11,
 748         0xfb, 0x18, 0x87, 0xce, 0x0c, 0x75, 0x07, 0xb1 };
 749     static const BYTE rc2_128_encrypted[] = {
 750         0x82,0x81,0xf7,0xff,0xdd,0xd7,0x88,0x8c,0x2a,0x2a,0xc0,0xce,0x4c,0x89,
 751         0xb6,0x66 };
 752     HCRYPTHASH hHash;
 753     HCRYPTKEY hKey;
 754     BOOL result;
 755     DWORD dwLen, dwKeyLen, dwDataLen, dwMode, dwModeBits;
 756     BYTE *pbTemp;
 757     unsigned char pbData[2000], pbHashValue[16];
 758     int i;
 759
 760     for (i=0; i<2000; i++) pbData[i] = (unsigned char)i;
 761
 762     /* MD2 Hashing */
 763     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 764     if (!result) {
 765         ok(GetLastError()==NTE_BAD_ALGID, "%08x\n", GetLastError());
 766     } else {
 767         CRYPT_INTEGER_BLOB salt;
 768
 769         result = CryptHashData(hHash, pbData, sizeof(pbData), 0);
 770         ok(result, "%08x\n", GetLastError());
 771
 772         dwLen = 16;
 773         result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &dwLen, 0);
 774         ok(result, "%08x\n", GetLastError());
 775
 776         result = CryptDeriveKey(hProv, CALG_RC2, hHash, 40 << 16, &hKey);
 777         ok(result, "%08x\n", GetLastError());
 778
 779         dwLen = sizeof(DWORD);
 780         result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
 781         ok(result, "%08x\n", GetLastError());
 782
 783         dwMode = CRYPT_MODE_CBC;
 784         result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 785         ok(result, "%08x\n", GetLastError());
 786
 787         dwLen = sizeof(DWORD);
 788         result = CryptGetKeyParam(hKey, KP_MODE_BITS, (BYTE*)&dwModeBits, &dwLen, 0);
 789         ok(result, "%08x\n", GetLastError());
 790
 791         dwModeBits = 0xdeadbeef;
 792         dwLen = sizeof(DWORD);
 793         result = CryptGetKeyParam(hKey, KP_PERMISSIONS, (BYTE*)&dwModeBits, &dwLen, 0);
 794         ok(result, "%08x\n", GetLastError());
 795         ok(dwModeBits ==
 796             (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT) ||
 797             broken(dwModeBits == 0xffffffff), /* Win9x/NT4 */
 798             "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT,"
 799             " got %08x\n", dwModeBits);
 800
 801         dwLen = sizeof(DWORD);
 802         result = CryptGetKeyParam(hKey, KP_PERMISSIONS, (BYTE*)&dwModeBits, &dwLen, 0);
 803         ok(result, "%08x\n", GetLastError());
 804
 805         dwLen = sizeof(DWORD);
 806         result = CryptGetKeyParam(hKey, KP_BLOCKLEN, (BYTE*)&dwModeBits, &dwLen, 0);
 807         ok(result, "%08x\n", GetLastError());
 808
 809         result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0);
 810         ok(result, "%08x\n", GetLastError());
 811         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 812         CryptGetKeyParam(hKey, KP_IV, pbTemp, &dwLen, 0);
 813         HeapFree(GetProcessHeap(), 0, pbTemp);
 814
 815         result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0);
 816         ok(result, "%08x\n", GetLastError());
 817         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 818         CryptGetKeyParam(hKey, KP_SALT, pbTemp, &dwLen, 0);
 819         HeapFree(GetProcessHeap(), 0, pbTemp);
 820
 821         dwLen = sizeof(DWORD);
 822         CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0);
 823
 824         result = CryptDestroyHash(hHash);
 825         ok(result, "%08x\n", GetLastError());
 826
 827         dwDataLen = 13;
 828         result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, 24);
 829         ok(result, "%08x\n", GetLastError());
 830
 831         ok(!memcmp(pbData, rc2_40_encrypted, 16), "RC2 encryption failed!\n");
 832
 833         result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0);
 834         ok(result, "%08x\n", GetLastError());
 835         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 836         CryptGetKeyParam(hKey, KP_IV, pbTemp, &dwLen, 0);
 837         HeapFree(GetProcessHeap(), 0, pbTemp);
 838
 839         result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen);
 840         ok(result, "%08x\n", GetLastError());
 841
 842         /* What sizes salt can I set? */
 843         salt.pbData = pbData;
 844         for (i=0; i<24; i++)
 845         {
 846             salt.cbData = i;
 847             result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0);
 848             ok(result, "setting salt failed for size %d: %08x\n", i, GetLastError());
 849         }
 850         salt.cbData = 25;
 851         SetLastError(0xdeadbeef);
 852         result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0);
 853         ok(!result ||
 854            broken(result), /* Win9x, WinMe, NT4, W2K */
 855            "%08x\n", GetLastError());
 856
 857         result = CryptDestroyKey(hKey);
 858         ok(result, "%08x\n", GetLastError());
 859     }
 860
 861     /* Again, but test setting the effective key len */
 862     for (i=0; i<2000; i++) pbData[i] = (unsigned char)i;
 863
 864     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 865     if (!result) {
 866         ok(GetLastError()==NTE_BAD_ALGID, "%08x\n", GetLastError());
 867     } else {
 868         result = CryptHashData(hHash, pbData, sizeof(pbData), 0);
 869         ok(result, "%08x\n", GetLastError());
 870
 871         dwLen = 16;
 872         result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &dwLen, 0);
 873         ok(result, "%08x\n", GetLastError());
 874
 875         result = CryptDeriveKey(hProv, CALG_RC2, hHash, 56 << 16, &hKey);
 876         ok(result, "%08x\n", GetLastError());
 877
 878         SetLastError(0xdeadbeef);
 879         result = CryptSetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, NULL, 0);
 880         ok(!result && GetLastError()==ERROR_INVALID_PARAMETER, "%08x\n", GetLastError());
 881         dwKeyLen = 0;
 882         SetLastError(0xdeadbeef);
 883         result = CryptSetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (LPBYTE)&dwKeyLen, 0);
 884         ok(!result && GetLastError()==NTE_BAD_DATA, "%08x\n", GetLastError());
 885         dwKeyLen = 1025;
 886         SetLastError(0xdeadbeef);
 887         result = CryptSetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (LPBYTE)&dwKeyLen, 0);
 888
 889         dwLen = sizeof(dwKeyLen);
 890         CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE *)&dwKeyLen, &dwLen, 0);
 891         ok(dwKeyLen == 56, "%d (%08x)\n", dwKeyLen, GetLastError());
 892         CryptGetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (BYTE *)&dwKeyLen, &dwLen, 0);
 893         ok(dwKeyLen == 56 || broken(dwKeyLen == 40), "%d (%08x)\n", dwKeyLen, GetLastError());
 894
 895         dwKeyLen = 128;
 896         result = CryptSetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (LPBYTE)&dwKeyLen, 0);
 897         ok(result, "%d\n", GetLastError());
 898
 899         dwLen = sizeof(dwKeyLen);
 900         CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE *)&dwKeyLen, &dwLen, 0);
 901         ok(dwKeyLen == 56, "%d (%08x)\n", dwKeyLen, GetLastError());
 902         CryptGetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (BYTE *)&dwKeyLen, &dwLen, 0);
 903         ok(dwKeyLen == 128, "%d (%08x)\n", dwKeyLen, GetLastError());
 904
 905         result = CryptDestroyHash(hHash);
 906         ok(result, "%08x\n", GetLastError());
 907
 908         dwDataLen = 13;
 909         result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, 24);
 910         ok(result, "%08x\n", GetLastError());
 911
 912         ok(!memcmp(pbData, rc2_128_encrypted, sizeof(rc2_128_encrypted)),
 913                 "RC2 encryption failed!\n");
 914
 915         /* Oddly enough this succeeds, though it should have no effect */
 916         dwKeyLen = 40;
 917         result = CryptSetKeyParam(hKey, KP_EFFECTIVE_KEYLEN, (LPBYTE)&dwKeyLen, 0);
 918         ok(result, "%d\n", GetLastError());
 919
 920         result = CryptDestroyKey(hKey);
 921         ok(result, "%08x\n", GetLastError());
 922     }
 923 }
 924
 925 static void test_rc4(void)
 926 {
 927     static const BYTE rc4[16] = {
 928         0x17, 0x0c, 0x44, 0x8e, 0xae, 0x90, 0xcd, 0xb0,
 929         0x7f, 0x87, 0xf5, 0x7a, 0xec, 0xb2, 0x2e, 0x35 };
 930     BOOL result;
 931     HCRYPTHASH hHash;
 932     HCRYPTKEY hKey;
 933     DWORD dwDataLen = 5, dwKeyLen, dwLen = sizeof(DWORD), dwMode;
 934     unsigned char pbData[2000], *pbTemp;
 935     unsigned char pszBuffer[256];
 936     int i;
 937
 938     for (i=0; i<2000; i++) pbData[i] = (unsigned char)i;
 939
 940     /* MD2 Hashing */
 941     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 942     if (!result) {
 943         /* rsaenh compiled without OpenSSL */
 944         ok(GetLastError() == NTE_BAD_ALGID, "%08x\n", GetLastError());
 945     } else {
 946         CRYPT_INTEGER_BLOB salt;
 947
 948         result = CryptHashData(hHash, pbData, sizeof(pbData), 0);
 949            ok(result, "%08x\n", GetLastError());
 950
 951         dwLen = 16;
 952         result = CryptGetHashParam(hHash, HP_HASHVAL, pszBuffer, &dwLen, 0);
 953         ok(result, "%08x\n", GetLastError());
 954
 955         result = CryptDeriveKey(hProv, CALG_RC4, hHash, 56 << 16, &hKey);
 956         ok(result, "%08x\n", GetLastError());
 957
 958         dwLen = sizeof(DWORD);
 959         result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
 960         ok(result, "%08x\n", GetLastError());
 961
 962         dwLen = sizeof(DWORD);
 963         result = CryptGetKeyParam(hKey, KP_BLOCKLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
 964         ok(result, "%08x\n", GetLastError());
 965
 966         result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0);
 967         ok(result, "%08x\n", GetLastError());
 968         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 969         CryptGetKeyParam(hKey, KP_IV, pbTemp, &dwLen, 0);
 970         HeapFree(GetProcessHeap(), 0, pbTemp);
 971
 972         result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0);
 973         ok(result, "%08x\n", GetLastError());
 974         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 975         CryptGetKeyParam(hKey, KP_SALT, pbTemp, &dwLen, 0);
 976         HeapFree(GetProcessHeap(), 0, pbTemp);
 977
 978         dwLen = sizeof(DWORD);
 979         CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0);
 980
 981         result = CryptDestroyHash(hHash);
 982         ok(result, "%08x\n", GetLastError());
 983
 984         dwDataLen = 16;
 985         result = CryptEncrypt(hKey, 0, TRUE, 0, NULL, &dwDataLen, 24);
 986         ok(result, "%08x\n", GetLastError());
 987         dwDataLen = 16;
 988         result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, 24);
 989         ok(result, "%08x\n", GetLastError());
 990
 991         ok(!memcmp(pbData, rc4, dwDataLen), "RC4 encryption failed!\n");
 992
 993         result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen);
 994         ok(result, "%08x\n", GetLastError());
 995
 996         /* What sizes salt can I set? */
 997         salt.pbData = pbData;
 998         for (i=0; i<24; i++)
 999         {
1000             salt.cbData = i;
1001             result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0);
1002             ok(result, "setting salt failed for size %d: %08x\n", i, GetLastError());
1003         }
1004         salt.cbData = 25;
1005         SetLastError(0xdeadbeef);
1006         result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0);
1007         ok(!result ||
1008            broken(result), /* Win9x, WinMe, NT4, W2K */
1009            "%08x\n", GetLastError());
1010
1011         result = CryptDestroyKey(hKey);
1012         ok(result, "%08x\n", GetLastError());
1013     }
1014 }
1015
1016 static void test_hmac(void) {
1017     HCRYPTKEY hKey;
1018     HCRYPTHASH hHash;
1019     BOOL result;
1020     /* Using CALG_MD2 here fails on Windows 2003, why ? */
1021     HMAC_INFO hmacInfo = { CALG_MD5, NULL, 0, NULL, 0 };
1022     DWORD dwLen;
1023     BYTE abData[256];
1024     static const BYTE hmac[16] = {
1025         0x1a, 0x7d, 0x49, 0xc5, 0x9b, 0x2d, 0x0b, 0x9c,
1026         0xcf, 0x10, 0x6b, 0xb6, 0x7d, 0x0f, 0x13, 0x32 };
1027     int i;
1028
1029     for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abData[i] = (BYTE)i;
1030
1031     if (!derive_key(CALG_RC2, &hKey, 56)) return;
1032
1033     result = CryptCreateHash(hProv, CALG_HMAC, hKey, 0, &hHash);
1034     ok(result, "%08x\n", GetLastError());
1035     if (!result) return;
1036
1037     result = CryptSetHashParam(hHash, HP_HMAC_INFO, (BYTE*)&hmacInfo, 0);
1038     ok(result, "%08x\n", GetLastError());
1039
1040     result = CryptHashData(hHash, abData, sizeof(abData), 0);
1041     ok(result, "%08x\n", GetLastError());
1042
1043     dwLen = sizeof(abData)/sizeof(BYTE);
1044     result = CryptGetHashParam(hHash, HP_HASHVAL, abData, &dwLen, 0);
1045     ok(result, "%08x\n", GetLastError());
1046
1047     ok(!memcmp(abData, hmac, sizeof(hmac)), "HMAC failed!\n");
1048
1049     result = CryptDestroyHash(hHash);
1050     ok(result, "%08x\n", GetLastError());
1051
1052     result = CryptDestroyKey(hKey);
1053     ok(result, "%08x\n", GetLastError());
1054
1055     /* Provoke errors */
1056     result = CryptCreateHash(hProv, CALG_HMAC, 0, 0, &hHash);
1057     ok(!result && GetLastError() == NTE_BAD_KEY, "%08x\n", GetLastError());
1058 }
1059
1060 static void test_mac(void) {
1061     HCRYPTKEY hKey;
1062     HCRYPTHASH hHash;
1063     BOOL result;
1064     DWORD dwLen;
1065     BYTE abData[256], abEnc[264];
1066     static const BYTE mac_40[8] = { 0xb7, 0xa2, 0x46, 0xe9, 0x11, 0x31, 0xe0, 0xad};
1067     int i;
1068
1069     for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abData[i] = (BYTE)i;
1070     for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abEnc[i] = (BYTE)i;
1071
1072     if (!derive_key(CALG_RC2, &hKey, 40)) return;
1073
1074     dwLen = 256;
1075     result = CryptEncrypt(hKey, 0, TRUE, 0, abEnc, &dwLen, 264);
1076     ok (result && dwLen == 264, "%08x, dwLen: %d\n", GetLastError(), dwLen);
1077
1078     result = CryptCreateHash(hProv, CALG_MAC, hKey, 0, &hHash);
1079     ok(result, "%08x\n", GetLastError());
1080     if (!result) return;
1081
1082     result = CryptHashData(hHash, abData, sizeof(abData), 0);
1083     ok(result, "%08x\n", GetLastError());
1084
1085     dwLen = sizeof(abData)/sizeof(BYTE);
1086     result = CryptGetHashParam(hHash, HP_HASHVAL, abData, &dwLen, 0);
1087     ok(result && dwLen == 8, "%08x, dwLen: %d\n", GetLastError(), dwLen);
1088
1089     ok(!memcmp(abData, mac_40, sizeof(mac_40)), "MAC failed!\n");
1090
1091     result = CryptDestroyHash(hHash);
1092     ok(result, "%08x\n", GetLastError());
1093
1094     result = CryptDestroyKey(hKey);
1095     ok(result, "%08x\n", GetLastError());
1096
1097     /* Provoke errors */
1098     if (!derive_key(CALG_RC4, &hKey, 56)) return;
1099
1100     SetLastError(0xdeadbeef);
1101     result = CryptCreateHash(hProv, CALG_MAC, hKey, 0, &hHash);
1102     ok((!result && GetLastError() == NTE_BAD_KEY) ||
1103             broken(result), /* Win9x, WinMe, NT4, W2K */
1104             "%08x\n", GetLastError());
1105
1106     result = CryptDestroyKey(hKey);
1107     ok(result, "%08x\n", GetLastError());
1108 }
1109
1110 static BYTE abPlainPrivateKey[596] = {
1111     0x07, 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00,
1112     0x52, 0x53, 0x41, 0x32, 0x00, 0x04, 0x00, 0x00,
1113     0x01, 0x00, 0x01, 0x00, 0x9b, 0x64, 0xef, 0xce,
1114     0x31, 0x7c, 0xad, 0x56, 0xe2, 0x1e, 0x9b, 0x96,
1115     0xb3, 0xf0, 0x29, 0x88, 0x6e, 0xa8, 0xc2, 0x11,
1116     0x33, 0xd6, 0xcc, 0x8c, 0x69, 0xb2, 0x1a, 0xfd,
1117     0xfc, 0x23, 0x21, 0x30, 0x4d, 0x29, 0x45, 0xb6,
1118     0x3a, 0x67, 0x11, 0x80, 0x1a, 0x91, 0xf2, 0x9f,
1119     0x01, 0xac, 0xc0, 0x11, 0x50, 0x5f, 0xcd, 0xb9,
1120     0xad, 0x76, 0x9f, 0x6e, 0x91, 0x55, 0x71, 0xda,
1121     0x97, 0x96, 0x96, 0x22, 0x75, 0xb4, 0x83, 0x44,
1122     0x89, 0x9e, 0xf8, 0x44, 0x40, 0x7c, 0xd6, 0xcd,
1123     0x9d, 0x88, 0xd6, 0x88, 0xbc, 0x56, 0xb7, 0x64,
1124     0xe9, 0x2c, 0x24, 0x2f, 0x0d, 0x78, 0x55, 0x1c,
1125     0xb2, 0x67, 0xb1, 0x5e, 0xbc, 0x0c, 0xcf, 0x1c,
1126     0xe9, 0xd3, 0x9e, 0xa2, 0x15, 0x24, 0x73, 0xd6,
1127     0xdb, 0x6f, 0x83, 0xb2, 0xf8, 0xbc, 0xe7, 0x47,
1128     0x3b, 0x01, 0xef, 0x49, 0x08, 0x98, 0xd6, 0xa3,
1129     0xf9, 0x25, 0x57, 0xe9, 0x39, 0x3c, 0x53, 0x30,
1130     0x1b, 0xf2, 0xc9, 0x62, 0x31, 0x43, 0x5d, 0x84,
1131     0x24, 0x30, 0x21, 0x9a, 0xad, 0xdb, 0x62, 0x91,
1132     0xc8, 0x07, 0xd9, 0x2f, 0xd6, 0xb5, 0x37, 0x6f,
1133     0xfe, 0x7a, 0x12, 0xbc, 0xd9, 0xd2, 0x2b, 0xbf,
1134     0xd7, 0xb1, 0xfa, 0x7d, 0xc0, 0x48, 0xdd, 0x74,
1135     0xdd, 0x55, 0x04, 0xa1, 0x8b, 0xc1, 0x0a, 0xc4,
1136     0xa5, 0x57, 0x62, 0xee, 0x08, 0x8b, 0xf9, 0x19,
1137     0x6c, 0x52, 0x06, 0xf8, 0x73, 0x0f, 0x24, 0xc9,
1138     0x71, 0x9f, 0xc5, 0x45, 0x17, 0x3e, 0xae, 0x06,
1139     0x81, 0xa2, 0x96, 0x40, 0x06, 0xbf, 0xeb, 0x9e,
1140     0x80, 0x2b, 0x27, 0x20, 0x8f, 0x38, 0xcf, 0xeb,
1141     0xff, 0x3b, 0x38, 0x41, 0x35, 0x69, 0x66, 0x13,
1142     0x1d, 0x3c, 0x01, 0x3b, 0xf6, 0x37, 0xca, 0x9c,
1143     0x61, 0x74, 0x98, 0xcf, 0xc9, 0x6e, 0xe8, 0x90,
1144     0xc7, 0xb7, 0x33, 0xc0, 0x07, 0x3c, 0xf8, 0xc8,
1145     0xf6, 0xf2, 0xd7, 0xf0, 0x21, 0x62, 0x58, 0x8a,
1146     0x55, 0xbf, 0xa1, 0x2d, 0x3d, 0xa6, 0x69, 0xc5,
1147     0x02, 0x19, 0x31, 0xf0, 0x94, 0x0f, 0x45, 0x5c,
1148     0x95, 0x1b, 0x53, 0xbc, 0xf5, 0xb0, 0x1a, 0x8f,
1149     0xbf, 0x40, 0xe0, 0xc7, 0x73, 0xe7, 0x72, 0x6e,
1150     0xeb, 0xb1, 0x0f, 0x38, 0xc5, 0xf8, 0xee, 0x04,
1151     0xed, 0x34, 0x1a, 0x10, 0xf9, 0x53, 0x34, 0xf3,
1152     0x3e, 0xe6, 0x5c, 0xd1, 0x47, 0x65, 0xcd, 0xbd,
1153     0xf1, 0x06, 0xcb, 0xb4, 0xb1, 0x26, 0x39, 0x9f,
1154     0x71, 0xfe, 0x3d, 0xf8, 0x62, 0xab, 0x22, 0x8b,
1155     0x0e, 0xdc, 0xb9, 0xe8, 0x74, 0x06, 0xfc, 0x8c,
1156     0x25, 0xa1, 0xa9, 0xcf, 0x07, 0xf9, 0xac, 0x21,
1157     0x01, 0x7b, 0x1c, 0xdc, 0x94, 0xbd, 0x47, 0xe1,
1158     0xa0, 0x86, 0x59, 0x35, 0x6a, 0x6f, 0xb9, 0x70,
1159     0x26, 0x7c, 0x3c, 0xfd, 0xbd, 0x81, 0x39, 0x36,
1160     0x42, 0xc2, 0xbd, 0xbe, 0x84, 0x27, 0x9a, 0x69,
1161     0x81, 0xda, 0x99, 0x27, 0xc2, 0x4f, 0x62, 0x33,
1162     0xf4, 0x79, 0x30, 0xc5, 0x63, 0x54, 0x71, 0xf1,
1163     0x47, 0x22, 0x25, 0x9b, 0x6c, 0x00, 0x2f, 0x1c,
1164     0xf4, 0x1f, 0x85, 0xbc, 0xf6, 0x67, 0x6a, 0xe3,
1165     0xf6, 0x55, 0x8a, 0xef, 0xd0, 0x0b, 0xd3, 0xa2,
1166     0xc5, 0x51, 0x70, 0x15, 0x0a, 0xf0, 0x98, 0x4c,
1167     0xb7, 0x19, 0x62, 0x0e, 0x2d, 0x2a, 0x4a, 0x7d,
1168     0x7a, 0x0a, 0xc4, 0x17, 0xe3, 0x5d, 0x20, 0x52,
1169     0xa9, 0x98, 0xc3, 0xaa, 0x11, 0xf6, 0xbf, 0x4c,
1170     0x94, 0x99, 0x81, 0x89, 0xf0, 0x7f, 0x66, 0xaa,
1171     0xc8, 0x88, 0xd7, 0x31, 0x84, 0x71, 0xb6, 0x64,
1172     0x09, 0x76, 0x0b, 0x7f, 0x1a, 0x1f, 0x2e, 0xfe,
1173     0xcd, 0x59, 0x2a, 0x54, 0x11, 0x84, 0xd4, 0x6a,
1174     0x61, 0xdf, 0xaa, 0x76, 0x66, 0x9d, 0x82, 0x11,
1175     0x56, 0x3d, 0xd2, 0x52, 0xe6, 0x42, 0x5a, 0x77,
1176     0x92, 0x98, 0x34, 0xf3, 0x56, 0x6c, 0x96, 0x10,
1177     0x40, 0x59, 0x16, 0xcb, 0x77, 0x61, 0xe3, 0xbf,
1178     0x4b, 0xd4, 0x39, 0xfb, 0xb1, 0x4e, 0xc1, 0x74,
1179     0xec, 0x7a, 0xea, 0x3d, 0x68, 0xbb, 0x0b, 0xe6,
1180     0xc6, 0x06, 0xbf, 0xdd, 0x7f, 0x94, 0x42, 0xc0,
1181     0x0f, 0xe4, 0x92, 0x33, 0x6c, 0x6e, 0x1b, 0xba,
1182     0x73, 0xf9, 0x79, 0x84, 0xdf, 0x45, 0x00, 0xe4,
1183     0x94, 0x88, 0x9d, 0x08, 0x89, 0xcf, 0xf2, 0xa4,
1184     0xc5, 0x47, 0x45, 0x85, 0x86, 0xa5, 0xcc, 0xa8,
1185     0xf2, 0x5d, 0x58, 0x07
1186 };
1187
1188 static void test_import_private(void)
1189 {
1190     DWORD dwLen, dwVal;
1191     HCRYPTKEY hKeyExchangeKey, hSessionKey;
1192     BOOL result;
1193     static BYTE abSessionKey[148] = {
1194         0x01, 0x02, 0x00, 0x00, 0x01, 0x68, 0x00, 0x00,
1195         0x00, 0xa4, 0x00, 0x00, 0xb8, 0xa4, 0xdf, 0x5e,
1196         0x9e, 0xb1, 0xbf, 0x85, 0x3d, 0x24, 0x2d, 0x1e,
1197         0x69, 0xb7, 0x67, 0x13, 0x8e, 0x78, 0xf2, 0xdf,
1198         0xc6, 0x69, 0xce, 0x46, 0x7e, 0xf2, 0xf2, 0x33,
1199         0x20, 0x6f, 0xa1, 0xa5, 0x59, 0x83, 0x25, 0xcb,
1200         0x3a, 0xb1, 0x8a, 0x12, 0x63, 0x02, 0x3c, 0xfb,
1201         0x4a, 0xfa, 0xef, 0x8e, 0xf7, 0x29, 0x57, 0xb1,
1202         0x9e, 0xa7, 0xf3, 0x02, 0xfd, 0xca, 0xdf, 0x5a,
1203         0x1f, 0x71, 0xb6, 0x26, 0x09, 0x24, 0x39, 0xda,
1204         0xc0, 0xde, 0x2a, 0x0e, 0xcd, 0x1f, 0xe5, 0xb6,
1205         0x4f, 0x82, 0xa0, 0xa9, 0x90, 0xd3, 0xd9, 0x6a,
1206         0x43, 0x14, 0x2a, 0xf7, 0xac, 0xd5, 0xa0, 0x54,
1207         0x93, 0xc4, 0xb9, 0xe7, 0x24, 0x84, 0x4d, 0x69,
1208         0x5e, 0xcc, 0x2a, 0x32, 0xb5, 0xfb, 0xe4, 0xb4,
1209         0x08, 0xd5, 0x36, 0x58, 0x59, 0x40, 0xfb, 0x29,
1210         0x7f, 0xa7, 0x17, 0x25, 0xc4, 0x0d, 0x78, 0x37,
1211         0x04, 0x8c, 0x49, 0x92
1212     };
1213     static BYTE abEncryptedMessage[12] = {
1214         0x40, 0x64, 0x28, 0xe8, 0x8a, 0xe7, 0xa4, 0xd4,
1215         0x1c, 0xfd, 0xde, 0x71
1216     };
1217
1218     dwLen = (DWORD)sizeof(abPlainPrivateKey);
1219     result = CryptImportKey(hProv, abPlainPrivateKey, dwLen, 0, 0, &hKeyExchangeKey);
1220     if (!result) {
1221         /* rsaenh compiled without OpenSSL */
1222         ok(GetLastError() == NTE_FAIL, "%08x\n", GetLastError());
1223         return;
1224     }
1225
1226     dwLen = (DWORD)sizeof(abSessionKey);
1227     result = CryptImportKey(hProv, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey);
1228     ok(result, "%08x\n", GetLastError());
1229     if (!result) return;
1230
1231     dwVal = 0xdeadbeef;
1232     dwLen = sizeof(DWORD);
1233     result = CryptGetKeyParam(hSessionKey, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0);
1234     ok(result, "%08x\n", GetLastError());
1235     ok(dwVal ==
1236         (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT) ||
1237         broken(dwVal == 0xffffffff), /* Win9x/NT4 */
1238         "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT,"
1239         " got %08x\n", dwVal);
1240
1241     dwLen = (DWORD)sizeof(abEncryptedMessage);
1242     result = CryptDecrypt(hSessionKey, 0, TRUE, 0, abEncryptedMessage, &dwLen);
1243     ok(result && dwLen == 12 && !memcmp(abEncryptedMessage, "Wine rocks!",12),
1244        "%08x, len: %d\n", GetLastError(), dwLen);
1245     CryptDestroyKey(hSessionKey);
1246
1247     if (!derive_key(CALG_RC4, &hSessionKey, 56)) return;
1248
1249     dwLen = (DWORD)sizeof(abSessionKey);
1250     result = CryptExportKey(hSessionKey, hKeyExchangeKey, SIMPLEBLOB, 0, abSessionKey, &dwLen);
1251     ok(result, "%08x\n", GetLastError());
1252     CryptDestroyKey(hSessionKey);
1253     if (!result) return;
1254
1255     dwLen = (DWORD)sizeof(abSessionKey);
1256     result = CryptImportKey(hProv, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey);
1257     ok(result, "%08x\n", GetLastError());
1258     if (!result) return;
1259
1260     CryptDestroyKey(hSessionKey);
1261     CryptDestroyKey(hKeyExchangeKey);
1262 }
1263
1264 static void test_verify_signature(void) {
1265     HCRYPTHASH hHash;
1266     HCRYPTKEY hPubSignKey;
1267     BYTE abData[] = "Wine rocks!";
1268     BOOL result;
1269     BYTE abPubKey[148] = {
1270         0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
1271         0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00,
1272         0x01, 0x00, 0x01, 0x00, 0x71, 0x64, 0x9f, 0x19,
1273         0x89, 0x1c, 0x21, 0xcc, 0x36, 0xa3, 0xc9, 0x27,
1274         0x08, 0x8a, 0x09, 0xc6, 0xbe, 0xeb, 0xd3, 0xf8,
1275         0x19, 0xa9, 0x92, 0x57, 0xe4, 0xb9, 0x5d, 0xda,
1276         0x88, 0x93, 0xe4, 0x6b, 0x38, 0x77, 0x14, 0x8a,
1277         0x96, 0xc0, 0xb6, 0x4e, 0x42, 0xf5, 0x01, 0xdc,
1278         0xf0, 0xeb, 0x3c, 0xc7, 0x7b, 0xc4, 0xfd, 0x7c,
1279         0xde, 0x93, 0x34, 0x0a, 0x92, 0xe5, 0x97, 0x9c,
1280         0x3e, 0x65, 0xb8, 0x91, 0x2f, 0xe3, 0xf3, 0x89,
1281         0xcd, 0x6c, 0x26, 0xa4, 0x6c, 0xc7, 0x6d, 0x0b,
1282         0x2c, 0xa2, 0x0b, 0x29, 0xe2, 0xfc, 0x30, 0xfa,
1283         0x20, 0xdb, 0x4c, 0xb8, 0x91, 0xb8, 0x69, 0x63,
1284         0x96, 0x41, 0xc2, 0xb4, 0x60, 0xeb, 0xcd, 0xff,
1285         0x3a, 0x1f, 0x94, 0xb1, 0x23, 0xcf, 0x0f, 0x49,
1286         0xad, 0xd5, 0x33, 0x85, 0x71, 0xaf, 0x12, 0x87,
1287         0x84, 0xef, 0xa0, 0xea, 0xe1, 0xc1, 0xd4, 0xc7,
1288         0xe1, 0x21, 0x50, 0xac
1289     };
1290     /* md2 with hash oid */
1291     BYTE abSignatureMD2[128] = {
1292         0x4a, 0x4e, 0xb7, 0x5e, 0x32, 0xda, 0xdb, 0x67,
1293         0x9f, 0x77, 0x84, 0x32, 0x00, 0xba, 0x5f, 0x6b,
1294         0x0d, 0xcf, 0xd9, 0x99, 0xbd, 0x96, 0x31, 0xda,
1295         0x23, 0x4c, 0xd9, 0x4a, 0x90, 0x84, 0x20, 0x59,
1296         0x51, 0xdc, 0xd4, 0x93, 0x3a, 0xae, 0x0a, 0x0a,
1297         0xa1, 0x76, 0xfa, 0xb5, 0x68, 0xee, 0xc7, 0x34,
1298         0x41, 0xd3, 0xe7, 0x5a, 0x0e, 0x22, 0x61, 0x40,
1299         0xea, 0x24, 0x56, 0xf1, 0x91, 0x5a, 0xf7, 0xa7,
1300         0x5b, 0xf4, 0x98, 0x6b, 0xc3, 0xef, 0xad, 0xc0,
1301         0x5e, 0x6b, 0x87, 0x76, 0xcb, 0x1f, 0x62, 0x06,
1302         0x7c, 0xf6, 0x48, 0x97, 0x81, 0x8d, 0xef, 0x51,
1303         0x51, 0xdc, 0x21, 0x91, 0x57, 0x1e, 0x79, 0x6f,
1304         0x49, 0xb5, 0xde, 0x31, 0x07, 0x45, 0x99, 0x46,
1305         0xc3, 0x4f, 0xca, 0x2d, 0x0e, 0x4c, 0x10, 0x25,
1306         0xcb, 0x1a, 0x98, 0x63, 0x41, 0x93, 0x47, 0xc0,
1307         0xb2, 0xbc, 0x10, 0x3c, 0xe7, 0xd4, 0x3c, 0x1e
1308     };
1309     /* md2 without hash oid */
1310     BYTE abSignatureMD2NoOID[128] = {
1311         0x0c, 0x21, 0x3e, 0x60, 0xf9, 0xd0, 0x36, 0x2d,
1312         0xe1, 0x10, 0x45, 0x45, 0x85, 0x03, 0x29, 0x19,
1313         0xef, 0x19, 0xd9, 0xa6, 0x7e, 0x9c, 0x0d, 0xbd,
1314         0x03, 0x0e, 0xb9, 0x51, 0x9e, 0x74, 0x79, 0xc4,
1315         0xde, 0x25, 0xf2, 0x35, 0x74, 0x55, 0xbc, 0x65,
1316         0x7e, 0x33, 0x28, 0xa8, 0x1e, 0x72, 0xaa, 0x99,
1317         0xdd, 0xf5, 0x26, 0x20, 0x29, 0xf8, 0xa6, 0xdf,
1318         0x28, 0x4b, 0x1c, 0xdb, 0xa1, 0x41, 0x56, 0xbc,
1319         0xf9, 0x9c, 0x66, 0xc0, 0x37, 0x41, 0x55, 0xa0,
1320         0xe2, 0xec, 0xbf, 0x71, 0xf0, 0x5d, 0x25, 0x01,
1321         0x75, 0x91, 0xe2, 0x81, 0xb2, 0x9f, 0x57, 0xa7,
1322         0x5c, 0xd2, 0xfa, 0x66, 0xdb, 0x71, 0x2b, 0x1f,
1323         0xad, 0x30, 0xde, 0xea, 0x49, 0x73, 0x30, 0x6a,
1324         0x22, 0x54, 0x49, 0x4e, 0xae, 0xf6, 0x88, 0xc9,
1325         0xff, 0x71, 0xba, 0xbf, 0x27, 0xc5, 0xfa, 0x06,
1326         0xe2, 0x91, 0x71, 0x8a, 0x7e, 0x0c, 0xc2, 0x07
1327     };
1328     /* md4 with hash oid */
1329     BYTE abSignatureMD4[128] = {
1330         0x1c, 0x78, 0xaa, 0xea, 0x74, 0xf4, 0x83, 0x51,
1331         0xae, 0x66, 0xe3, 0xa9, 0x1c, 0x03, 0x39, 0x1b,
1332         0xac, 0x7e, 0x4e, 0x85, 0x7e, 0x1c, 0x38, 0xd2,
1333         0x82, 0x43, 0xb3, 0x6f, 0x6f, 0x46, 0x45, 0x8e,
1334         0x17, 0x74, 0x58, 0x29, 0xca, 0xe1, 0x03, 0x13,
1335         0x45, 0x79, 0x34, 0xdf, 0x5c, 0xd6, 0xc3, 0xf9,
1336         0x7a, 0x1c, 0x9d, 0xff, 0x6f, 0x03, 0x7d, 0x0f,
1337         0x59, 0x1a, 0x2d, 0x0e, 0x94, 0xb4, 0x75, 0x96,
1338         0xd1, 0x48, 0x63, 0x6e, 0xb2, 0xc4, 0x5c, 0xd9,
1339         0xab, 0x49, 0xb4, 0x90, 0xd9, 0x57, 0x04, 0x6e,
1340         0x4c, 0xb6, 0xea, 0x00, 0x94, 0x4a, 0x34, 0xa0,
1341         0xd9, 0x63, 0xef, 0x2c, 0xde, 0x5b, 0xb9, 0xbe,
1342         0x35, 0xc8, 0xc1, 0x31, 0xb5, 0x31, 0x15, 0x18,
1343         0x90, 0x39, 0xf5, 0x2a, 0x34, 0x6d, 0xb4, 0xab,
1344         0x09, 0x34, 0x69, 0x54, 0x4d, 0x11, 0x2f, 0xf3,
1345         0xa2, 0x36, 0x0e, 0xa8, 0x45, 0xe7, 0x36, 0xac
1346     };
1347     /* md4 without hash oid */
1348     BYTE abSignatureMD4NoOID[128] = {
1349         0xd3, 0x60, 0xb2, 0xb0, 0x22, 0x0a, 0x99, 0xda,
1350         0x04, 0x85, 0x64, 0xc6, 0xc6, 0xdb, 0x11, 0x24,
1351         0xe9, 0x68, 0x2d, 0xf7, 0x09, 0xef, 0xb6, 0xa0,
1352         0xa2, 0xfe, 0x45, 0xee, 0x85, 0x49, 0xcd, 0x36,
1353         0xf7, 0xc7, 0x9d, 0x2b, 0x4c, 0x68, 0xda, 0x85,
1354         0x8c, 0x50, 0xcc, 0x4f, 0x4b, 0xe1, 0x82, 0xc3,
1355         0xbe, 0xa3, 0xf1, 0x78, 0x6b, 0x60, 0x42, 0x3f,
1356         0x67, 0x22, 0x14, 0xe4, 0xe1, 0xa4, 0x6e, 0xa9,
1357         0x4e, 0xf1, 0xd4, 0xb0, 0xce, 0x82, 0xac, 0x06,
1358         0xba, 0x2c, 0xbc, 0xf7, 0xcb, 0xf6, 0x0c, 0x3f,
1359         0xf6, 0x79, 0xfe, 0xb3, 0xd8, 0x5a, 0xbc, 0xdb,
1360         0x05, 0x41, 0xa4, 0x07, 0x57, 0x9e, 0xa2, 0x96,
1361         0xfc, 0x60, 0x4b, 0xf7, 0x6f, 0x86, 0x26, 0x1f,
1362         0xc2, 0x2c, 0x67, 0x08, 0xcd, 0x7f, 0x91, 0xe9,
1363         0x16, 0xb5, 0x0e, 0xd9, 0xc4, 0xc4, 0x97, 0xeb,
1364         0x91, 0x3f, 0x20, 0x6c, 0xf0, 0x68, 0x86, 0x7f
1365     };
1366     /* md5 with hash oid */
1367     BYTE abSignatureMD5[128] = {
1368         0x4f, 0xe0, 0x8c, 0x9b, 0x43, 0xdd, 0x02, 0xe5,
1369         0xf4, 0xa1, 0xdd, 0x88, 0x4c, 0x9c, 0x40, 0x0f,
1370         0x6c, 0x43, 0x86, 0x64, 0x00, 0xe6, 0xac, 0xf7,
1371         0xd0, 0x92, 0xaa, 0xc4, 0x62, 0x9a, 0x48, 0x98,
1372         0x1a, 0x56, 0x6d, 0x75, 0xec, 0x04, 0x89, 0xec,
1373         0x69, 0x93, 0xd6, 0x61, 0x37, 0xb2, 0x36, 0xb5,
1374         0xb2, 0xba, 0xf2, 0xf5, 0x21, 0x0c, 0xf1, 0x04,
1375         0xc8, 0x2d, 0xf5, 0xa0, 0x8d, 0x6d, 0x10, 0x0b,
1376         0x68, 0x63, 0xf2, 0x08, 0x68, 0xdc, 0xbd, 0x95,
1377         0x25, 0x7d, 0xee, 0x63, 0x5c, 0x3b, 0x98, 0x4c,
1378         0xea, 0x41, 0xdc, 0x6a, 0x8b, 0x6c, 0xbb, 0x29,
1379         0x2b, 0x1c, 0x5c, 0x8b, 0x7d, 0x94, 0x24, 0xa9,
1380         0x7a, 0x62, 0x94, 0xf3, 0x3a, 0x6a, 0xb2, 0x4c,
1381         0x33, 0x59, 0x00, 0xcd, 0x7d, 0x37, 0x79, 0x90,
1382         0x31, 0xd1, 0xd9, 0x84, 0x12, 0xe5, 0x08, 0x5e,
1383         0xb3, 0x60, 0x61, 0x27, 0x78, 0x37, 0x63, 0x01
1384     };
1385     /* md5 without hash oid */
1386     BYTE abSignatureMD5NoOID[128] = {
1387         0xc6, 0xad, 0x5c, 0x2b, 0x9b, 0xe0, 0x99, 0x2f,
1388         0x5e, 0x55, 0x04, 0x32, 0x65, 0xe0, 0xb5, 0x75,
1389         0x01, 0x9a, 0x11, 0x4d, 0x0e, 0x9a, 0xe1, 0x9f,
1390         0xc7, 0xbf, 0x77, 0x6d, 0xa9, 0xfd, 0xcc, 0x9d,
1391         0x8b, 0xd1, 0x31, 0xed, 0x5a, 0xd2, 0xe5, 0x5f,
1392         0x42, 0x3b, 0xb5, 0x3c, 0x32, 0x30, 0x88, 0x49,
1393         0xcb, 0x67, 0xb8, 0x2e, 0xc9, 0xf5, 0x2b, 0xc8,
1394         0x35, 0x71, 0xb5, 0x1b, 0x32, 0x3f, 0x44, 0x4c,
1395         0x66, 0x93, 0xcb, 0xe8, 0x48, 0x7c, 0x14, 0x23,
1396         0xfb, 0x12, 0xa5, 0xb7, 0x86, 0x94, 0x6b, 0x19,
1397         0x17, 0x20, 0xc6, 0xb8, 0x09, 0xe8, 0xbb, 0xdb,
1398         0x00, 0x2b, 0x96, 0x4a, 0x93, 0x00, 0x26, 0xd3,
1399         0x07, 0xa0, 0x06, 0xce, 0x5a, 0x13, 0x69, 0x6b,
1400         0x62, 0x5a, 0x56, 0x61, 0x6a, 0xd8, 0x11, 0x3b,
1401         0xd5, 0x67, 0xc7, 0x4d, 0xf6, 0x66, 0x63, 0xc5,
1402         0xe3, 0x8f, 0x7c, 0x7c, 0xb1, 0x3e, 0x55, 0x43
1403     };
1404     /* sha with hash oid */
1405     BYTE abSignatureSHA[128] = {
1406         0x5a, 0x4c, 0x66, 0xc9, 0x30, 0x67, 0xcb, 0x91,
1407         0x3c, 0x4d, 0xd5, 0x8d, 0xea, 0x4e, 0x85, 0xcd,
1408         0xd9, 0x68, 0x3a, 0xf3, 0x24, 0x3c, 0x99, 0x24,
1409         0x25, 0x32, 0x93, 0x3d, 0xd6, 0x2f, 0x86, 0x94,
1410         0x23, 0x09, 0xee, 0x02, 0xd4, 0x15, 0xdc, 0x5f,
1411         0x0e, 0x44, 0x45, 0x13, 0x5f, 0x18, 0x5d, 0x1a,
1412         0xd7, 0x0b, 0xd1, 0x23, 0xd6, 0x35, 0x98, 0x52,
1413         0x57, 0x45, 0x74, 0x92, 0xe3, 0x50, 0xb4, 0x20,
1414         0x28, 0x2a, 0x11, 0xbf, 0x49, 0xb4, 0x2c, 0xc5,
1415         0xd4, 0x1a, 0x27, 0x4e, 0xdf, 0xa0, 0xb5, 0x7a,
1416         0xc8, 0x14, 0xdd, 0x9b, 0xb6, 0xca, 0xd6, 0xff,
1417         0xb2, 0x6b, 0xd8, 0x98, 0x67, 0x80, 0xab, 0x53,
1418         0x52, 0xbb, 0xe1, 0x2a, 0xce, 0x79, 0x2f, 0x00,
1419         0x53, 0x26, 0xd8, 0xa7, 0x43, 0xca, 0x72, 0x0e,
1420         0x68, 0x97, 0x37, 0x71, 0x87, 0xc2, 0x6a, 0x98,
1421         0xbb, 0x6c, 0xa0, 0x01, 0xff, 0x04, 0x9d, 0xa6
1422     };
1423     /* sha without hash oid */
1424     BYTE abSignatureSHANoOID[128] = {
1425         0x86, 0xa6, 0x2b, 0x9a, 0x04, 0xda, 0x47, 0xc6,
1426         0x4f, 0x97, 0x8a, 0x8a, 0xf4, 0xfa, 0x63, 0x1a,
1427         0x32, 0x89, 0x56, 0x41, 0x37, 0x91, 0x15, 0x2f,
1428         0x2d, 0x1c, 0x8f, 0xdc, 0x88, 0x40, 0xbb, 0x37,
1429         0x3e, 0x06, 0x33, 0x1b, 0xde, 0xda, 0x7c, 0x65,
1430         0x91, 0x35, 0xca, 0x45, 0x17, 0x0e, 0x24, 0xbe,
1431         0x9e, 0xf6, 0x4e, 0x8a, 0xa4, 0x3e, 0xca, 0xe6,
1432         0x11, 0x36, 0xb8, 0x3a, 0xf0, 0xde, 0x71, 0xfe,
1433         0xdd, 0xb3, 0xcb, 0x6c, 0x39, 0xe0, 0x5f, 0x0c,
1434         0x9e, 0xa8, 0x40, 0x26, 0x9c, 0x81, 0xe9, 0xc4,
1435         0x15, 0x90, 0xbf, 0x4f, 0xd2, 0xc1, 0xa1, 0x80,
1436         0x52, 0xfd, 0xf6, 0x3d, 0x99, 0x1b, 0x9c, 0x8a,
1437         0x27, 0x1b, 0x0c, 0x9a, 0xf3, 0xf9, 0xa2, 0x00,
1438         0x3e, 0x5b, 0xdf, 0xc2, 0xb4, 0x71, 0xa5, 0xbd,
1439         0xf8, 0xae, 0x63, 0xbb, 0x4a, 0xc9, 0xdd, 0x67,
1440         0xc1, 0x3e, 0x93, 0xee, 0xf1, 0x1f, 0x24, 0x5b
1441     };
1442
1443     result = CryptImportKey(hProv, abPubKey, 148, 0, 0, &hPubSignKey);
1444     ok(result, "%08x\n", GetLastError());
1445     if (!result) return;
1446
1447     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
1448     ok(result, "%08x\n", GetLastError());
1449     if (!result) return;
1450
1451     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1452     ok(result, "%08x\n", GetLastError());
1453     if (!result) return;
1454
1455     /*check that a NULL pointer signature is correctly handled*/
1456     result = CryptVerifySignature(hHash, NULL, 128, hPubSignKey, NULL, 0);
1457     ok(!result && ERROR_INVALID_PARAMETER == GetLastError(),
1458      "Expected ERROR_INVALID_PARAMETER error, got %08x\n", GetLastError());
1459     if (result) return;
1460
1461     /* check that we get a bad signature error when the signature is too short*/
1462     SetLastError(0xdeadbeef);
1463     result = CryptVerifySignature(hHash, abSignatureMD2, 64, hPubSignKey, NULL, 0);
1464     ok((!result && NTE_BAD_SIGNATURE == GetLastError()) ||
1465      broken(result), /* Win9x, WinMe, NT4 */
1466      "Expected NTE_BAD_SIGNATURE, got %08x\n",  GetLastError());
1467
1468     result = CryptVerifySignature(hHash, abSignatureMD2, 128, hPubSignKey, NULL, 0);
1469     ok(result, "%08x\n", GetLastError());
1470     if (!result) return;
1471
1472     result = CryptVerifySignature(hHash, abSignatureMD2NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1473     ok(result, "%08x\n", GetLastError());
1474     if (!result) return;
1475
1476     /* Next test fails on WinXP SP2. It seems that CPVerifySignature doesn't care about
1477      * the OID at all. */
1478     /*result = CryptVerifySignature(hHash, abSignatureMD2NoOID, 128, hPubSignKey, NULL, 0);
1479     ok(!result && GetLastError()==NTE_BAD_SIGNATURE, "%08lx\n", GetLastError());
1480     if (result) return;*/
1481
1482     CryptDestroyHash(hHash);
1483
1484     result = CryptCreateHash(hProv, CALG_MD4, 0, 0, &hHash);
1485     ok(result, "%08x\n", GetLastError());
1486     if (!result) return;
1487
1488     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1489     ok(result, "%08x\n", GetLastError());
1490     if (!result) return;
1491
1492     result = CryptVerifySignature(hHash, abSignatureMD4, 128, hPubSignKey, NULL, 0);
1493     ok(result, "%08x\n", GetLastError());
1494     if (!result) return;
1495
1496     result = CryptVerifySignature(hHash, abSignatureMD4NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1497     ok(result, "%08x\n", GetLastError());
1498     if (!result) return;
1499
1500     CryptDestroyHash(hHash);
1501
1502     result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
1503     ok(result, "%08x\n", GetLastError());
1504     if (!result) return;
1505
1506     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1507     ok(result, "%08x\n", GetLastError());
1508     if (!result) return;
1509
1510     result = CryptVerifySignature(hHash, abSignatureMD5, 128, hPubSignKey, NULL, 0);
1511     ok(result, "%08x\n", GetLastError());
1512     if (!result) return;
1513
1514     result = CryptVerifySignature(hHash, abSignatureMD5NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1515     ok(result, "%08x\n", GetLastError());
1516     if (!result) return;
1517
1518     CryptDestroyHash(hHash);
1519
1520     result = CryptCreateHash(hProv, CALG_SHA, 0, 0, &hHash);
1521     ok(result, "%08x\n", GetLastError());
1522     if (!result) return;
1523
1524     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1525     ok(result, "%08x\n", GetLastError());
1526     if (!result) return;
1527
1528     result = CryptVerifySignature(hHash, abSignatureSHA, 128, hPubSignKey, NULL, 0);
1529     ok(result, "%08x\n", GetLastError());
1530     if (!result) return;
1531
1532     result = CryptVerifySignature(hHash, abSignatureSHANoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1533     ok(result, "%08x\n", GetLastError());
1534     if (!result) return;
1535
1536     CryptDestroyHash(hHash);
1537     CryptDestroyKey(hPubSignKey);
1538 }
1539
1540 static void test_rsa_encrypt(void)
1541 {
1542     HCRYPTKEY hRSAKey;
1543     BYTE abData[2048] = "Wine rocks!";
1544     BOOL result;
1545     DWORD dwVal, dwLen;
1546
1547     /* It is allowed to use the key exchange key for encryption/decryption */
1548     result = CryptGetUserKey(hProv, AT_KEYEXCHANGE, &hRSAKey);
1549     ok (result, "%08x\n", GetLastError());
1550     if (!result) return;
1551
1552     dwLen = 12;
1553     result = CryptEncrypt(hRSAKey, 0, TRUE, 0, NULL, &dwLen, (DWORD)sizeof(abData));
1554     ok(result, "CryptEncrypt failed: %08x\n", GetLastError());
1555     ok(dwLen == 128, "Unexpected length %d\n", dwLen);
1556     dwLen = 12;
1557     result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, (DWORD)sizeof(abData));
1558     ok (result, "%08x\n", GetLastError());
1559     if (!result) return;
1560
1561     result = CryptDecrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen);
1562     ok (result && dwLen == 12 && !memcmp(abData, "Wine rocks!", 12), "%08x\n", GetLastError());
1563
1564     dwVal = 0xdeadbeef;
1565     dwLen = sizeof(DWORD);
1566     result = CryptGetKeyParam(hRSAKey, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0);
1567     ok(result, "%08x\n", GetLastError());
1568     ok(dwVal ==
1569         (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT) ||
1570         broken(dwVal == 0xffffffff), /* Win9x/NT4 */
1571         "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT,"
1572         " got %08x\n", dwVal);
1573
1574     /* The key exchange key's public key may be exported.. */
1575     result = CryptExportKey(hRSAKey, 0, PUBLICKEYBLOB, 0, NULL, &dwLen);
1576     ok(result, "%08x\n", GetLastError());
1577     /* but its private key may not be. */
1578     SetLastError(0xdeadbeef);
1579     result = CryptExportKey(hRSAKey, 0, PRIVATEKEYBLOB, 0, NULL, &dwLen);
1580     ok((!result && GetLastError() == NTE_BAD_KEY_STATE) ||
1581         broken(result), /* Win9x/NT4 */
1582         "expected NTE_BAD_KEY_STATE, got %08x\n", GetLastError());
1583     /* Setting the permissions of the key exchange key isn't allowed, either. */
1584     dwVal |= CRYPT_EXPORT;
1585     SetLastError(0xdeadbeef);
1586     result = CryptSetKeyParam(hRSAKey, KP_PERMISSIONS, (BYTE *)&dwVal, 0);
1587     ok(!result &&
1588         (GetLastError() == NTE_BAD_DATA || GetLastError() == NTE_BAD_FLAGS),
1589         "expected NTE_BAD_DATA or NTE_BAD_FLAGS, got %08x\n", GetLastError());
1590
1591     CryptDestroyKey(hRSAKey);
1592
1593     /* It is not allowed to use the signature key for encryption/decryption */
1594     result = CryptGetUserKey(hProv, AT_SIGNATURE, &hRSAKey);
1595     ok (result, "%08x\n", GetLastError());
1596     if (!result) return;
1597
1598     dwVal = 0xdeadbeef;
1599     dwLen = sizeof(DWORD);
1600     result = CryptGetKeyParam(hRSAKey, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0);
1601     ok(result, "%08x\n", GetLastError());
1602     ok(dwVal ==
1603         (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT) ||
1604         broken(dwVal == 0xffffffff), /* Win9x/NT4 */
1605         "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT,"
1606         " got %08x\n", dwVal);
1607
1608     /* The signature key's public key may also be exported.. */
1609     result = CryptExportKey(hRSAKey, 0, PUBLICKEYBLOB, 0, NULL, &dwLen);
1610     ok(result, "%08x\n", GetLastError());
1611     /* but its private key may not be. */
1612     SetLastError(0xdeadbeef);
1613     result = CryptExportKey(hRSAKey, 0, PRIVATEKEYBLOB, 0, NULL, &dwLen);
1614     ok((!result && GetLastError() == NTE_BAD_KEY_STATE) ||
1615         broken(result), /* Win9x/NT4 */
1616         "expected NTE_BAD_KEY_STATE, got %08x\n", GetLastError());
1617     /* Setting the permissions of the signature key isn't allowed, either. */
1618     dwVal |= CRYPT_EXPORT;
1619     SetLastError(0xdeadbeef);
1620     result = CryptSetKeyParam(hRSAKey, KP_PERMISSIONS, (BYTE *)&dwVal, 0);
1621     ok(!result &&
1622         (GetLastError() == NTE_BAD_DATA || GetLastError() == NTE_BAD_FLAGS),
1623         "expected NTE_BAD_DATA or NTE_BAD_FLAGS, got %08x\n", GetLastError());
1624
1625     dwLen = 12;
1626     result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, (DWORD)sizeof(abData));
1627     ok (!result && GetLastError() == NTE_BAD_KEY, "%08x\n", GetLastError());
1628
1629     CryptDestroyKey(hRSAKey);
1630 }
1631
1632 static void test_import_export(void)
1633 {
1634     DWORD dwLen, dwDataLen, dwVal;
1635     HCRYPTKEY hPublicKey, hPrivKey;
1636     BOOL result;
1637     ALG_ID algID;
1638     BYTE emptyKey[2048], *exported_key;
1639     static BYTE abPlainPublicKey[84] = {
1640         0x06, 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00,
1641         0x52, 0x53, 0x41, 0x31, 0x00, 0x02, 0x00, 0x00,
1642         0x01, 0x00, 0x01, 0x00, 0x11, 0x11, 0x11, 0x11,
1643         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1644         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1645         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1646         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1647         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1648         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1649         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1650         0x11, 0x11, 0x11, 0x11
1651     };
1652     static BYTE priv_key_with_high_bit[] = {
1653         0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
1654         0x52, 0x53, 0x41, 0x32, 0x00, 0x04, 0x00, 0x00,
1655         0x01, 0x00, 0x01, 0x00, 0xd5, 0xa2, 0x0d, 0x66,
1656         0xfe, 0x65, 0xb5, 0xf1, 0xc9, 0x6b, 0xf5, 0x58,
1657         0x04, 0x38, 0x2d, 0xf4, 0xa3, 0x5a, 0xda, 0x9e,
1658         0x95, 0x81, 0x85, 0x3d, 0x01, 0x07, 0xb2, 0x03,
1659         0x77, 0x70, 0x79, 0x6e, 0x6c, 0x26, 0x42, 0xa4,
1660         0x12, 0xfd, 0xaa, 0x29, 0x83, 0x04, 0xce, 0x91,
1661         0x90, 0x39, 0x5e, 0x49, 0x56, 0xfd, 0x0a, 0xe5,
1662         0xb1, 0xea, 0x3b, 0xb2, 0x70, 0xb0, 0x20, 0xc1,
1663         0x1f, 0x22, 0x07, 0x3e, 0x4d, 0xc0, 0x73, 0xfd,
1664         0x92, 0x8f, 0x87, 0xd8, 0xd1, 0xd1, 0x28, 0xd8,
1665         0x19, 0xd1, 0x93, 0x83, 0xe0, 0xb8, 0x9f, 0x53,
1666         0xf4, 0x6a, 0x7c, 0xcb, 0x10, 0x53, 0xd0, 0x37,
1667         0x02, 0xb4, 0xa5, 0xf7, 0xa2, 0x28, 0x6e, 0x26,
1668         0xef, 0x5c, 0x14, 0x01, 0x40, 0x1e, 0xa3, 0xe1,
1669         0xda, 0x76, 0xd0, 0x12, 0x84, 0xb7, 0x48, 0x7d,
1670         0xc8, 0x67, 0x5c, 0xb2, 0xd5, 0x2e, 0xaf, 0x8e,
1671         0x7d, 0x32, 0x59, 0x92, 0x01, 0xd6, 0x5b, 0x68,
1672         0x28, 0x9b, 0xb1, 0x6c, 0x69, 0xeb, 0x61, 0x5b,
1673         0x4b, 0x13, 0xe2, 0xbd, 0x7d, 0xbe, 0xce, 0xe8,
1674         0x41, 0x54, 0xca, 0xa8, 0xdd, 0xc7, 0xfe, 0x8b,
1675         0xdf, 0xf6, 0x55, 0x6c, 0x50, 0x11, 0xc8, 0x15,
1676         0x13, 0x42, 0x59, 0x9f, 0xbb, 0xea, 0x73, 0x78,
1677         0x7b, 0x22, 0x8d, 0x96, 0x62, 0xe5, 0xda, 0xa2,
1678         0x85, 0x5c, 0x20, 0x74, 0x9f, 0x1c, 0x12, 0xf2,
1679         0x48, 0x06, 0x1a, 0xc6, 0xd5, 0x94, 0xec, 0x31,
1680         0x6b, 0xb6, 0x7b, 0x54, 0x61, 0x77, 0xec, 0x7c,
1681         0x6f, 0xb7, 0x55, 0x3d, 0x6b, 0x98, 0x05, 0xd7,
1682         0x8a, 0x73, 0x25, 0xf2, 0x8f, 0xe4, 0xb8, 0x8d,
1683         0x27, 0x18, 0x0d, 0x05, 0xba, 0x23, 0x54, 0x37,
1684         0x10, 0xf0, 0x1c, 0x41, 0xa6, 0xae, 0x4c, 0x2a,
1685         0x6a, 0x2f, 0x7f, 0x68, 0x43, 0x86, 0xe7, 0x9c,
1686         0xfd, 0x9e, 0xf1, 0xfe, 0x84, 0xe3, 0xb6, 0x99,
1687         0x51, 0xfe, 0x1e, 0xbd, 0x01, 0xc6, 0x10, 0xef,
1688         0x88, 0xa4, 0xd8, 0x53, 0x14, 0x88, 0x15, 0xc9,
1689         0xe5, 0x86, 0xe2, 0x8d, 0x85, 0x2e, 0x0d, 0xec,
1690         0x15, 0xa7, 0x48, 0xfa, 0x18, 0xfb, 0x01, 0x8d,
1691         0x2b, 0x90, 0x70, 0x7f, 0x78, 0xb1, 0x33, 0x7e,
1692         0xfe, 0x82, 0x40, 0x5f, 0x4a, 0x97, 0xc2, 0x42,
1693         0x22, 0xd5, 0x5f, 0xbc, 0xbd, 0xab, 0x26, 0x98,
1694         0xcd, 0xb5, 0xdf, 0x7e, 0xa0, 0x68, 0xa7, 0x12,
1695         0x9e, 0xa5, 0xa2, 0x90, 0x85, 0xc5, 0xca, 0x73,
1696         0x4a, 0x59, 0x8a, 0xec, 0xcf, 0xdd, 0x65, 0x5d,
1697         0xc1, 0xaa, 0x86, 0x53, 0xd5, 0xde, 0xbb, 0x23,
1698         0x24, 0xb8, 0x9b, 0x74, 0x03, 0x20, 0xb4, 0xf0,
1699         0xe4, 0xdd, 0xd2, 0x03, 0xfd, 0x67, 0x55, 0x19,
1700         0x28, 0x1d, 0xc1, 0xb8, 0xa5, 0x89, 0x0e, 0xc0,
1701         0x80, 0x9d, 0xdd, 0xda, 0x9d, 0x30, 0x5c, 0xc8,
1702         0xbb, 0xfe, 0x8f, 0xce, 0xd5, 0xf6, 0xdf, 0xfa,
1703         0x14, 0xaf, 0xe4, 0xba, 0xb0, 0x84, 0x45, 0xd8,
1704         0x67, 0xa7, 0xd0, 0xce, 0x89, 0x2a, 0x30, 0x8c,
1705         0xfa, 0xe9, 0x65, 0xa4, 0x21, 0x2d, 0x6b, 0xa2,
1706         0x9b, 0x8f, 0x92, 0xbd, 0x3a, 0x10, 0x71, 0x12,
1707         0xc2, 0x02, 0x3d, 0xd5, 0x83, 0x1d, 0xfa, 0x42,
1708         0xb7, 0x48, 0x1b, 0x31, 0xe3, 0x82, 0x90, 0x2d,
1709         0x91, 0x59, 0xf9, 0x38, 0x52, 0xe5, 0xdb, 0xc1,
1710         0x4d, 0x3a, 0xe6, 0x9b, 0x6a, 0xbb, 0xea, 0xa4,
1711         0x8d, 0x5e, 0xc4, 0x00, 0x01, 0xb8, 0xec, 0x91,
1712         0xc1, 0xdb, 0x63, 0xbd, 0x57, 0xb6, 0x26, 0x15,
1713         0xb6, 0x3e, 0xa2, 0xdf, 0x62, 0x8d, 0xa8, 0xbe,
1714         0xe1, 0xf1, 0x39, 0xbd, 0x18, 0xd2, 0x6f, 0xd7,
1715         0xda, 0xdc, 0x71, 0x30, 0xf1, 0x21, 0x71, 0xa4,
1716         0x08, 0x43, 0x46, 0xdf, 0x50, 0xbd, 0x3c, 0x60,
1717         0x5b, 0x63, 0x35, 0xe3, 0x37, 0x5b, 0x25, 0x17,
1718         0x54, 0x5e, 0x68, 0x60, 0xb6, 0x49, 0xef, 0x6e,
1719         0x09, 0xef, 0xda, 0x90, 0x3e, 0xd4, 0x09, 0x33,
1720         0x36, 0x57, 0x9a, 0x14, 0xbd, 0xf7, 0xb1, 0x98,
1721         0x30, 0x42, 0x03, 0x84, 0x61, 0xeb, 0x8e, 0x50,
1722         0xdc, 0x6a, 0x93, 0x1b, 0x32, 0x51, 0xf9, 0xc6,
1723         0xc2, 0x19, 0xb3, 0x5d, 0xe2, 0xf8, 0xc5, 0x8f,
1724         0x68, 0xaa, 0x1d, 0xdb, 0xd3, 0x7f, 0x8d, 0x98,
1725         0x9c, 0x16, 0x8c, 0xc3, 0xcd, 0xd9, 0xdb, 0x08,
1726         0xe6, 0x36, 0x60, 0xb6, 0x36, 0xdc, 0x1d, 0x59,
1727         0xb6, 0x5f, 0x01, 0x5e
1728     };
1729     static const BYTE expected_exported_priv_key[] = {
1730         0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
1731         0x52, 0x53, 0x41, 0x32, 0x00, 0x04, 0x00, 0x00,
1732         0x01, 0x00, 0x01, 0x00, 0xd5, 0xa2, 0x0d, 0x66,
1733         0xfe, 0x65, 0xb5, 0xf1, 0xc9, 0x6b, 0xf5, 0x58,
1734         0x04, 0x38, 0x2d, 0xf4, 0xa3, 0x5a, 0xda, 0x9e,
1735         0x95, 0x81, 0x85, 0x3d, 0x01, 0x07, 0xb2, 0x03,
1736         0x77, 0x70, 0x79, 0x6e, 0x6c, 0x26, 0x42, 0xa4,
1737         0x12, 0xfd, 0xaa, 0x29, 0x83, 0x04, 0xce, 0x91,
1738         0x90, 0x39, 0x5e, 0x49, 0x56, 0xfd, 0x0a, 0xe5,
1739         0xb1, 0xea, 0x3b, 0xb2, 0x70, 0xb0, 0x20, 0xc1,
1740         0x1f, 0x22, 0x07, 0x3e, 0x4d, 0xc0, 0x73, 0xfd,
1741         0x92, 0x8f, 0x87, 0xd8, 0xd1, 0xd1, 0x28, 0xd8,
1742         0x19, 0xd1, 0x93, 0x83, 0xe0, 0xb8, 0x9f, 0x53,
1743         0xf4, 0x6a, 0x7c, 0xcb, 0x10, 0x53, 0xd0, 0x37,
1744         0x02, 0xb4, 0xa5, 0xf7, 0xa2, 0x28, 0x6e, 0x26,
1745         0xef, 0x5c, 0x14, 0x01, 0x40, 0x1e, 0xa3, 0xe1,
1746         0xda, 0x76, 0xd0, 0x12, 0x84, 0xb7, 0x48, 0x7d,
1747         0xc8, 0x67, 0x5c, 0xb2, 0xd5, 0x2e, 0xaf, 0x8e,
1748         0x7d, 0x32, 0x59, 0x92, 0x01, 0xd6, 0x5b, 0x68,
1749         0x28, 0x9b, 0xb1, 0x6c, 0x69, 0xeb, 0x61, 0x5b,
1750         0x4b, 0x13, 0xe2, 0xbd, 0x7d, 0xbe, 0xce, 0xe8,
1751         0x41, 0x54, 0xca, 0xa8, 0xdd, 0xc7, 0xfe, 0x8b,
1752         0xdf, 0xf6, 0x55, 0x6c, 0x50, 0x11, 0xc8, 0x15,
1753         0x13, 0x42, 0x59, 0x9f, 0xbb, 0xea, 0x73, 0x78,
1754         0x7b, 0x22, 0x8d, 0x96, 0x62, 0xe5, 0xda, 0xa2,
1755         0x85, 0x5c, 0x20, 0x74, 0x9f, 0x1c, 0x12, 0xf2,
1756         0x48, 0x06, 0x1a, 0xc6, 0xd5, 0x94, 0xec, 0x31,
1757         0x6b, 0xb6, 0x7b, 0x54, 0x61, 0x77, 0xec, 0x7c,
1758         0x6f, 0xb7, 0x55, 0x3d, 0x6b, 0x98, 0x05, 0xd7,
1759         0x8a, 0x73, 0x25, 0xf2, 0x8f, 0xe4, 0xb8, 0x8d,
1760         0x27, 0x18, 0x0d, 0x05, 0xba, 0x23, 0x54, 0x37,
1761         0x10, 0xf0, 0x1c, 0x41, 0xa6, 0xae, 0x4c, 0x2a,
1762         0x6a, 0x2f, 0x7f, 0x68, 0x43, 0x86, 0xe7, 0x9c,
1763         0xfd, 0x9e, 0xf1, 0xfe, 0x84, 0xe3, 0xb6, 0x99,
1764         0x51, 0xfe, 0x1e, 0xbd, 0x01, 0xc6, 0x10, 0xef,
1765         0x88, 0xa4, 0xd8, 0x53, 0x14, 0x88, 0x15, 0xc9,
1766         0xe5, 0x86, 0xe2, 0x8d, 0x85, 0x2e, 0x0d, 0xec,
1767         0x15, 0xa7, 0x48, 0xfa, 0x18, 0xfb, 0x01, 0x8d,
1768         0x2b, 0x90, 0x70, 0x7f, 0x78, 0xb1, 0x33, 0x7e,
1769         0xfe, 0x82, 0x40, 0x5f, 0x4a, 0x97, 0xc2, 0x42,
1770         0x22, 0xd5, 0x5f, 0xbc, 0xbd, 0xab, 0x26, 0x98,
1771         0xcd, 0xb5, 0xdf, 0x7e, 0xa0, 0x68, 0xa7, 0x12,
1772         0x9e, 0xa5, 0xa2, 0x90, 0x85, 0xc5, 0xca, 0x73,
1773         0x4a, 0x59, 0x8a, 0xec, 0xcf, 0xdd, 0x65, 0x5d,
1774         0xc1, 0xaa, 0x86, 0x53, 0xd5, 0xde, 0xbb, 0x23,
1775         0x24, 0xb8, 0x9b, 0x74, 0x03, 0x20, 0xb4, 0xf0,
1776         0xe4, 0xdd, 0xd2, 0x03, 0xfd, 0x67, 0x55, 0x19,
1777         0x28, 0x1d, 0xc1, 0xb8, 0xa5, 0x89, 0x0e, 0xc0,
1778         0x80, 0x9d, 0xdd, 0xda, 0x9d, 0x30, 0x5c, 0xc8,
1779         0xbb, 0xfe, 0x8f, 0xce, 0xd5, 0xf6, 0xdf, 0xfa,
1780         0x14, 0xaf, 0xe4, 0xba, 0xb0, 0x84, 0x45, 0xd8,
1781         0x67, 0xa7, 0xd0, 0xce, 0x89, 0x2a, 0x30, 0x8c,
1782         0xfa, 0xe9, 0x65, 0xa4, 0x21, 0x2d, 0x6b, 0xa2,
1783         0x9b, 0x8f, 0x92, 0xbd, 0x3a, 0x10, 0x71, 0x12,
1784         0xc2, 0x02, 0x3d, 0xd5, 0x83, 0x1d, 0xfa, 0x42,
1785         0xb7, 0x48, 0x1b, 0x31, 0xe3, 0x82, 0x90, 0x2d,
1786         0x91, 0x59, 0xf9, 0x38, 0x52, 0xe5, 0xdb, 0xc1,
1787         0x4d, 0x3a, 0xe6, 0x9b, 0x6a, 0xbb, 0xea, 0xa4,
1788         0x8d, 0x5e, 0xc4, 0x00, 0x01, 0xb8, 0xec, 0x91,
1789         0xc1, 0xdb, 0x63, 0xbd, 0x57, 0xb6, 0x26, 0x15,
1790         0xb6, 0x3e, 0xa2, 0xdf, 0x62, 0x8d, 0xa8, 0xbe,
1791         0xe1, 0xf1, 0x39, 0xbd, 0x18, 0xd2, 0x6f, 0xd7,
1792         0xda, 0xdc, 0x71, 0x30, 0xf1, 0x21, 0x71, 0xa4,
1793         0x08, 0x43, 0x46, 0xdf, 0x50, 0xbd, 0x3c, 0x60,
1794         0x5b, 0x63, 0x35, 0xe3, 0x37, 0x5b, 0x25, 0x17,
1795         0x54, 0x5e, 0x68, 0x60, 0xb6, 0x49, 0xef, 0x6e,
1796         0x09, 0xef, 0xda, 0x90, 0x3e, 0xd4, 0x09, 0x33,
1797         0x36, 0x57, 0x9a, 0x14, 0xbd, 0xf7, 0xb1, 0x98,
1798         0x30, 0x42, 0x03, 0x84, 0x61, 0xeb, 0x8e, 0x50,
1799         0xdc, 0x6a, 0x93, 0x1b, 0x32, 0x51, 0xf9, 0xc6,
1800         0xc2, 0x19, 0xb3, 0x5d, 0xe2, 0xf8, 0xc5, 0x8f,
1801         0x68, 0xaa, 0x1d, 0xdb, 0xd3, 0x7f, 0x8d, 0x98,
1802         0x9c, 0x16, 0x8c, 0xc3, 0xcd, 0xd9, 0xdb, 0x08,
1803         0xe6, 0x36, 0x60, 0xb6, 0x36, 0xdc, 0x1d, 0x59,
1804         0xb6, 0x5f, 0x01, 0x5e
1805     };
1806
1807     dwLen=84;
1808     result = CryptImportKey(hProv, abPlainPublicKey, dwLen, 0, 0, &hPublicKey);
1809     ok(result, "failed to import the public key\n");
1810
1811     dwDataLen=sizeof(algID);
1812     result = CryptGetKeyParam(hPublicKey, KP_ALGID, (LPBYTE)&algID, &dwDataLen, 0);
1813     ok(result, "failed to get the KP_ALGID from the imported public key\n");
1814     ok(algID == CALG_RSA_KEYX, "Expected CALG_RSA_KEYX, got %x\n", algID);
1815
1816     dwVal = 0xdeadbeef;
1817     dwDataLen = sizeof(DWORD);
1818     result = CryptGetKeyParam(hPublicKey, KP_PERMISSIONS, (BYTE*)&dwVal, &dwDataLen, 0);
1819     ok(result, "%08x\n", GetLastError());
1820     ok(dwVal ==
1821         (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT) ||
1822         broken(dwVal == 0xffffffff), /* Win9x/NT4 */
1823         "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT,"
1824         " got %08x\n", dwVal);
1825     result = CryptExportKey(hPublicKey, 0, PUBLICKEYBLOB, 0, emptyKey, &dwLen);
1826     ok(result, "failed to export the fresh imported public key\n");
1827     ok(dwLen == 84, "Expected exported key to be 84 bytes long but got %d bytes.\n",dwLen);
1828     ok(!memcmp(emptyKey, abPlainPublicKey, dwLen), "exported key is different from the imported key\n");
1829
1830     CryptDestroyKey(hPublicKey);
1831
1832     result = CryptImportKey(hProv, priv_key_with_high_bit,
1833         sizeof(priv_key_with_high_bit), 0, CRYPT_EXPORTABLE, &hPrivKey);
1834     ok(result, "CryptImportKey failed: %08x\n", GetLastError());
1835
1836     result = CryptExportKey(hPrivKey, 0, PRIVATEKEYBLOB, 0, NULL, &dwDataLen);
1837     ok(result, "CryptExportKey failed: %08x\n", GetLastError());
1838     exported_key = HeapAlloc(GetProcessHeap(), 0, dwDataLen);
1839     result = CryptExportKey(hPrivKey, 0, PRIVATEKEYBLOB, 0, exported_key,
1840         &dwDataLen);
1841     ok(result, "CryptExportKey failed: %08x\n", GetLastError());
1842
1843     ok(dwDataLen == sizeof(expected_exported_priv_key), "unexpected size %d\n",
1844         dwDataLen);
1845     ok(!memcmp(exported_key, expected_exported_priv_key, dwDataLen),
1846         "unexpected value\n");
1847
1848     HeapFree(GetProcessHeap(), 0, exported_key);
1849
1850     CryptDestroyKey(hPrivKey);
1851 }
1852
1853 static void test_schannel_provider(void)
1854 {
1855     HCRYPTPROV hProv;
1856     HCRYPTKEY hRSAKey, hMasterSecret, hServerWriteKey, hServerWriteMACKey;
1857     HCRYPTHASH hMasterHash, hTLS1PRF, hHMAC;
1858     BOOL result;
1859     DWORD dwLen;
1860     SCHANNEL_ALG saSChannelAlg;
1861     CRYPT_DATA_BLOB data_blob;
1862     HMAC_INFO hmacInfo = { CALG_MD5, NULL, 0, NULL, 0 };
1863     BYTE abTLS1Master[140] = {
1864         0x01, 0x02, 0x00, 0x00, 0x06, 0x4c, 0x00, 0x00,
1865         0x00, 0xa4, 0x00, 0x00, 0x5b, 0x13, 0xc7, 0x68,
1866         0xd8, 0x55, 0x23, 0x5d, 0xbc, 0xa6, 0x9d, 0x97,
1867         0x0e, 0xcd, 0x6b, 0xcf, 0xc0, 0xdc, 0xc5, 0x53,
1868         0x28, 0xa0, 0xca, 0xc1, 0x63, 0x4e, 0x3a, 0x24,
1869         0x22, 0xe5, 0x4d, 0x15, 0xbb, 0xa5, 0x06, 0xc3,
1870         0x98, 0x25, 0xdc, 0x35, 0xd3, 0xdb, 0xab, 0xb8,
1871         0x44, 0x1b, 0xfe, 0x63, 0x88, 0x7c, 0x2e, 0x6d,
1872         0x34, 0xd9, 0x0f, 0x7e, 0x2f, 0xc2, 0xb2, 0x6e,
1873         0x56, 0xfa, 0xab, 0xb2, 0x88, 0xf6, 0x15, 0x6e,
1874         0xa8, 0xcd, 0x70, 0x16, 0x94, 0x61, 0x07, 0x40,
1875         0x9e, 0x25, 0x22, 0xf8, 0x64, 0x9f, 0xcc, 0x0b,
1876         0xf1, 0x92, 0x4d, 0xfe, 0xc3, 0x5d, 0x52, 0xdb,
1877         0x0f, 0xff, 0x12, 0x0f, 0x49, 0x43, 0x7d, 0xc6,
1878         0x52, 0x61, 0xb0, 0x06, 0xc8, 0x1b, 0x90, 0xac,
1879         0x09, 0x7e, 0x4b, 0x95, 0x69, 0x3b, 0x0d, 0x41,
1880         0x1b, 0x4c, 0x65, 0x75, 0x4d, 0x85, 0x16, 0xc4,
1881         0xd3, 0x1e, 0x82, 0xb3
1882     };
1883     BYTE abServerSecret[33] = "Super Secret Server Secret 12345";
1884     BYTE abClientSecret[33] = "Super Secret Client Secret 12345";
1885     BYTE abHashedHandshakes[37] = "123456789012345678901234567890123456";
1886     BYTE abClientFinished[16] = "client finished";
1887     BYTE abData[16] = "Wine rocks!";
1888     BYTE abMD5Hash[16];
1889     static const BYTE abEncryptedData[16] = {
1890         0x13, 0xd2, 0xdd, 0xeb, 0x6c, 0x3f, 0xbe, 0xb2,
1891         0x04, 0x86, 0xb5, 0xe5, 0x08, 0xe5, 0xf3, 0x0d
1892     };
1893     static const BYTE abPRF[16] = {
1894         0xa8, 0xb2, 0xa6, 0xef, 0x83, 0x4e, 0x74, 0xb1,
1895         0xf3, 0xb1, 0x51, 0x5a, 0x1a, 0x2b, 0x11, 0x31
1896     };
1897     static const BYTE abMD5[16] = {
1898         0xe1, 0x65, 0x3f, 0xdb, 0xbb, 0x3d, 0x99, 0x3c,
1899         0x3d, 0xca, 0x6a, 0x6f, 0xfa, 0x15, 0x4e, 0xaa
1900     };
1901
1902     result = CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT|CRYPT_NEWKEYSET);
1903     if (!result)
1904     {
1905         win_skip("no PROV_RSA_SCHANNEL support\n");
1906         return;
1907     }
1908     ok (result, "%08x\n", GetLastError());
1909     if (result)
1910         CryptReleaseContext(hProv, 0);
1911
1912     result = CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT);
1913     ok (result, "%08x\n", GetLastError());
1914     if (!result) return;
1915
1916     /* To get deterministic results, we import the TLS1 master secret (which
1917      * is typically generated from a random generator). Therefore, we need
1918      * an RSA key. */
1919     dwLen = (DWORD)sizeof(abPlainPrivateKey);
1920     result = CryptImportKey(hProv, abPlainPrivateKey, dwLen, 0, 0, &hRSAKey);
1921     ok (result, "%08x\n", GetLastError());
1922     if (!result) return;
1923
1924     dwLen = (DWORD)sizeof(abTLS1Master);
1925     result = CryptImportKey(hProv, abTLS1Master, dwLen, hRSAKey, 0, &hMasterSecret);
1926     ok (result, "%08x\n", GetLastError());
1927     if (!result) return;
1928
1929     /* Setting the TLS1 client and server random parameters, as well as the
1930      * MAC and encryption algorithm parameters. */
1931     data_blob.cbData = 33;
1932     data_blob.pbData = abClientSecret;
1933     result = CryptSetKeyParam(hMasterSecret, KP_CLIENT_RANDOM, (BYTE*)&data_blob, 0);
1934     ok (result, "%08x\n", GetLastError());
1935     if (!result) return;
1936
1937     data_blob.cbData = 33;
1938     data_blob.pbData = abServerSecret;
1939     result = CryptSetKeyParam(hMasterSecret, KP_SERVER_RANDOM, (BYTE*)&data_blob, 0);
1940     ok (result, "%08x\n", GetLastError());
1941     if (!result) return;
1942
1943     saSChannelAlg.dwUse = SCHANNEL_ENC_KEY;
1944     saSChannelAlg.Algid = CALG_DES;
1945     saSChannelAlg.cBits = 64;
1946     saSChannelAlg.dwFlags = 0;
1947     saSChannelAlg.dwReserved = 0;
1948     result = CryptSetKeyParam(hMasterSecret, KP_SCHANNEL_ALG, (PBYTE)&saSChannelAlg, 0);
1949     ok (result, "%08x\n", GetLastError());
1950     if (!result) return;
1951
1952     saSChannelAlg.dwUse = SCHANNEL_MAC_KEY;
1953     saSChannelAlg.Algid = CALG_MD5;
1954     saSChannelAlg.cBits = 128;
1955     saSChannelAlg.dwFlags = 0;
1956     saSChannelAlg.dwReserved = 0;
1957     result = CryptSetKeyParam(hMasterSecret, KP_SCHANNEL_ALG, (PBYTE)&saSChannelAlg, 0);
1958     ok (result, "%08x\n", GetLastError());
1959     if (!result) return;
1960
1961     /* Deriving a hash from the master secret. This is due to the CryptoAPI architecture.
1962      * (Keys can only be derived from hashes, not from other keys.) */
1963     result = CryptCreateHash(hProv, CALG_SCHANNEL_MASTER_HASH, hMasterSecret, 0, &hMasterHash);
1964     ok (result, "%08x\n", GetLastError());
1965     if (!result) return;
1966
1967     /* Deriving the server write encryption key from the master hash */
1968     result = CryptDeriveKey(hProv, CALG_SCHANNEL_ENC_KEY, hMasterHash, CRYPT_SERVER, &hServerWriteKey);
1969     ok (result, "%08x\n", GetLastError());
1970     if (!result) return;
1971
1972     /* Encrypting some data with the server write encryption key and checking the result. */
1973     dwLen = 12;
1974     result = CryptEncrypt(hServerWriteKey, 0, TRUE, 0, abData, &dwLen, 16);
1975     ok (result && (dwLen == 16) && !memcmp(abData, abEncryptedData, 16), "%08x\n", GetLastError());
1976
1977     /* Second test case: Test the TLS1 pseudo random number function. */
1978     result = CryptCreateHash(hProv, CALG_TLS1PRF, hMasterSecret, 0, &hTLS1PRF);
1979     ok (result, "%08x\n", GetLastError());
1980     if (!result) return;
1981
1982     /* Set the label and seed parameters for the random number function */
1983     data_blob.cbData = 36;
1984     data_blob.pbData = abHashedHandshakes;
1985     result = CryptSetHashParam(hTLS1PRF, HP_TLS1PRF_SEED, (BYTE*)&data_blob, 0);
1986     ok (result, "%08x\n", GetLastError());
1987     if (!result) return;
1988
1989     data_blob.cbData = 15;
1990     data_blob.pbData = abClientFinished;
1991     result = CryptSetHashParam(hTLS1PRF, HP_TLS1PRF_LABEL, (BYTE*)&data_blob, 0);
1992     ok (result, "%08x\n", GetLastError());
1993     if (!result) return;
1994
1995     /* Generate some pseudo random bytes and check if they are correct. */
1996     dwLen = (DWORD)sizeof(abData);
1997     result = CryptGetHashParam(hTLS1PRF, HP_HASHVAL, abData, &dwLen, 0);
1998     ok (result && (dwLen==(DWORD)sizeof(abData)) && !memcmp(abData, abPRF, sizeof(abData)),
1999         "%08x\n", GetLastError());
2000
2001     /* Third test case. Derive the server write mac key. Derive an HMAC object from this one.
2002      * Hash some data with the HMAC. Compare results. */
2003     result = CryptDeriveKey(hProv, CALG_SCHANNEL_MAC_KEY, hMasterHash, CRYPT_SERVER, &hServerWriteMACKey);
2004     ok (result, "%08x\n", GetLastError());
2005     if (!result) return;
2006
2007     result = CryptCreateHash(hProv, CALG_HMAC, hServerWriteMACKey, 0, &hHMAC);
2008     ok (result, "%08x\n", GetLastError());
2009     if (!result) return;
2010
2011     result = CryptSetHashParam(hHMAC, HP_HMAC_INFO, (PBYTE)&hmacInfo, 0);
2012     ok (result, "%08x\n", GetLastError());
2013     if (!result) return;
2014
2015     result = CryptHashData(hHMAC, abData, (DWORD)sizeof(abData), 0);
2016     ok (result, "%08x\n", GetLastError());
2017     if (!result) return;
2018
2019     dwLen = (DWORD)sizeof(abMD5Hash);
2020     result = CryptGetHashParam(hHMAC, HP_HASHVAL, abMD5Hash, &dwLen, 0);
2021     ok (result && (dwLen == 16) && !memcmp(abMD5Hash, abMD5, 16), "%08x\n", GetLastError());
2022
2023     CryptDestroyHash(hHMAC);
2024     CryptDestroyHash(hTLS1PRF);
2025     CryptDestroyHash(hMasterHash);
2026     CryptDestroyKey(hServerWriteMACKey);
2027     CryptDestroyKey(hServerWriteKey);
2028     CryptDestroyKey(hRSAKey);
2029     CryptDestroyKey(hMasterSecret);
2030     CryptReleaseContext(hProv, 0);
2031     CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_DELETEKEYSET);
2032 }
2033
2034 /* Test that a key can be used to encrypt data and exported, and that, when
2035  * the exported key is imported again, can be used to decrypt the original
2036  * data again.
2037  */
2038 static void test_rsa_round_trip(void)
2039 {
2040     static const char test_string[] = "Well this is a fine how-do-you-do.";
2041     HCRYPTPROV prov;
2042     HCRYPTKEY signKey, keyExchangeKey;
2043     BOOL result;
2044     BYTE data[256], *exportedKey;
2045     DWORD dataLen, keyLen;
2046
2047     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2048      CRYPT_DELETEKEYSET);
2049
2050     /* Generate a new key... */
2051     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2052      CRYPT_NEWKEYSET);
2053     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
2054     result = CryptGenKey(prov, CALG_RSA_KEYX, CRYPT_EXPORTABLE, &signKey);
2055     ok(result, "CryptGenKey with CALG_RSA_KEYX failed with error %08x\n", GetLastError());
2056     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &keyExchangeKey);
2057     ok(result, "CryptGetUserKey failed: %08x\n", GetLastError());
2058     /* encrypt some data with it... */
2059     memcpy(data, test_string, strlen(test_string) + 1);
2060     dataLen = strlen(test_string) + 1;
2061     result = CryptEncrypt(keyExchangeKey, 0, TRUE, 0, data, &dataLen,
2062                           sizeof(data));
2063     ok(result || broken(GetLastError() == NTE_BAD_KEY /* Win9x/2000 */),
2064        "CryptEncrypt failed: %08x\n", GetLastError());
2065     /* export the key... */
2066     result = CryptExportKey(keyExchangeKey, 0, PRIVATEKEYBLOB, 0, NULL,
2067                             &keyLen);
2068     ok(result, "CryptExportKey failed: %08x\n", GetLastError());
2069     exportedKey = HeapAlloc(GetProcessHeap(), 0, keyLen);
2070     result = CryptExportKey(keyExchangeKey, 0, PRIVATEKEYBLOB, 0, exportedKey,
2071                             &keyLen);
2072     /* destroy the key... */
2073     CryptDestroyKey(keyExchangeKey);
2074     CryptDestroyKey(signKey);
2075     /* import the key again... */
2076     result = CryptImportKey(prov, exportedKey, keyLen, 0, 0, &keyExchangeKey);
2077     ok(result, "CryptImportKey failed: %08x\n", GetLastError());
2078     HeapFree(GetProcessHeap(), 0, exportedKey);
2079     /* and decrypt the data encrypted with the original key with the imported
2080      * key.
2081      */
2082     result = CryptDecrypt(keyExchangeKey, 0, TRUE, 0, data, &dataLen);
2083     ok(result || broken(GetLastError() == NTE_BAD_KEY /* Win9x/2000 */),
2084        "CryptDecrypt failed: %08x\n", GetLastError());
2085     if (result)
2086     {
2087         ok(dataLen == sizeof(test_string), "unexpected size %d\n", dataLen);
2088         ok(!memcmp(data, test_string, sizeof(test_string)), "unexpected value\n");
2089     }
2090     CryptReleaseContext(prov, 0);
2091
2092     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2093      CRYPT_DELETEKEYSET);
2094 }
2095
2096 static void test_enum_container(void)
2097 {
2098     BYTE abContainerName[MAX_PATH + 2]; /* Larger than maximum name len */
2099     DWORD dwBufferLen;
2100     BOOL result, fFound = FALSE;
2101
2102     /* If PP_ENUMCONTAINERS is queried with CRYPT_FIRST and abData == NULL, it returns
2103      * the maximum legal length of container names (which is MAX_PATH + 1 == 261) */
2104     SetLastError(0xdeadbeef);
2105     result = CryptGetProvParam(hProv, PP_ENUMCONTAINERS, NULL, &dwBufferLen, CRYPT_FIRST);
2106     ok (result, "%08x\n", GetLastError());
2107     ok (dwBufferLen == MAX_PATH + 1 ||
2108         broken(dwBufferLen != MAX_PATH + 1), /* Win9x, WinMe, NT4 */
2109         "Expected dwBufferLen to be (MAX_PATH + 1), it was : %d\n", dwBufferLen);
2110
2111     /* If the result fits into abContainerName dwBufferLen is left untouched */
2112     dwBufferLen = (DWORD)sizeof(abContainerName);
2113     result = CryptGetProvParam(hProv, PP_ENUMCONTAINERS, abContainerName, &dwBufferLen, CRYPT_FIRST);
2114     ok (result && dwBufferLen == (DWORD)sizeof(abContainerName), "%08x\n", GetLastError());
2115
2116     /* We only check, if the currently open 'winetest' container is among the enumerated. */
2117     do {
2118         if (!strcmp((const char*)abContainerName, "winetest")) fFound = TRUE;
2119         dwBufferLen = (DWORD)sizeof(abContainerName);
2120     } while (CryptGetProvParam(hProv, PP_ENUMCONTAINERS, abContainerName, &dwBufferLen, 0));
2121
2122     ok (fFound && GetLastError() == ERROR_NO_MORE_ITEMS, "%d, %08x\n", fFound, GetLastError());
2123 }
2124
2125 static BYTE signBlob[] = {
2126 0x07,0x02,0x00,0x00,0x00,0x24,0x00,0x00,0x52,0x53,0x41,0x32,0x00,0x02,0x00,0x00,
2127 0x01,0x00,0x01,0x00,0xf1,0x82,0x9e,0x84,0xb5,0x79,0x9a,0xbe,0x4d,0x06,0x20,0x21,
2128 0xb1,0x89,0x0c,0xca,0xb0,0x35,0x72,0x18,0xc6,0x92,0xa8,0xe2,0xb1,0xe1,0xf6,0x56,
2129 0x53,0x99,0x47,0x10,0x6e,0x1c,0x81,0xaf,0xb8,0xf9,0x5f,0xfe,0x76,0x7f,0x2c,0x93,
2130 0xec,0x54,0x7e,0x5e,0xc2,0x25,0x3c,0x50,0x56,0x10,0x20,0x72,0x4a,0x93,0x03,0x12,
2131 0x29,0x98,0xcc,0xc9,0x47,0xbf,0xbf,0x93,0xcc,0xb0,0xe5,0x53,0x14,0xc8,0x7e,0x1f,
2132 0xa4,0x03,0x2d,0x8e,0x84,0x7a,0xd2,0xeb,0xf7,0x92,0x5e,0xa2,0xc7,0x6b,0x35,0x7d,
2133 0xcb,0x60,0xae,0xfb,0x07,0x78,0x11,0x73,0xb5,0x79,0xe5,0x7e,0x96,0xe3,0x50,0x95,
2134 0x80,0x0e,0x1c,0xf6,0x56,0xc6,0xe9,0x0a,0xaf,0x03,0xc6,0xdc,0x9a,0x81,0xcf,0x7a,
2135 0x63,0x16,0x43,0xcd,0xab,0x74,0xa1,0x7d,0xe7,0xe0,0x75,0x6d,0xbd,0x19,0xae,0x0b,
2136 0xa3,0x7f,0x6a,0x7b,0x05,0x4e,0xbc,0xec,0x18,0xfc,0x19,0xc2,0x00,0xf0,0x6a,0x2e,
2137 0xc4,0x31,0x73,0xba,0x07,0xcc,0x9d,0x57,0xeb,0xc7,0x7c,0x00,0x7d,0x5d,0x11,0x16,
2138 0x42,0x4b,0xe5,0x3a,0xf5,0xc7,0xf8,0xee,0xc3,0x2c,0x0d,0x86,0x03,0xe2,0xaf,0xb2,
2139 0xd2,0x91,0xdb,0x71,0xcd,0xdf,0x81,0x5f,0x06,0xfc,0x48,0x0d,0xb6,0x88,0x9f,0xc1,
2140 0x5e,0x24,0xa2,0x05,0x4f,0x30,0x2e,0x8f,0x8b,0x0d,0x76,0xa1,0x84,0xda,0x7b,0x44,
2141 0x70,0x85,0xf1,0x50,0xb1,0x21,0x3d,0xe2,0x57,0x3d,0xd0,0x01,0x93,0x49,0x8e,0xc5,
2142 0x0b,0x8b,0x0d,0x7b,0x08,0xe9,0x14,0xec,0x20,0x0d,0xea,0x02,0x00,0x63,0xe8,0x0a,
2143 0x52,0xe8,0xfb,0x21,0xbd,0x37,0xde,0x4c,0x4d,0xc2,0xf6,0xb9,0x0d,0x2a,0xc3,0xe2,
2144 0xc9,0xdf,0x48,0x3e,0x55,0x3d,0xe3,0xc0,0x22,0x37,0xf9,0x52,0xc0,0xd7,0x61,0x22,
2145 0xb6,0x85,0x86,0x07 };
2146
2147 static void test_null_provider(void)
2148 {
2149     HCRYPTPROV prov;
2150     HCRYPTKEY key;
2151     BOOL result;
2152     DWORD keySpec, dataLen,dwParam;
2153     char szName[MAX_PATH];
2154
2155     result = CryptAcquireContext(NULL, szContainer, NULL, 0, 0);
2156     ok(!result && GetLastError() == NTE_BAD_PROV_TYPE,
2157      "Expected NTE_BAD_PROV_TYPE, got %08x\n", GetLastError());
2158     result = CryptAcquireContext(NULL, szContainer, NULL, PROV_RSA_FULL, 0);
2159     ok(!result && (GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == NTE_BAD_KEYSET),
2160      "Expected ERROR_INVALID_PARAMETER or NTE_BAD_KEYSET, got %08x\n", GetLastError());
2161     result = CryptAcquireContext(NULL, szContainer, NULL, PROV_RSA_FULL,
2162      CRYPT_DELETEKEYSET);
2163     ok(!result && ( GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == NTE_BAD_KEYSET),
2164      "Expected ERROR_INVALID_PARAMETER or NTE_BAD_KEYSET, got %08x\n", GetLastError());
2165     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2166      CRYPT_DELETEKEYSET);
2167     ok(!result && GetLastError() == NTE_BAD_KEYSET,
2168      "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
2169     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL, 0);
2170     ok(!result && GetLastError() == NTE_BAD_KEYSET,
2171      "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
2172
2173     /* Delete the default container. */
2174     CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
2175     /* Once you've deleted the default container you can't open it as if it
2176      * already exists.
2177      */
2178     result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, 0);
2179     ok(!result && GetLastError() == NTE_BAD_KEYSET,
2180      "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
2181     /* But you can always open the default container for CRYPT_VERIFYCONTEXT. */
2182     result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL,
2183      CRYPT_VERIFYCONTEXT);
2184     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
2185     if (!result) return;
2186     dataLen = sizeof(keySpec);
2187     result = CryptGetProvParam(prov, PP_KEYSPEC, (LPBYTE)&keySpec, &dataLen, 0);
2188     if (result)
2189         ok(keySpec == (AT_KEYEXCHANGE | AT_SIGNATURE),
2190          "Expected AT_KEYEXCHANGE | AT_SIGNATURE, got %08x\n", keySpec);
2191     /* Even though PP_KEYSPEC says both AT_KEYEXCHANGE and AT_SIGNATURE are
2192      * supported, you can't get the keys from this container.
2193      */
2194     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
2195     ok(!result && GetLastError() == NTE_NO_KEY,
2196      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
2197     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
2198     ok(!result && GetLastError() == NTE_NO_KEY,
2199      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
2200     result = CryptReleaseContext(prov, 0);
2201     ok(result, "CryptReleaseContext failed: %08x\n", GetLastError());
2202     /* You can create a new default container. */
2203     result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL,
2204      CRYPT_NEWKEYSET);
2205     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
2206     /* But you still can't get the keys (until one's been generated.) */
2207     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
2208     ok(!result && GetLastError() == NTE_NO_KEY,
2209      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
2210     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
2211     ok(!result && GetLastError() == NTE_NO_KEY,
2212      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
2213     CryptReleaseContext(prov, 0);
2214     CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
2215
2216     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2217      CRYPT_DELETEKEYSET);
2218     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL, 0);
2219     ok(!result && GetLastError() == NTE_BAD_KEYSET,
2220      "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
2221     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2222      CRYPT_VERIFYCONTEXT);
2223     ok(!result && GetLastError() == NTE_BAD_FLAGS,
2224      "Expected NTE_BAD_FLAGS, got %08x\n", GetLastError());
2225     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2226      CRYPT_NEWKEYSET);
2227     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
2228     if (!result) return;
2229     /* Test provider parameters getter */
2230     dataLen = sizeof(dwParam);
2231     result = CryptGetProvParam(prov, PP_PROVTYPE, (LPBYTE)&dwParam, &dataLen, 0);
2232     ok(result && dataLen == sizeof(dwParam) && dwParam == PROV_RSA_FULL,
2233         "Expected PROV_RSA_FULL, got 0x%08X\n",dwParam);
2234     dataLen = sizeof(dwParam);
2235     result = CryptGetProvParam(prov, PP_KEYSET_TYPE, (LPBYTE)&dwParam, &dataLen, 0);
2236     ok(result && dataLen == sizeof(dwParam) && dwParam == 0,
2237         "Expected 0, got 0x%08X\n",dwParam);
2238     dataLen = sizeof(dwParam);
2239     result = CryptGetProvParam(prov, PP_KEYSTORAGE, (LPBYTE)&dwParam, &dataLen, 0);
2240     ok(result && dataLen == sizeof(dwParam) && (dwParam & CRYPT_SEC_DESCR),
2241         "Expected CRYPT_SEC_DESCR to be set, got 0x%08X\n",dwParam);
2242     dataLen = sizeof(keySpec);
2243     SetLastError(0xdeadbeef);
2244     result = CryptGetProvParam(prov, PP_KEYSPEC, (LPBYTE)&keySpec, &dataLen, 0);
2245     if (!result && GetLastError() == NTE_BAD_TYPE)
2246         skip("PP_KEYSPEC is not supported (win9x or NT)\n");
2247     else
2248         ok(result && keySpec == (AT_KEYEXCHANGE | AT_SIGNATURE),
2249             "Expected AT_KEYEXCHANGE | AT_SIGNATURE, got %08x\n", keySpec);
2250     /* PP_CONTAINER parameter */
2251     dataLen = sizeof(szName);
2252     result = CryptGetProvParam(prov, PP_CONTAINER, (LPBYTE)szName, &dataLen, 0);
2253     ok(result && dataLen == strlen(szContainer)+1 && strcmp(szContainer,szName) == 0,
2254         "failed getting PP_CONTAINER. result = %s. Error 0x%08X. returned length = %d\n",
2255         (result)? "TRUE":"FALSE",GetLastError(),dataLen);
2256     /* PP_UNIQUE_CONTAINER parameter */
2257     dataLen = sizeof(szName);
2258     SetLastError(0xdeadbeef);
2259     result = CryptGetProvParam(prov, PP_UNIQUE_CONTAINER, (LPBYTE)szName, &dataLen, 0);
2260     if (!result && GetLastError() == NTE_BAD_TYPE)
2261     {
2262         skip("PP_UNIQUE_CONTAINER is not supported (win9x or NT)\n");
2263     }
2264     else
2265     {
2266         char container[MAX_PATH];
2267
2268         ok(result, "failed getting PP_UNIQUE_CONTAINER : 0x%08X\n", GetLastError());
2269         uniquecontainer(container);
2270         todo_wine
2271         {
2272             ok(dataLen == strlen(container)+1 ||
2273                broken(dataLen == strlen(szContainer)+1) /* WinME */,
2274                "Expected a param length of 70, got %d\n", dataLen);
2275             ok(!strcmp(container, szName) ||
2276                broken(!strcmp(szName, szContainer)) /* WinME */,
2277                "Wrong container name : %s\n", szName);
2278         }
2279     }
2280     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
2281     ok(!result && GetLastError() == NTE_NO_KEY,
2282      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
2283     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
2284     ok(!result && GetLastError() == NTE_NO_KEY,
2285      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
2286
2287     /* Importing a key exchange blob.. */
2288     result = CryptImportKey(prov, abPlainPrivateKey, sizeof(abPlainPrivateKey),
2289      0, 0, &key);
2290     ok(result, "CryptImportKey failed: %08x\n", GetLastError());
2291     CryptDestroyKey(key);
2292     /* allows access to the key exchange key.. */
2293     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
2294     ok(result, "CryptGetUserKey failed: %08x\n", GetLastError());
2295     CryptDestroyKey(key);
2296     /* but not to the private key. */
2297     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
2298     ok(!result && GetLastError() == NTE_NO_KEY,
2299      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
2300     CryptReleaseContext(prov, 0);
2301     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2302      CRYPT_DELETEKEYSET);
2303
2304     /* Whereas importing a sign blob.. */
2305     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2306      CRYPT_NEWKEYSET);
2307     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
2308     if (!result) return;
2309     result = CryptImportKey(prov, signBlob, sizeof(signBlob), 0, 0, &key);
2310     ok(result, "CryptImportKey failed: %08x\n", GetLastError());
2311     CryptDestroyKey(key);
2312     /* doesn't allow access to the key exchange key.. */
2313     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
2314     ok(!result && GetLastError() == NTE_NO_KEY,
2315      "Expected NTE_NO_KEY, got %08x\n", GetLastError());
2316     /* but does to the private key. */
2317     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
2318     ok(result, "CryptGetUserKey failed: %08x\n", GetLastError());
2319     CryptDestroyKey(key);
2320     CryptReleaseContext(prov, 0);
2321
2322     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2323      CRYPT_DELETEKEYSET);
2324
2325     /* Test for being able to get a key generated with CALG_RSA_SIGN. */
2326     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2327      CRYPT_NEWKEYSET);
2328     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
2329     result = CryptGenKey(prov, CALG_RSA_SIGN, 0, &key);
2330     ok(result, "CryptGenKey with CALG_RSA_SIGN failed with error %08x\n", GetLastError());
2331     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
2332     ok(!result, "expected CryptGetUserKey to fail\n");
2333     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
2334     ok(result, "CryptGetUserKey with AT_SIGNATURE failed: %08x\n", GetLastError());
2335     CryptDestroyKey(key);
2336     CryptReleaseContext(prov, 0);
2337
2338     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2339      CRYPT_DELETEKEYSET);
2340
2341     /* Test for being able to get a key generated with CALG_RSA_KEYX. */
2342     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2343      CRYPT_NEWKEYSET);
2344     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
2345     result = CryptGenKey(prov, CALG_RSA_KEYX, 0, &key);
2346     ok(result, "CryptGenKey with CALG_RSA_KEYX failed with error %08x\n", GetLastError());
2347     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
2348     ok(result, "CryptGetUserKey with AT_KEYEXCHANGE failed: %08x\n", GetLastError());
2349     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
2350     ok(!result, "expected CryptGetUserKey to fail\n");
2351     CryptDestroyKey(key);
2352     CryptReleaseContext(prov, 0);
2353
2354     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2355      CRYPT_DELETEKEYSET);
2356
2357     /* test for the bug in accessing the user key in a container
2358      */
2359     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2360      CRYPT_NEWKEYSET);
2361     ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
2362     result = CryptGenKey(prov, AT_KEYEXCHANGE, 0, &key);
2363     ok(result, "CryptGenKey with AT_KEYEXCHANGE failed with error %08x\n", GetLastError());
2364     CryptDestroyKey(key);
2365     CryptReleaseContext(prov,0);
2366     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,0);
2367     ok(result, "CryptAcquireContext failed: 0x%08x\n", GetLastError());
2368     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
2369     ok (result, "CryptGetUserKey failed with error %08x\n", GetLastError());
2370     CryptDestroyKey(key);
2371     CryptReleaseContext(prov, 0);
2372
2373     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2374      CRYPT_DELETEKEYSET);
2375
2376     /* test the machine key set */
2377     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2378      CRYPT_DELETEKEYSET|CRYPT_MACHINE_KEYSET);
2379     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2380      CRYPT_NEWKEYSET|CRYPT_MACHINE_KEYSET);
2381     ok(result, "CryptAcquireContext with CRYPT_MACHINE_KEYSET failed: %08x\n", GetLastError());
2382     CryptReleaseContext(prov, 0);
2383     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2384      CRYPT_MACHINE_KEYSET);
2385     ok(result, "CryptAcquireContext with CRYPT_MACHINE_KEYSET failed: %08x\n", GetLastError());
2386     CryptReleaseContext(prov,0);
2387     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2388        CRYPT_DELETEKEYSET|CRYPT_MACHINE_KEYSET);
2389     ok(result, "CryptAcquireContext with CRYPT_DELETEKEYSET|CRYPT_MACHINE_KEYSET failed: %08x\n",
2390                 GetLastError());
2391     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
2392      CRYPT_MACHINE_KEYSET);
2393     ok(!result && GetLastError() == NTE_BAD_KEYSET ,
2394         "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
2395
2396 }
2397
2398 static void test_key_permissions(void)
2399 {
2400     HCRYPTKEY hKey1, hKey2;
2401     DWORD dwVal, dwLen;
2402     BOOL result;
2403
2404     /* Create keys that are exportable */
2405     if (!init_base_environment(CRYPT_EXPORTABLE))
2406         return;
2407
2408     result = CryptGetUserKey(hProv, AT_KEYEXCHANGE, &hKey1);
2409     ok (result, "%08x\n", GetLastError());
2410     if (!result) return;
2411
2412     dwVal = 0xdeadbeef;
2413     dwLen = sizeof(DWORD);
2414     result = CryptGetKeyParam(hKey1, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0);
2415     ok(result, "%08x\n", GetLastError());
2416     ok(dwVal ==
2417         (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT) ||
2418         broken(dwVal == 0xffffffff), /* Win9x/NT4 */
2419         "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT,"
2420         " got %08x\n", dwVal);
2421
2422     /* The key exchange key's public key may be exported.. */
2423     result = CryptExportKey(hKey1, 0, PUBLICKEYBLOB, 0, NULL, &dwLen);
2424     ok(result, "%08x\n", GetLastError());
2425     /* and its private key may be too. */
2426     result = CryptExportKey(hKey1, 0, PRIVATEKEYBLOB, 0, NULL, &dwLen);
2427     ok(result, "%08x\n", GetLastError());
2428     /* Turning off the key's export permissions is "allowed".. */
2429     dwVal &= ~CRYPT_EXPORT;
2430     result = CryptSetKeyParam(hKey1, KP_PERMISSIONS, (BYTE *)&dwVal, 0);
2431     ok(result ||
2432         broken(!result && GetLastError() == NTE_BAD_DATA) || /* W2K */
2433         broken(!result && GetLastError() == NTE_BAD_FLAGS), /* Win9x/WinME/NT4 */
2434         "%08x\n", GetLastError());
2435     /* but it has no effect. */
2436     dwVal = 0xdeadbeef;
2437     dwLen = sizeof(DWORD);
2438     result = CryptGetKeyParam(hKey1, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0);
2439     ok(result, "%08x\n", GetLastError());
2440     ok(dwVal ==
2441         (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT) ||
2442         broken(dwVal == 0xffffffff), /* Win9x/NT4 */
2443         "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT,"
2444         " got %08x\n", dwVal);
2445     /* Thus, changing the export flag of the key doesn't affect whether the key
2446      * may be exported.
2447      */
2448     result = CryptExportKey(hKey1, 0, PRIVATEKEYBLOB, 0, NULL, &dwLen);
2449     ok(result, "%08x\n", GetLastError());
2450
2451     result = CryptGetUserKey(hProv, AT_KEYEXCHANGE, &hKey2);
2452     ok (result, "%08x\n", GetLastError());
2453
2454     /* A subsequent get of the same key, into a different handle, also doesn't
2455      * show that the permissions have been changed.
2456      */
2457     dwVal = 0xdeadbeef;
2458     dwLen = sizeof(DWORD);
2459     result = CryptGetKeyParam(hKey2, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0);
2460     ok(result, "%08x\n", GetLastError());
2461     ok(dwVal ==
2462         (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT) ||
2463         broken(dwVal == 0xffffffff), /* Win9x/NT4 */
2464         "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT,"
2465         " got %08x\n", dwVal);
2466
2467     CryptDestroyKey(hKey2);
2468     CryptDestroyKey(hKey1);
2469
2470     clean_up_base_environment();
2471 }
2472
2473 static void test_key_initialization(void)
2474 {
2475     DWORD dwLen;
2476     HCRYPTPROV prov1, prov2;
2477     HCRYPTKEY hKeyExchangeKey, hSessionKey, hKey;
2478     BOOL result;
2479     static BYTE abSessionKey[148] = {
2480         0x01, 0x02, 0x00, 0x00, 0x01, 0x68, 0x00, 0x00,
2481         0x00, 0xa4, 0x00, 0x00, 0xb8, 0xa4, 0xdf, 0x5e,
2482         0x9e, 0xb1, 0xbf, 0x85, 0x3d, 0x24, 0x2d, 0x1e,
2483         0x69, 0xb7, 0x67, 0x13, 0x8e, 0x78, 0xf2, 0xdf,
2484         0xc6, 0x69, 0xce, 0x46, 0x7e, 0xf2, 0xf2, 0x33,
2485         0x20, 0x6f, 0xa1, 0xa5, 0x59, 0x83, 0x25, 0xcb,
2486         0x3a, 0xb1, 0x8a, 0x12, 0x63, 0x02, 0x3c, 0xfb,
2487         0x4a, 0xfa, 0xef, 0x8e, 0xf7, 0x29, 0x57, 0xb1,
2488         0x9e, 0xa7, 0xf3, 0x02, 0xfd, 0xca, 0xdf, 0x5a,
2489         0x1f, 0x71, 0xb6, 0x26, 0x09, 0x24, 0x39, 0xda,
2490         0xc0, 0xde, 0x2a, 0x0e, 0xcd, 0x1f, 0xe5, 0xb6,
2491         0x4f, 0x82, 0xa0, 0xa9, 0x90, 0xd3, 0xd9, 0x6a,
2492         0x43, 0x14, 0x2a, 0xf7, 0xac, 0xd5, 0xa0, 0x54,
2493         0x93, 0xc4, 0xb9, 0xe7, 0x24, 0x84, 0x4d, 0x69,
2494         0x5e, 0xcc, 0x2a, 0x32, 0xb5, 0xfb, 0xe4, 0xb4,
2495         0x08, 0xd5, 0x36, 0x58, 0x59, 0x40, 0xfb, 0x29,
2496         0x7f, 0xa7, 0x17, 0x25, 0xc4, 0x0d, 0x78, 0x37,
2497         0x04, 0x8c, 0x49, 0x92
2498     };
2499
2500     /* Like init_base_environment, but doesn't generate new keys, as they'll
2501      * be imported instead.
2502      */
2503     if (!CryptAcquireContext(&prov1, szContainer, szProvider, PROV_RSA_FULL, 0))
2504     {
2505         result = CryptAcquireContext(&prov1, szContainer, szProvider, PROV_RSA_FULL,
2506                                      CRYPT_NEWKEYSET);
2507         ok(result, "%08x\n", GetLastError());
2508     }
2509     dwLen = (DWORD)sizeof(abPlainPrivateKey);
2510     result = CryptImportKey(prov1, abPlainPrivateKey, dwLen, 0, 0, &hKeyExchangeKey);
2511
2512     dwLen = (DWORD)sizeof(abSessionKey);
2513     result = CryptImportKey(prov1, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey);
2514     ok(result, "%08x\n", GetLastError());
2515
2516     /* Once the key has been imported, subsequently acquiring a context with
2517      * the same name will allow retrieving the key.
2518      */
2519     result = CryptAcquireContext(&prov2, szContainer, szProvider, PROV_RSA_FULL, 0);
2520     ok(result, "%08x\n", GetLastError());
2521     result = CryptGetUserKey(prov2, AT_KEYEXCHANGE, &hKey);
2522     ok(result, "%08x\n", GetLastError());
2523     if (result) CryptDestroyKey(hKey);
2524     CryptReleaseContext(prov2, 0);
2525
2526     CryptDestroyKey(hSessionKey);
2527     CryptDestroyKey(hKeyExchangeKey);
2528     CryptReleaseContext(prov1, 0);
2529     CryptAcquireContext(&prov1, szContainer, NULL, PROV_RSA_FULL,
2530      CRYPT_DELETEKEYSET);
2531 }
2532
2533 START_TEST(rsaenh)
2534 {
2535     if (!init_base_environment(0))
2536         return;
2537     test_prov();
2538     test_gen_random();
2539     test_hashes();
2540     test_rc4();
2541     test_rc2();
2542     test_des();
2543     test_3des112();
2544     test_3des();
2545     test_hmac();
2546     test_mac();
2547     test_block_cipher_modes();
2548     test_import_private();
2549     test_verify_signature();
2550     test_rsa_encrypt();
2551     test_import_export();
2552     test_enum_container();
2553     clean_up_base_environment();
2554     test_key_permissions();
2555     test_key_initialization();
2556     test_schannel_provider();
2557     test_null_provider();
2558     test_rsa_round_trip();
2559     if (!init_aes_environment())
2560         return;
2561     test_aes(128);
2562     test_aes(192);
2563     test_aes(256);
2564     clean_up_aes_environment();
2565 }