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  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <string.h>
  22 #include <stdio.h>
  23 #include "wine/test.h"
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winerror.h"
  27 #include "wincrypt.h"
  28
  29 static HCRYPTPROV hProv;
  30 static const char szContainer[] = "winetest";
  31 static const unsigned char pbData[] = "Wine rocks totally!";
  32 static const char szProvider[] = MS_ENHANCED_PROV_A;
  33
  34 static BOOL (WINAPI *pCryptDuplicateHash) (HCRYPTHASH, DWORD*, DWORD, HCRYPTHASH*);
  35
  36 /*
  37 static void trace_hex(BYTE *pbData, DWORD dwLen) {
  38     char szTemp[256];
  39     DWORD i, j;
  40
  41     for (i = 0; i < dwLen-7; i+=8) {
  42         sprintf(szTemp, "0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x,\n",
  43             pbData[i], pbData[i+1], pbData[i+2], pbData[i+3], pbData[i+4], pbData[i+5],
  44             pbData[i+6], pbData[i+7]);
  45         trace(szTemp);
  46     }
  47     for (j=0; i<dwLen; j++,i++) {
  48         sprintf(szTemp+6*j, "0x%02x, \n", pbData[i]);
  49     }
  50     trace(szTemp);
  51 }
  52 */
  53
  54 static int init_environment(void)
  55 {
  56     HCRYPTKEY hKey;
  57     BOOL result;
  58
  59     pCryptDuplicateHash = (void *)GetProcAddress(GetModuleHandleA("advapi32.dll"), "CryptDuplicateHash");
  60
  61     hProv = (HCRYPTPROV)INVALID_HANDLE_VALUE;
  62
  63     result = CryptAcquireContext(&hProv, szContainer, szProvider, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
  64     ok(!result && GetLastError()==NTE_BAD_FLAGS, "%d, %08lx\n", result, GetLastError());
  65
  66     if (!CryptAcquireContext(&hProv, szContainer, szProvider, PROV_RSA_FULL, 0))
  67     {
  68         ok(GetLastError()==NTE_BAD_KEYSET, "%08lx\n", GetLastError());
  69         if (GetLastError()!=NTE_BAD_KEYSET) return 0;
  70         result = CryptAcquireContext(&hProv, szContainer, szProvider, PROV_RSA_FULL,
  71                                     CRYPT_NEWKEYSET);
  72         ok(result, "%08lx\n", GetLastError());
  73         if (!result) return 0;
  74         result = CryptGenKey(hProv, AT_KEYEXCHANGE, 0, &hKey);
  75         ok(result, "%08lx\n", GetLastError());
  76         if (result) CryptDestroyKey(hKey);
  77         result = CryptGenKey(hProv, AT_SIGNATURE, 0, &hKey);
  78         ok(result, "%08lx\n", GetLastError());
  79         if (result) CryptDestroyKey(hKey);
  80     }
  81     return 1;
  82 }
  83
  84 static void clean_up_environment(void)
  85 {
  86     BOOL result;
  87
  88     result = CryptReleaseContext(hProv, 1);
  89     ok(!result && GetLastError()==NTE_BAD_FLAGS, "%08lx\n", GetLastError());
  90
  91     CryptAcquireContext(&hProv, szContainer, szProvider, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
  92 }
  93
  94 static void test_prov(void)
  95 {
  96     BOOL result;
  97     DWORD dwLen, dwInc;
  98
  99     dwLen = (DWORD)sizeof(DWORD);
 100     result = CryptGetProvParam(hProv, PP_SIG_KEYSIZE_INC, (BYTE*)&dwInc, &dwLen, 0);
 101     ok(result && dwInc==8, "%08lx, %ld\n", GetLastError(), dwInc);
 102
 103     dwLen = (DWORD)sizeof(DWORD);
 104     result = CryptGetProvParam(hProv, PP_KEYX_KEYSIZE_INC, (BYTE*)&dwInc, &dwLen, 0);
 105     ok(result && dwInc==8, "%08lx, %ld\n", GetLastError(), dwInc);
 106 }
 107
 108 static void test_gen_random(void)
 109 {
 110     BOOL result;
 111     BYTE rnd1[16], rnd2[16];
 112
 113     memset(rnd1, 0, sizeof(rnd1));
 114     memset(rnd2, 0, sizeof(rnd2));
 115
 116     result = CryptGenRandom(hProv, sizeof(rnd1), rnd1);
 117     if (!result && GetLastError() == NTE_FAIL) {
 118         /* rsaenh compiled without OpenSSL */
 119         return;
 120     }
 121
 122     ok(result, "%08lx\n", GetLastError());
 123
 124     result = CryptGenRandom(hProv, sizeof(rnd2), rnd2);
 125     ok(result, "%08lx\n", GetLastError());
 126
 127     ok(memcmp(rnd1, rnd2, sizeof(rnd1)), "CryptGenRandom generates non random data\n");
 128 }
 129
 130 static BOOL derive_key(ALG_ID aiAlgid, HCRYPTKEY *phKey, DWORD len)
 131 {
 132     HCRYPTHASH hHash;
 133     BOOL result;
 134     unsigned char pbData[2000];
 135     int i;
 136
 137     *phKey = (HCRYPTKEY)NULL;
 138     for (i=0; i<2000; i++) pbData[i] = (unsigned char)i;
 139     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 140     if (!result) {
 141         /* rsaenh compiled without OpenSSL */
 142         ok(GetLastError()==NTE_BAD_ALGID, "%08lx\n", GetLastError());
 143         return FALSE;
 144     }
 145     ok(result, "%08lx\n", GetLastError());
 146     if (!result) return FALSE;
 147     result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 148     ok(result, "%08lx\n", GetLastError());
 149     if (!result) return FALSE;
 150     result = CryptDeriveKey(hProv, aiAlgid, hHash, (len << 16) | CRYPT_EXPORTABLE, phKey);
 151     ok(result, "%08lx\n", GetLastError());
 152     if (!result) return FALSE;
 153     len = 2000;
 154     result = CryptGetHashParam(hHash, HP_HASHVAL, pbData, &len, 0);
 155     ok(result, "%08lx\n", GetLastError());
 156     CryptDestroyHash(hHash);
 157     return TRUE;
 158 }
 159
 160 static void test_hashes(void)
 161 {
 162     static const unsigned char md2hash[16] = {
 163         0x12, 0xcb, 0x1b, 0x08, 0xc8, 0x48, 0xa4, 0xa9,
 164         0xaa, 0xf3, 0xf1, 0x9f, 0xfc, 0x29, 0x28, 0x68 };
 165     static const unsigned char md4hash[16] = {
 166         0x8e, 0x2a, 0x58, 0xbf, 0xf2, 0xf5, 0x26, 0x23,
 167         0x79, 0xd2, 0x92, 0x36, 0x1b, 0x23, 0xe3, 0x81 };
 168     static const unsigned char md5hash[16] = {
 169         0x15, 0x76, 0xa9, 0x4d, 0x6c, 0xb3, 0x34, 0xdd,
 170         0x12, 0x6c, 0xb1, 0xc2, 0x7f, 0x19, 0xe0, 0xf2 };
 171     static const unsigned char sha1hash[20] = {
 172         0xf1, 0x0c, 0xcf, 0xde, 0x60, 0xc1, 0x7d, 0xb2, 0x6e, 0x7d,
 173         0x85, 0xd3, 0x56, 0x65, 0xc7, 0x66, 0x1d, 0xbb, 0xeb, 0x2c };
 174     unsigned char pbData[2048];
 175     BOOL result;
 176     HCRYPTHASH hHash, hHashClone;
 177     BYTE pbHashValue[36];
 178     DWORD hashlen, len;
 179     int i;
 180
 181     for (i=0; i<2048; i++) pbData[i] = (unsigned char)i;
 182
 183     /* MD2 Hashing */
 184     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 185     if (!result) {
 186         /* rsaenh compiled without OpenSSL */
 187         ok(GetLastError() == NTE_BAD_ALGID, "%08lx\n", GetLastError());
 188     } else {
 189         result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 190         ok(result, "%08lx\n", GetLastError());
 191
 192         len = sizeof(DWORD);
 193         result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 194            ok(result && (hashlen == 16), "%08lx, hashlen: %ld\n", GetLastError(), hashlen);
 195
 196         len = 16;
 197         result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 198         ok(result, "%08lx\n", GetLastError());
 199
 200         ok(!memcmp(pbHashValue, md2hash, 16), "Wrong MD2 hash!\n");
 201
 202         result = CryptDestroyHash(hHash);
 203         ok(result, "%08lx\n", GetLastError());
 204     }
 205
 206     /* MD4 Hashing */
 207     result = CryptCreateHash(hProv, CALG_MD4, 0, 0, &hHash);
 208     ok(result, "%08lx\n", GetLastError());
 209
 210     result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 211     ok(result, "%08lx\n", GetLastError());
 212
 213     len = sizeof(DWORD);
 214     result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 215     ok(result && (hashlen == 16), "%08lx, hashlen: %ld\n", GetLastError(), hashlen);
 216
 217     len = 16;
 218     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 219     ok(result, "%08lx\n", GetLastError());
 220
 221     ok(!memcmp(pbHashValue, md4hash, 16), "Wrong MD4 hash!\n");
 222
 223     result = CryptDestroyHash(hHash);
 224     ok(result, "%08lx\n", GetLastError());
 225
 226     /* MD5 Hashing */
 227     result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
 228     ok(result, "%08lx\n", GetLastError());
 229
 230     result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 231     ok(result, "%08lx\n", GetLastError());
 232
 233     len = sizeof(DWORD);
 234     result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 235     ok(result && (hashlen == 16), "%08lx, hashlen: %ld\n", GetLastError(), hashlen);
 236
 237     len = 16;
 238     result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
 239     ok(result, "%08lx\n", GetLastError());
 240
 241     ok(!memcmp(pbHashValue, md5hash, 16), "Wrong MD5 hash!\n");
 242
 243     result = CryptDestroyHash(hHash);
 244     ok(result, "%08lx\n", GetLastError());
 245
 246     /* SHA1 Hashing */
 247     result = CryptCreateHash(hProv, CALG_SHA, 0, 0, &hHash);
 248     ok(result, "%08lx\n", GetLastError());
 249
 250     result = CryptHashData(hHash, (BYTE*)pbData, 5, 0);
 251     ok(result, "%08lx\n", GetLastError());
 252
 253     if(pCryptDuplicateHash) {
 254         result = pCryptDuplicateHash(hHash, 0, 0, &hHashClone);
 255         ok(result, "%08lx\n", GetLastError());
 256
 257         result = CryptHashData(hHashClone, (BYTE*)pbData+5, sizeof(pbData)-5, 0);
 258         ok(result, "%08lx\n", GetLastError());
 259
 260         len = sizeof(DWORD);
 261         result = CryptGetHashParam(hHashClone, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
 262         ok(result && (hashlen == 20), "%08lx, hashlen: %ld\n", GetLastError(), hashlen);
 263
 264         len = 20;
 265         result = CryptGetHashParam(hHashClone, HP_HASHVAL, pbHashValue, &len, 0);
 266         ok(result, "%08lx\n", GetLastError());
 267
 268         ok(!memcmp(pbHashValue, sha1hash, 20), "Wrong SHA1 hash!\n");
 269
 270         result = CryptDestroyHash(hHashClone);
 271         ok(result, "%08lx\n", GetLastError());
 272     }
 273
 274     result = CryptDestroyHash(hHash);
 275     ok(result, "%08lx\n", GetLastError());
 276 }
 277
 278 static void test_block_cipher_modes(void)
 279 {
 280     static const BYTE plain[23] = {
 281         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
 282         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
 283     static const BYTE ecb[24] = {
 284         0xc0, 0x9a, 0xe4, 0x2f, 0x0a, 0x47, 0x67, 0x11, 0xf2, 0xb2, 0x5d, 0x5f,
 285         0x08, 0xff, 0x49, 0xa4, 0x45, 0x3a, 0x68, 0x14, 0xca, 0x18, 0xe5, 0xf4 };
 286     static const BYTE cbc[24] = {
 287         0xc0, 0x9a, 0xe4, 0x2f, 0x0a, 0x47, 0x67, 0x11, 0x10, 0xf5, 0xda, 0x61,
 288         0x4e, 0x3d, 0xab, 0xc0, 0x97, 0x85, 0x01, 0x12, 0x97, 0xa4, 0xf7, 0xd3 };
 289     static const BYTE cfb[24] = {
 290         0x29, 0xb5, 0x67, 0x85, 0x0b, 0x1b, 0xec, 0x07, 0x67, 0x2d, 0xa1, 0xa4,
 291         0x1a, 0x47, 0x24, 0x6a, 0x54, 0xe1, 0xe0, 0x92, 0xf9, 0x0e, 0xf6, 0xeb };
 292     HCRYPTKEY hKey;
 293     BOOL result;
 294     BYTE abData[24];
 295     DWORD dwMode, dwLen;
 296
 297     result = derive_key(CALG_RC2, &hKey, 40);
 298     if (!result) return;
 299
 300     memcpy(abData, plain, sizeof(abData));
 301
 302     dwMode = CRYPT_MODE_ECB;
 303     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 304     ok(result, "%08lx\n", GetLastError());
 305
 306     dwLen = 23;
 307     result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, NULL, &dwLen, 24);
 308     ok(result, "CryptEncrypt failed: %08lx\n", GetLastError());
 309     ok(dwLen == 24, "Unexpected length %ld\n", dwLen);
 310
 311     SetLastError(ERROR_SUCCESS);
 312     dwLen = 23;
 313     result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, abData, &dwLen, 24);
 314     ok(result && dwLen == 24 && !memcmp(ecb, abData, sizeof(ecb)),
 315        "%08lx, dwLen: %ld\n", GetLastError(), dwLen);
 316
 317     result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, abData, &dwLen);
 318     ok(result && dwLen == 23 && !memcmp(plain, abData, sizeof(plain)),
 319        "%08lx, dwLen: %ld\n", GetLastError(), dwLen);
 320
 321     dwMode = CRYPT_MODE_CBC;
 322     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 323     ok(result, "%08lx\n", GetLastError());
 324
 325     dwLen = 23;
 326     result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, NULL, &dwLen, 24);
 327     ok(result, "CryptEncrypt failed: %08lx\n", GetLastError());
 328     ok(dwLen == 24, "Unexpected length %ld\n", dwLen);
 329
 330     dwLen = 23;
 331     result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, abData, &dwLen, 24);
 332     ok(result && dwLen == 24 && !memcmp(cbc, abData, sizeof(cbc)),
 333        "%08lx, dwLen: %ld\n", GetLastError(), dwLen);
 334
 335     result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, abData, &dwLen);
 336     ok(result && dwLen == 23 && !memcmp(plain, abData, sizeof(plain)),
 337        "%08lx, dwLen: %ld\n", GetLastError(), dwLen);
 338
 339     dwMode = CRYPT_MODE_CFB;
 340     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 341     ok(result, "%08lx\n", GetLastError());
 342
 343     dwLen = 16;
 344     result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, FALSE, 0, abData, &dwLen, 24);
 345     ok(result && dwLen == 16, "%08lx, dwLen: %ld\n", GetLastError(), dwLen);
 346
 347     dwLen = 7;
 348     result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, abData+16, &dwLen, 8);
 349     ok(result && dwLen == 8 && !memcmp(cfb, abData, sizeof(cfb)),
 350        "%08lx, dwLen: %ld\n", GetLastError(), dwLen);
 351
 352     dwLen = 8;
 353     result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, FALSE, 0, abData, &dwLen);
 354     ok(result && dwLen == 8, "%08lx, dwLen: %ld\n", GetLastError(), dwLen);
 355
 356     dwLen = 16;
 357     result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, abData+8, &dwLen);
 358     ok(result && dwLen == 15 && !memcmp(plain, abData, sizeof(plain)),
 359        "%08lx, dwLen: %ld\n", GetLastError(), dwLen);
 360
 361     dwMode = CRYPT_MODE_OFB;
 362     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 363     ok(result, "%08lx\n", GetLastError());
 364
 365     dwLen = 23;
 366     result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, abData, &dwLen, 24);
 367     ok(!result && GetLastError() == NTE_BAD_ALGID, "%08lx\n", GetLastError());
 368 }
 369
 370 static void test_3des112(void)
 371 {
 372     HCRYPTKEY hKey;
 373     BOOL result;
 374     DWORD dwLen;
 375     unsigned char pbData[16];
 376     int i;
 377
 378     result = derive_key(CALG_3DES_112, &hKey, 0);
 379     if (!result) {
 380         /* rsaenh compiled without OpenSSL */
 381         ok(GetLastError() == NTE_BAD_ALGID, "%08lx\n", GetLastError());
 382         return;
 383     }
 384
 385     for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
 386
 387     dwLen = 13;
 388     result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwLen, 16);
 389     ok(result, "%08lx\n", GetLastError());
 390
 391     result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwLen);
 392     ok(result, "%08lx\n", GetLastError());
 393
 394     result = CryptDestroyKey(hKey);
 395     ok(result, "%08lx\n", GetLastError());
 396 }
 397
 398 static void test_des(void)
 399 {
 400     HCRYPTKEY hKey;
 401     BOOL result;
 402     DWORD dwLen, dwMode;
 403     unsigned char pbData[16];
 404     int i;
 405
 406     result = derive_key(CALG_DES, &hKey, 56);
 407     if (!result) {
 408         /* rsaenh compiled without OpenSSL */
 409         ok(GetLastError()==NTE_BAD_ALGID, "%08lx\n", GetLastError());
 410         return;
 411     }
 412
 413     dwMode = CRYPT_MODE_ECB;
 414     result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 415     ok(result, "%08lx\n", GetLastError());
 416
 417     dwLen = sizeof(DWORD);
 418     result = CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0);
 419     ok(result, "%08lx\n", GetLastError());
 420
 421     for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
 422
 423     dwLen = 13;
 424     result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwLen, 16);
 425     ok(result, "%08lx\n", GetLastError());
 426
 427     result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwLen);
 428     ok(result, "%08lx\n", GetLastError());
 429
 430     result = CryptDestroyKey(hKey);
 431     ok(result, "%08lx\n", GetLastError());
 432 }
 433
 434 static void test_3des(void)
 435 {
 436     HCRYPTKEY hKey;
 437     BOOL result;
 438     DWORD dwLen;
 439     unsigned char pbData[16];
 440     static const BYTE des3[16] = {
 441         0x7b, 0xba, 0xdd, 0xa2, 0x39, 0xd3, 0x7b, 0xb3,
 442         0xc7, 0x51, 0x81, 0x41, 0x53, 0xe8, 0xcf, 0xeb };
 443     int i;
 444
 445     result = derive_key(CALG_3DES, &hKey, 0);
 446     if (!result) return;
 447
 448     for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
 449
 450     dwLen = 13;
 451     result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwLen, 16);
 452     ok(result, "%08lx\n", GetLastError());
 453
 454     ok(!memcmp(pbData, des3, sizeof(des3)), "3DES encryption failed!\n");
 455
 456     result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwLen);
 457     ok(result, "%08lx\n", GetLastError());
 458
 459     result = CryptDestroyKey(hKey);
 460     ok(result, "%08lx\n", GetLastError());
 461 }
 462
 463 static void test_rc2(void)
 464 {
 465     static const BYTE rc2encrypted[16] = {
 466         0x02, 0x34, 0x7d, 0xf6, 0x1d, 0xc5, 0x9b, 0x8b,
 467         0x2e, 0x0d, 0x63, 0x80, 0x72, 0xc1, 0xc2, 0xb1 };
 468     HCRYPTHASH hHash;
 469     HCRYPTKEY hKey;
 470     BOOL result;
 471     DWORD dwLen, dwKeyLen, dwDataLen, dwMode, dwModeBits;
 472     BYTE *pbTemp;
 473     unsigned char pbData[2000], pbHashValue[16];
 474     int i;
 475
 476     for (i=0; i<2000; i++) pbData[i] = (unsigned char)i;
 477
 478     /* MD2 Hashing */
 479     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 480     if (!result) {
 481         ok(GetLastError()==NTE_BAD_ALGID, "%08lx\n", GetLastError());
 482     } else {
 483         result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 484         ok(result, "%08lx\n", GetLastError());
 485
 486         dwLen = 16;
 487         result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &dwLen, 0);
 488         ok(result, "%08lx\n", GetLastError());
 489
 490         result = CryptDeriveKey(hProv, CALG_RC2, hHash, 56 << 16, &hKey);
 491         ok(result, "%08lx\n", GetLastError());
 492
 493         dwLen = sizeof(DWORD);
 494         result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
 495         ok(result, "%08lx\n", GetLastError());
 496
 497         dwMode = CRYPT_MODE_CBC;
 498         result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
 499         ok(result, "%08lx\n", GetLastError());
 500
 501         dwLen = sizeof(DWORD);
 502         result = CryptGetKeyParam(hKey, KP_MODE_BITS, (BYTE*)&dwModeBits, &dwLen, 0);
 503         ok(result, "%08lx\n", GetLastError());
 504
 505         dwLen = sizeof(DWORD);
 506         result = CryptGetKeyParam(hKey, KP_PERMISSIONS, (BYTE*)&dwModeBits, &dwLen, 0);
 507         ok(result, "%08lx\n", GetLastError());
 508
 509         dwLen = sizeof(DWORD);
 510         result = CryptGetKeyParam(hKey, KP_BLOCKLEN, (BYTE*)&dwModeBits, &dwLen, 0);
 511         ok(result, "%08lx\n", GetLastError());
 512
 513         result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0);
 514         ok(result, "%08lx\n", GetLastError());
 515         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 516         CryptGetKeyParam(hKey, KP_IV, pbTemp, &dwLen, 0);
 517         HeapFree(GetProcessHeap(), 0, pbTemp);
 518
 519         result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0);
 520         ok(result, "%08lx\n", GetLastError());
 521         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 522         CryptGetKeyParam(hKey, KP_SALT, pbTemp, &dwLen, 0);
 523         HeapFree(GetProcessHeap(), 0, pbTemp);
 524
 525         dwLen = sizeof(DWORD);
 526         CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0);
 527
 528         result = CryptDestroyHash(hHash);
 529         ok(result, "%08lx\n", GetLastError());
 530
 531         dwDataLen = 13;
 532         result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwDataLen, 24);
 533         ok(result, "%08lx\n", GetLastError());
 534
 535         ok(!memcmp(pbData, rc2encrypted, 8), "RC2 encryption failed!\n");
 536
 537         result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0);
 538         ok(result, "%08lx\n", GetLastError());
 539         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 540         CryptGetKeyParam(hKey, KP_IV, pbTemp, &dwLen, 0);
 541         HeapFree(GetProcessHeap(), 0, pbTemp);
 542
 543         result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwDataLen);
 544         ok(result, "%08lx\n", GetLastError());
 545
 546         result = CryptDestroyKey(hKey);
 547         ok(result, "%08lx\n", GetLastError());
 548     }
 549 }
 550
 551 static void test_rc4(void)
 552 {
 553     static const BYTE rc4[16] = {
 554         0x17, 0x0c, 0x44, 0x8e, 0xae, 0x90, 0xcd, 0xb0,
 555         0x7f, 0x87, 0xf5, 0x7a, 0xec, 0xb2, 0x2e, 0x35 };
 556     BOOL result;
 557     HCRYPTHASH hHash;
 558     HCRYPTKEY hKey;
 559     DWORD dwDataLen = 5, dwKeyLen, dwLen = sizeof(DWORD), dwMode;
 560     unsigned char pbData[2000], *pbTemp;
 561     unsigned char pszBuffer[256];
 562     int i;
 563
 564     for (i=0; i<2000; i++) pbData[i] = (unsigned char)i;
 565
 566     /* MD2 Hashing */
 567     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
 568     if (!result) {
 569         /* rsaenh compiled without OpenSSL */
 570         ok(GetLastError() == NTE_BAD_ALGID, "%08lx\n", GetLastError());
 571     } else {
 572         result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
 573            ok(result, "%08lx\n", GetLastError());
 574
 575         dwLen = 16;
 576         result = CryptGetHashParam(hHash, HP_HASHVAL, pszBuffer, &dwLen, 0);
 577         ok(result, "%08lx\n", GetLastError());
 578
 579         result = CryptDeriveKey(hProv, CALG_RC4, hHash, 56 << 16, &hKey);
 580         ok(result, "%08lx\n", GetLastError());
 581
 582         dwLen = sizeof(DWORD);
 583         result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
 584         ok(result, "%08lx\n", GetLastError());
 585
 586         dwLen = sizeof(DWORD);
 587         result = CryptGetKeyParam(hKey, KP_BLOCKLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
 588         ok(result, "%08lx\n", GetLastError());
 589
 590         result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0);
 591         ok(result, "%08lx\n", GetLastError());
 592         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 593         CryptGetKeyParam(hKey, KP_IV, pbTemp, &dwLen, 0);
 594         HeapFree(GetProcessHeap(), 0, pbTemp);
 595
 596         result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0);
 597         ok(result, "%08lx\n", GetLastError());
 598         pbTemp = HeapAlloc(GetProcessHeap(), 0, dwLen);
 599         CryptGetKeyParam(hKey, KP_SALT, pbTemp, &dwLen, 0);
 600         HeapFree(GetProcessHeap(), 0, pbTemp);
 601
 602         dwLen = sizeof(DWORD);
 603         CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0);
 604
 605         result = CryptDestroyHash(hHash);
 606         ok(result, "%08lx\n", GetLastError());
 607
 608         dwDataLen = 16;
 609         result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, NULL, &dwDataLen, 24);
 610         ok(result, "%08lx\n", GetLastError());
 611         dwDataLen = 16;
 612         result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwDataLen, 24);
 613         ok(result, "%08lx\n", GetLastError());
 614
 615         ok(!memcmp(pbData, rc4, dwDataLen), "RC4 encryption failed!\n");
 616
 617         result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwDataLen);
 618         ok(result, "%08lx\n", GetLastError());
 619
 620         result = CryptDestroyKey(hKey);
 621         ok(result, "%08lx\n", GetLastError());
 622     }
 623 }
 624
 625 static void test_hmac(void) {
 626     HCRYPTKEY hKey;
 627     HCRYPTHASH hHash;
 628     BOOL result;
 629     HMAC_INFO hmacInfo = { CALG_MD2, NULL, 0, NULL, 0 };
 630     DWORD dwLen;
 631     BYTE abData[256];
 632     static const BYTE hmac[16] = {
 633         0xfd, 0x16, 0xb5, 0xb6, 0x13, 0x1c, 0x2b, 0xd6,
 634         0x0a, 0xc7, 0xae, 0x92, 0x76, 0xa3, 0x05, 0x71 };
 635     int i;
 636
 637     for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abData[i] = (BYTE)i;
 638
 639     if (!derive_key(CALG_RC2, &hKey, 56)) return;
 640
 641     result = CryptCreateHash(hProv, CALG_HMAC, hKey, 0, &hHash);
 642     ok(result, "%08lx\n", GetLastError());
 643     if (!result) return;
 644
 645     result = CryptSetHashParam(hHash, HP_HMAC_INFO, (BYTE*)&hmacInfo, 0);
 646     ok(result, "%08lx\n", GetLastError());
 647
 648     result = CryptHashData(hHash, (BYTE*)abData, sizeof(abData), 0);
 649     ok(result, "%08lx\n", GetLastError());
 650
 651     dwLen = sizeof(abData)/sizeof(BYTE);
 652     result = CryptGetHashParam(hHash, HP_HASHVAL, abData, &dwLen, 0);
 653     ok(result, "%08lx\n", GetLastError());
 654
 655     ok(!memcmp(abData, hmac, sizeof(hmac)), "HMAC failed!\n");
 656
 657     result = CryptDestroyHash(hHash);
 658     ok(result, "%08lx\n", GetLastError());
 659
 660     result = CryptDestroyKey(hKey);
 661     ok(result, "%08lx\n", GetLastError());
 662
 663     /* Provoke errors */
 664     result = CryptCreateHash(hProv, CALG_HMAC, 0, 0, &hHash);
 665     ok(!result && GetLastError() == NTE_BAD_KEY, "%08lx\n", GetLastError());
 666 }
 667
 668 static void test_mac(void) {
 669     HCRYPTKEY hKey;
 670     HCRYPTHASH hHash;
 671     BOOL result;
 672     DWORD dwLen;
 673     BYTE abData[256], abEnc[264];
 674     static const BYTE mac[8] = { 0x0d, 0x3e, 0x15, 0x6b, 0x85, 0x63, 0x5c, 0x11 };
 675     int i;
 676
 677     for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abData[i] = (BYTE)i;
 678     for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abEnc[i] = (BYTE)i;
 679
 680     if (!derive_key(CALG_RC2, &hKey, 56)) return;
 681
 682     dwLen = 256;
 683     result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, abEnc, &dwLen, 264);
 684     ok (result && dwLen == 264, "%08lx, dwLen: %ld\n", GetLastError(), dwLen);
 685
 686     result = CryptCreateHash(hProv, CALG_MAC, hKey, 0, &hHash);
 687     ok(result, "%08lx\n", GetLastError());
 688     if (!result) return;
 689
 690     result = CryptHashData(hHash, (BYTE*)abData, sizeof(abData), 0);
 691     ok(result, "%08lx\n", GetLastError());
 692
 693     dwLen = sizeof(abData)/sizeof(BYTE);
 694     result = CryptGetHashParam(hHash, HP_HASHVAL, abData, &dwLen, 0);
 695     ok(result && dwLen == 8, "%08lx, dwLen: %ld\n", GetLastError(), dwLen);
 696
 697     ok(!memcmp(abData, mac, sizeof(mac)), "MAC failed!\n");
 698
 699     result = CryptDestroyHash(hHash);
 700     ok(result, "%08lx\n", GetLastError());
 701
 702     result = CryptDestroyKey(hKey);
 703     ok(result, "%08lx\n", GetLastError());
 704
 705     /* Provoke errors */
 706     if (!derive_key(CALG_RC4, &hKey, 56)) return;
 707
 708     result = CryptCreateHash(hProv, CALG_MAC, hKey, 0, &hHash);
 709     ok(!result && GetLastError() == NTE_BAD_KEY, "%08lx\n", GetLastError());
 710
 711     result = CryptDestroyKey(hKey);
 712     ok(result, "%08lx\n", GetLastError());
 713 }
 714
 715 static BYTE abPlainPrivateKey[596] = {
 716     0x07, 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00,
 717     0x52, 0x53, 0x41, 0x32, 0x00, 0x04, 0x00, 0x00,
 718     0x01, 0x00, 0x01, 0x00, 0x9b, 0x64, 0xef, 0xce,
 719     0x31, 0x7c, 0xad, 0x56, 0xe2, 0x1e, 0x9b, 0x96,
 720     0xb3, 0xf0, 0x29, 0x88, 0x6e, 0xa8, 0xc2, 0x11,
 721     0x33, 0xd6, 0xcc, 0x8c, 0x69, 0xb2, 0x1a, 0xfd,
 722     0xfc, 0x23, 0x21, 0x30, 0x4d, 0x29, 0x45, 0xb6,
 723     0x3a, 0x67, 0x11, 0x80, 0x1a, 0x91, 0xf2, 0x9f,
 724     0x01, 0xac, 0xc0, 0x11, 0x50, 0x5f, 0xcd, 0xb9,
 725     0xad, 0x76, 0x9f, 0x6e, 0x91, 0x55, 0x71, 0xda,
 726     0x97, 0x96, 0x96, 0x22, 0x75, 0xb4, 0x83, 0x44,
 727     0x89, 0x9e, 0xf8, 0x44, 0x40, 0x7c, 0xd6, 0xcd,
 728     0x9d, 0x88, 0xd6, 0x88, 0xbc, 0x56, 0xb7, 0x64,
 729     0xe9, 0x2c, 0x24, 0x2f, 0x0d, 0x78, 0x55, 0x1c,
 730     0xb2, 0x67, 0xb1, 0x5e, 0xbc, 0x0c, 0xcf, 0x1c,
 731     0xe9, 0xd3, 0x9e, 0xa2, 0x15, 0x24, 0x73, 0xd6,
 732     0xdb, 0x6f, 0x83, 0xb2, 0xf8, 0xbc, 0xe7, 0x47,
 733     0x3b, 0x01, 0xef, 0x49, 0x08, 0x98, 0xd6, 0xa3,
 734     0xf9, 0x25, 0x57, 0xe9, 0x39, 0x3c, 0x53, 0x30,
 735     0x1b, 0xf2, 0xc9, 0x62, 0x31, 0x43, 0x5d, 0x84,
 736     0x24, 0x30, 0x21, 0x9a, 0xad, 0xdb, 0x62, 0x91,
 737     0xc8, 0x07, 0xd9, 0x2f, 0xd6, 0xb5, 0x37, 0x6f,
 738     0xfe, 0x7a, 0x12, 0xbc, 0xd9, 0xd2, 0x2b, 0xbf,
 739     0xd7, 0xb1, 0xfa, 0x7d, 0xc0, 0x48, 0xdd, 0x74,
 740     0xdd, 0x55, 0x04, 0xa1, 0x8b, 0xc1, 0x0a, 0xc4,
 741     0xa5, 0x57, 0x62, 0xee, 0x08, 0x8b, 0xf9, 0x19,
 742     0x6c, 0x52, 0x06, 0xf8, 0x73, 0x0f, 0x24, 0xc9,
 743     0x71, 0x9f, 0xc5, 0x45, 0x17, 0x3e, 0xae, 0x06,
 744     0x81, 0xa2, 0x96, 0x40, 0x06, 0xbf, 0xeb, 0x9e,
 745     0x80, 0x2b, 0x27, 0x20, 0x8f, 0x38, 0xcf, 0xeb,
 746     0xff, 0x3b, 0x38, 0x41, 0x35, 0x69, 0x66, 0x13,
 747     0x1d, 0x3c, 0x01, 0x3b, 0xf6, 0x37, 0xca, 0x9c,
 748     0x61, 0x74, 0x98, 0xcf, 0xc9, 0x6e, 0xe8, 0x90,
 749     0xc7, 0xb7, 0x33, 0xc0, 0x07, 0x3c, 0xf8, 0xc8,
 750     0xf6, 0xf2, 0xd7, 0xf0, 0x21, 0x62, 0x58, 0x8a,
 751     0x55, 0xbf, 0xa1, 0x2d, 0x3d, 0xa6, 0x69, 0xc5,
 752     0x02, 0x19, 0x31, 0xf0, 0x94, 0x0f, 0x45, 0x5c,
 753     0x95, 0x1b, 0x53, 0xbc, 0xf5, 0xb0, 0x1a, 0x8f,
 754     0xbf, 0x40, 0xe0, 0xc7, 0x73, 0xe7, 0x72, 0x6e,
 755     0xeb, 0xb1, 0x0f, 0x38, 0xc5, 0xf8, 0xee, 0x04,
 756     0xed, 0x34, 0x1a, 0x10, 0xf9, 0x53, 0x34, 0xf3,
 757     0x3e, 0xe6, 0x5c, 0xd1, 0x47, 0x65, 0xcd, 0xbd,
 758     0xf1, 0x06, 0xcb, 0xb4, 0xb1, 0x26, 0x39, 0x9f,
 759     0x71, 0xfe, 0x3d, 0xf8, 0x62, 0xab, 0x22, 0x8b,
 760     0x0e, 0xdc, 0xb9, 0xe8, 0x74, 0x06, 0xfc, 0x8c,
 761     0x25, 0xa1, 0xa9, 0xcf, 0x07, 0xf9, 0xac, 0x21,
 762     0x01, 0x7b, 0x1c, 0xdc, 0x94, 0xbd, 0x47, 0xe1,
 763     0xa0, 0x86, 0x59, 0x35, 0x6a, 0x6f, 0xb9, 0x70,
 764     0x26, 0x7c, 0x3c, 0xfd, 0xbd, 0x81, 0x39, 0x36,
 765     0x42, 0xc2, 0xbd, 0xbe, 0x84, 0x27, 0x9a, 0x69,
 766     0x81, 0xda, 0x99, 0x27, 0xc2, 0x4f, 0x62, 0x33,
 767     0xf4, 0x79, 0x30, 0xc5, 0x63, 0x54, 0x71, 0xf1,
 768     0x47, 0x22, 0x25, 0x9b, 0x6c, 0x00, 0x2f, 0x1c,
 769     0xf4, 0x1f, 0x85, 0xbc, 0xf6, 0x67, 0x6a, 0xe3,
 770     0xf6, 0x55, 0x8a, 0xef, 0xd0, 0x0b, 0xd3, 0xa2,
 771     0xc5, 0x51, 0x70, 0x15, 0x0a, 0xf0, 0x98, 0x4c,
 772     0xb7, 0x19, 0x62, 0x0e, 0x2d, 0x2a, 0x4a, 0x7d,
 773     0x7a, 0x0a, 0xc4, 0x17, 0xe3, 0x5d, 0x20, 0x52,
 774     0xa9, 0x98, 0xc3, 0xaa, 0x11, 0xf6, 0xbf, 0x4c,
 775     0x94, 0x99, 0x81, 0x89, 0xf0, 0x7f, 0x66, 0xaa,
 776     0xc8, 0x88, 0xd7, 0x31, 0x84, 0x71, 0xb6, 0x64,
 777     0x09, 0x76, 0x0b, 0x7f, 0x1a, 0x1f, 0x2e, 0xfe,
 778     0xcd, 0x59, 0x2a, 0x54, 0x11, 0x84, 0xd4, 0x6a,
 779     0x61, 0xdf, 0xaa, 0x76, 0x66, 0x9d, 0x82, 0x11,
 780     0x56, 0x3d, 0xd2, 0x52, 0xe6, 0x42, 0x5a, 0x77,
 781     0x92, 0x98, 0x34, 0xf3, 0x56, 0x6c, 0x96, 0x10,
 782     0x40, 0x59, 0x16, 0xcb, 0x77, 0x61, 0xe3, 0xbf,
 783     0x4b, 0xd4, 0x39, 0xfb, 0xb1, 0x4e, 0xc1, 0x74,
 784     0xec, 0x7a, 0xea, 0x3d, 0x68, 0xbb, 0x0b, 0xe6,
 785     0xc6, 0x06, 0xbf, 0xdd, 0x7f, 0x94, 0x42, 0xc0,
 786     0x0f, 0xe4, 0x92, 0x33, 0x6c, 0x6e, 0x1b, 0xba,
 787     0x73, 0xf9, 0x79, 0x84, 0xdf, 0x45, 0x00, 0xe4,
 788     0x94, 0x88, 0x9d, 0x08, 0x89, 0xcf, 0xf2, 0xa4,
 789     0xc5, 0x47, 0x45, 0x85, 0x86, 0xa5, 0xcc, 0xa8,
 790     0xf2, 0x5d, 0x58, 0x07
 791 };
 792
 793 static void test_import_private(void)
 794 {
 795     DWORD dwLen;
 796     HCRYPTKEY hKeyExchangeKey, hSessionKey;
 797     BOOL result;
 798     static BYTE abSessionKey[148] = {
 799         0x01, 0x02, 0x00, 0x00, 0x01, 0x68, 0x00, 0x00,
 800         0x00, 0xa4, 0x00, 0x00, 0xb8, 0xa4, 0xdf, 0x5e,
 801         0x9e, 0xb1, 0xbf, 0x85, 0x3d, 0x24, 0x2d, 0x1e,
 802         0x69, 0xb7, 0x67, 0x13, 0x8e, 0x78, 0xf2, 0xdf,
 803         0xc6, 0x69, 0xce, 0x46, 0x7e, 0xf2, 0xf2, 0x33,
 804         0x20, 0x6f, 0xa1, 0xa5, 0x59, 0x83, 0x25, 0xcb,
 805         0x3a, 0xb1, 0x8a, 0x12, 0x63, 0x02, 0x3c, 0xfb,
 806         0x4a, 0xfa, 0xef, 0x8e, 0xf7, 0x29, 0x57, 0xb1,
 807         0x9e, 0xa7, 0xf3, 0x02, 0xfd, 0xca, 0xdf, 0x5a,
 808         0x1f, 0x71, 0xb6, 0x26, 0x09, 0x24, 0x39, 0xda,
 809         0xc0, 0xde, 0x2a, 0x0e, 0xcd, 0x1f, 0xe5, 0xb6,
 810         0x4f, 0x82, 0xa0, 0xa9, 0x90, 0xd3, 0xd9, 0x6a,
 811         0x43, 0x14, 0x2a, 0xf7, 0xac, 0xd5, 0xa0, 0x54,
 812         0x93, 0xc4, 0xb9, 0xe7, 0x24, 0x84, 0x4d, 0x69,
 813         0x5e, 0xcc, 0x2a, 0x32, 0xb5, 0xfb, 0xe4, 0xb4,
 814         0x08, 0xd5, 0x36, 0x58, 0x59, 0x40, 0xfb, 0x29,
 815         0x7f, 0xa7, 0x17, 0x25, 0xc4, 0x0d, 0x78, 0x37,
 816         0x04, 0x8c, 0x49, 0x92
 817     };
 818     static BYTE abEncryptedMessage[12] = {
 819         0x40, 0x64, 0x28, 0xe8, 0x8a, 0xe7, 0xa4, 0xd4,
 820         0x1c, 0xfd, 0xde, 0x71
 821     };
 822
 823     dwLen = (DWORD)sizeof(abPlainPrivateKey);
 824     result = CryptImportKey(hProv, abPlainPrivateKey, dwLen, 0, 0, &hKeyExchangeKey);
 825     if (!result) {
 826         /* rsaenh compiled without OpenSSL */
 827         ok(GetLastError() == NTE_FAIL, "%08lx\n", GetLastError());
 828         return;
 829     }
 830
 831     dwLen = (DWORD)sizeof(abSessionKey);
 832     result = CryptImportKey(hProv, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey);
 833     ok(result, "%08lx\n", GetLastError());
 834     if (!result) return;
 835
 836     dwLen = (DWORD)sizeof(abEncryptedMessage);
 837     result = CryptDecrypt(hSessionKey, 0, TRUE, 0, abEncryptedMessage, &dwLen);
 838     ok(result && dwLen == 12 && !memcmp(abEncryptedMessage, "Wine rocks!",12),
 839        "%08lx, len: %ld\n", GetLastError(), dwLen);
 840
 841     if (!derive_key(CALG_RC4, &hSessionKey, 56)) return;
 842
 843     dwLen = (DWORD)sizeof(abSessionKey);
 844     result = CryptExportKey(hSessionKey, hKeyExchangeKey, SIMPLEBLOB, 0, abSessionKey, &dwLen);
 845     ok(result, "%08lx\n", GetLastError());
 846     if (!result) return;
 847
 848     dwLen = (DWORD)sizeof(abSessionKey);
 849     result = CryptImportKey(hProv, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey);
 850     ok(result, "%08lx\n", GetLastError());
 851     if (!result) return;
 852 }
 853
 854 static void test_verify_signature(void) {
 855     HCRYPTHASH hHash;
 856     HCRYPTKEY hPubSignKey;
 857     BYTE abData[] = "Wine rocks!";
 858     BOOL result;
 859     BYTE abPubKey[148] = {
 860         0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
 861         0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00,
 862         0x01, 0x00, 0x01, 0x00, 0x71, 0x64, 0x9f, 0x19,
 863         0x89, 0x1c, 0x21, 0xcc, 0x36, 0xa3, 0xc9, 0x27,
 864         0x08, 0x8a, 0x09, 0xc6, 0xbe, 0xeb, 0xd3, 0xf8,
 865         0x19, 0xa9, 0x92, 0x57, 0xe4, 0xb9, 0x5d, 0xda,
 866         0x88, 0x93, 0xe4, 0x6b, 0x38, 0x77, 0x14, 0x8a,
 867         0x96, 0xc0, 0xb6, 0x4e, 0x42, 0xf5, 0x01, 0xdc,
 868         0xf0, 0xeb, 0x3c, 0xc7, 0x7b, 0xc4, 0xfd, 0x7c,
 869         0xde, 0x93, 0x34, 0x0a, 0x92, 0xe5, 0x97, 0x9c,
 870         0x3e, 0x65, 0xb8, 0x91, 0x2f, 0xe3, 0xf3, 0x89,
 871         0xcd, 0x6c, 0x26, 0xa4, 0x6c, 0xc7, 0x6d, 0x0b,
 872         0x2c, 0xa2, 0x0b, 0x29, 0xe2, 0xfc, 0x30, 0xfa,
 873         0x20, 0xdb, 0x4c, 0xb8, 0x91, 0xb8, 0x69, 0x63,
 874         0x96, 0x41, 0xc2, 0xb4, 0x60, 0xeb, 0xcd, 0xff,
 875         0x3a, 0x1f, 0x94, 0xb1, 0x23, 0xcf, 0x0f, 0x49,
 876         0xad, 0xd5, 0x33, 0x85, 0x71, 0xaf, 0x12, 0x87,
 877         0x84, 0xef, 0xa0, 0xea, 0xe1, 0xc1, 0xd4, 0xc7,
 878         0xe1, 0x21, 0x50, 0xac
 879     };
 880     /* md2 with hash oid */
 881     BYTE abSignatureMD2[128] = {
 882         0x4a, 0x4e, 0xb7, 0x5e, 0x32, 0xda, 0xdb, 0x67,
 883         0x9f, 0x77, 0x84, 0x32, 0x00, 0xba, 0x5f, 0x6b,
 884         0x0d, 0xcf, 0xd9, 0x99, 0xbd, 0x96, 0x31, 0xda,
 885         0x23, 0x4c, 0xd9, 0x4a, 0x90, 0x84, 0x20, 0x59,
 886         0x51, 0xdc, 0xd4, 0x93, 0x3a, 0xae, 0x0a, 0x0a,
 887         0xa1, 0x76, 0xfa, 0xb5, 0x68, 0xee, 0xc7, 0x34,
 888         0x41, 0xd3, 0xe7, 0x5a, 0x0e, 0x22, 0x61, 0x40,
 889         0xea, 0x24, 0x56, 0xf1, 0x91, 0x5a, 0xf7, 0xa7,
 890         0x5b, 0xf4, 0x98, 0x6b, 0xc3, 0xef, 0xad, 0xc0,
 891         0x5e, 0x6b, 0x87, 0x76, 0xcb, 0x1f, 0x62, 0x06,
 892         0x7c, 0xf6, 0x48, 0x97, 0x81, 0x8d, 0xef, 0x51,
 893         0x51, 0xdc, 0x21, 0x91, 0x57, 0x1e, 0x79, 0x6f,
 894         0x49, 0xb5, 0xde, 0x31, 0x07, 0x45, 0x99, 0x46,
 895         0xc3, 0x4f, 0xca, 0x2d, 0x0e, 0x4c, 0x10, 0x25,
 896         0xcb, 0x1a, 0x98, 0x63, 0x41, 0x93, 0x47, 0xc0,
 897         0xb2, 0xbc, 0x10, 0x3c, 0xe7, 0xd4, 0x3c, 0x1e
 898     };
 899     /* md2 without hash oid */
 900     BYTE abSignatureMD2NoOID[128] = {
 901         0x0c, 0x21, 0x3e, 0x60, 0xf9, 0xd0, 0x36, 0x2d,
 902         0xe1, 0x10, 0x45, 0x45, 0x85, 0x03, 0x29, 0x19,
 903         0xef, 0x19, 0xd9, 0xa6, 0x7e, 0x9c, 0x0d, 0xbd,
 904         0x03, 0x0e, 0xb9, 0x51, 0x9e, 0x74, 0x79, 0xc4,
 905         0xde, 0x25, 0xf2, 0x35, 0x74, 0x55, 0xbc, 0x65,
 906         0x7e, 0x33, 0x28, 0xa8, 0x1e, 0x72, 0xaa, 0x99,
 907         0xdd, 0xf5, 0x26, 0x20, 0x29, 0xf8, 0xa6, 0xdf,
 908         0x28, 0x4b, 0x1c, 0xdb, 0xa1, 0x41, 0x56, 0xbc,
 909         0xf9, 0x9c, 0x66, 0xc0, 0x37, 0x41, 0x55, 0xa0,
 910         0xe2, 0xec, 0xbf, 0x71, 0xf0, 0x5d, 0x25, 0x01,
 911         0x75, 0x91, 0xe2, 0x81, 0xb2, 0x9f, 0x57, 0xa7,
 912         0x5c, 0xd2, 0xfa, 0x66, 0xdb, 0x71, 0x2b, 0x1f,
 913         0xad, 0x30, 0xde, 0xea, 0x49, 0x73, 0x30, 0x6a,
 914         0x22, 0x54, 0x49, 0x4e, 0xae, 0xf6, 0x88, 0xc9,
 915         0xff, 0x71, 0xba, 0xbf, 0x27, 0xc5, 0xfa, 0x06,
 916         0xe2, 0x91, 0x71, 0x8a, 0x7e, 0x0c, 0xc2, 0x07
 917     };
 918     /* md4 with hash oid */
 919     BYTE abSignatureMD4[128] = {
 920         0x1c, 0x78, 0xaa, 0xea, 0x74, 0xf4, 0x83, 0x51,
 921         0xae, 0x66, 0xe3, 0xa9, 0x1c, 0x03, 0x39, 0x1b,
 922         0xac, 0x7e, 0x4e, 0x85, 0x7e, 0x1c, 0x38, 0xd2,
 923         0x82, 0x43, 0xb3, 0x6f, 0x6f, 0x46, 0x45, 0x8e,
 924         0x17, 0x74, 0x58, 0x29, 0xca, 0xe1, 0x03, 0x13,
 925         0x45, 0x79, 0x34, 0xdf, 0x5c, 0xd6, 0xc3, 0xf9,
 926         0x7a, 0x1c, 0x9d, 0xff, 0x6f, 0x03, 0x7d, 0x0f,
 927         0x59, 0x1a, 0x2d, 0x0e, 0x94, 0xb4, 0x75, 0x96,
 928         0xd1, 0x48, 0x63, 0x6e, 0xb2, 0xc4, 0x5c, 0xd9,
 929         0xab, 0x49, 0xb4, 0x90, 0xd9, 0x57, 0x04, 0x6e,
 930         0x4c, 0xb6, 0xea, 0x00, 0x94, 0x4a, 0x34, 0xa0,
 931         0xd9, 0x63, 0xef, 0x2c, 0xde, 0x5b, 0xb9, 0xbe,
 932         0x35, 0xc8, 0xc1, 0x31, 0xb5, 0x31, 0x15, 0x18,
 933         0x90, 0x39, 0xf5, 0x2a, 0x34, 0x6d, 0xb4, 0xab,
 934         0x09, 0x34, 0x69, 0x54, 0x4d, 0x11, 0x2f, 0xf3,
 935         0xa2, 0x36, 0x0e, 0xa8, 0x45, 0xe7, 0x36, 0xac
 936     };
 937     /* md4 without hash oid */
 938     BYTE abSignatureMD4NoOID[128] = {
 939         0xd3, 0x60, 0xb2, 0xb0, 0x22, 0x0a, 0x99, 0xda,
 940         0x04, 0x85, 0x64, 0xc6, 0xc6, 0xdb, 0x11, 0x24,
 941         0xe9, 0x68, 0x2d, 0xf7, 0x09, 0xef, 0xb6, 0xa0,
 942         0xa2, 0xfe, 0x45, 0xee, 0x85, 0x49, 0xcd, 0x36,
 943         0xf7, 0xc7, 0x9d, 0x2b, 0x4c, 0x68, 0xda, 0x85,
 944         0x8c, 0x50, 0xcc, 0x4f, 0x4b, 0xe1, 0x82, 0xc3,
 945         0xbe, 0xa3, 0xf1, 0x78, 0x6b, 0x60, 0x42, 0x3f,
 946         0x67, 0x22, 0x14, 0xe4, 0xe1, 0xa4, 0x6e, 0xa9,
 947         0x4e, 0xf1, 0xd4, 0xb0, 0xce, 0x82, 0xac, 0x06,
 948         0xba, 0x2c, 0xbc, 0xf7, 0xcb, 0xf6, 0x0c, 0x3f,
 949         0xf6, 0x79, 0xfe, 0xb3, 0xd8, 0x5a, 0xbc, 0xdb,
 950         0x05, 0x41, 0xa4, 0x07, 0x57, 0x9e, 0xa2, 0x96,
 951         0xfc, 0x60, 0x4b, 0xf7, 0x6f, 0x86, 0x26, 0x1f,
 952         0xc2, 0x2c, 0x67, 0x08, 0xcd, 0x7f, 0x91, 0xe9,
 953         0x16, 0xb5, 0x0e, 0xd9, 0xc4, 0xc4, 0x97, 0xeb,
 954         0x91, 0x3f, 0x20, 0x6c, 0xf0, 0x68, 0x86, 0x7f
 955     };
 956     /* md5 with hash oid */
 957     BYTE abSignatureMD5[128] = {
 958         0x4f, 0xe0, 0x8c, 0x9b, 0x43, 0xdd, 0x02, 0xe5,
 959         0xf4, 0xa1, 0xdd, 0x88, 0x4c, 0x9c, 0x40, 0x0f,
 960         0x6c, 0x43, 0x86, 0x64, 0x00, 0xe6, 0xac, 0xf7,
 961         0xd0, 0x92, 0xaa, 0xc4, 0x62, 0x9a, 0x48, 0x98,
 962         0x1a, 0x56, 0x6d, 0x75, 0xec, 0x04, 0x89, 0xec,
 963         0x69, 0x93, 0xd6, 0x61, 0x37, 0xb2, 0x36, 0xb5,
 964         0xb2, 0xba, 0xf2, 0xf5, 0x21, 0x0c, 0xf1, 0x04,
 965         0xc8, 0x2d, 0xf5, 0xa0, 0x8d, 0x6d, 0x10, 0x0b,
 966         0x68, 0x63, 0xf2, 0x08, 0x68, 0xdc, 0xbd, 0x95,
 967         0x25, 0x7d, 0xee, 0x63, 0x5c, 0x3b, 0x98, 0x4c,
 968         0xea, 0x41, 0xdc, 0x6a, 0x8b, 0x6c, 0xbb, 0x29,
 969         0x2b, 0x1c, 0x5c, 0x8b, 0x7d, 0x94, 0x24, 0xa9,
 970         0x7a, 0x62, 0x94, 0xf3, 0x3a, 0x6a, 0xb2, 0x4c,
 971         0x33, 0x59, 0x00, 0xcd, 0x7d, 0x37, 0x79, 0x90,
 972         0x31, 0xd1, 0xd9, 0x84, 0x12, 0xe5, 0x08, 0x5e,
 973         0xb3, 0x60, 0x61, 0x27, 0x78, 0x37, 0x63, 0x01
 974     };
 975     /* md5 without hash oid */
 976     BYTE abSignatureMD5NoOID[128] = {
 977         0xc6, 0xad, 0x5c, 0x2b, 0x9b, 0xe0, 0x99, 0x2f,
 978         0x5e, 0x55, 0x04, 0x32, 0x65, 0xe0, 0xb5, 0x75,
 979         0x01, 0x9a, 0x11, 0x4d, 0x0e, 0x9a, 0xe1, 0x9f,
 980         0xc7, 0xbf, 0x77, 0x6d, 0xa9, 0xfd, 0xcc, 0x9d,
 981         0x8b, 0xd1, 0x31, 0xed, 0x5a, 0xd2, 0xe5, 0x5f,
 982         0x42, 0x3b, 0xb5, 0x3c, 0x32, 0x30, 0x88, 0x49,
 983         0xcb, 0x67, 0xb8, 0x2e, 0xc9, 0xf5, 0x2b, 0xc8,
 984         0x35, 0x71, 0xb5, 0x1b, 0x32, 0x3f, 0x44, 0x4c,
 985         0x66, 0x93, 0xcb, 0xe8, 0x48, 0x7c, 0x14, 0x23,
 986         0xfb, 0x12, 0xa5, 0xb7, 0x86, 0x94, 0x6b, 0x19,
 987         0x17, 0x20, 0xc6, 0xb8, 0x09, 0xe8, 0xbb, 0xdb,
 988         0x00, 0x2b, 0x96, 0x4a, 0x93, 0x00, 0x26, 0xd3,
 989         0x07, 0xa0, 0x06, 0xce, 0x5a, 0x13, 0x69, 0x6b,
 990         0x62, 0x5a, 0x56, 0x61, 0x6a, 0xd8, 0x11, 0x3b,
 991         0xd5, 0x67, 0xc7, 0x4d, 0xf6, 0x66, 0x63, 0xc5,
 992         0xe3, 0x8f, 0x7c, 0x7c, 0xb1, 0x3e, 0x55, 0x43
 993     };
 994     /* sha with hash oid */
 995     BYTE abSignatureSHA[128] = {
 996         0x5a, 0x4c, 0x66, 0xc9, 0x30, 0x67, 0xcb, 0x91,
 997         0x3c, 0x4d, 0xd5, 0x8d, 0xea, 0x4e, 0x85, 0xcd,
 998         0xd9, 0x68, 0x3a, 0xf3, 0x24, 0x3c, 0x99, 0x24,
 999         0x25, 0x32, 0x93, 0x3d, 0xd6, 0x2f, 0x86, 0x94,
1000         0x23, 0x09, 0xee, 0x02, 0xd4, 0x15, 0xdc, 0x5f,
1001         0x0e, 0x44, 0x45, 0x13, 0x5f, 0x18, 0x5d, 0x1a,
1002         0xd7, 0x0b, 0xd1, 0x23, 0xd6, 0x35, 0x98, 0x52,
1003         0x57, 0x45, 0x74, 0x92, 0xe3, 0x50, 0xb4, 0x20,
1004         0x28, 0x2a, 0x11, 0xbf, 0x49, 0xb4, 0x2c, 0xc5,
1005         0xd4, 0x1a, 0x27, 0x4e, 0xdf, 0xa0, 0xb5, 0x7a,
1006         0xc8, 0x14, 0xdd, 0x9b, 0xb6, 0xca, 0xd6, 0xff,
1007         0xb2, 0x6b, 0xd8, 0x98, 0x67, 0x80, 0xab, 0x53,
1008         0x52, 0xbb, 0xe1, 0x2a, 0xce, 0x79, 0x2f, 0x00,
1009         0x53, 0x26, 0xd8, 0xa7, 0x43, 0xca, 0x72, 0x0e,
1010         0x68, 0x97, 0x37, 0x71, 0x87, 0xc2, 0x6a, 0x98,
1011         0xbb, 0x6c, 0xa0, 0x01, 0xff, 0x04, 0x9d, 0xa6
1012     };
1013     /* sha without hash oid */
1014     BYTE abSignatureSHANoOID[128] = {
1015         0x86, 0xa6, 0x2b, 0x9a, 0x04, 0xda, 0x47, 0xc6,
1016         0x4f, 0x97, 0x8a, 0x8a, 0xf4, 0xfa, 0x63, 0x1a,
1017         0x32, 0x89, 0x56, 0x41, 0x37, 0x91, 0x15, 0x2f,
1018         0x2d, 0x1c, 0x8f, 0xdc, 0x88, 0x40, 0xbb, 0x37,
1019         0x3e, 0x06, 0x33, 0x1b, 0xde, 0xda, 0x7c, 0x65,
1020         0x91, 0x35, 0xca, 0x45, 0x17, 0x0e, 0x24, 0xbe,
1021         0x9e, 0xf6, 0x4e, 0x8a, 0xa4, 0x3e, 0xca, 0xe6,
1022         0x11, 0x36, 0xb8, 0x3a, 0xf0, 0xde, 0x71, 0xfe,
1023         0xdd, 0xb3, 0xcb, 0x6c, 0x39, 0xe0, 0x5f, 0x0c,
1024         0x9e, 0xa8, 0x40, 0x26, 0x9c, 0x81, 0xe9, 0xc4,
1025         0x15, 0x90, 0xbf, 0x4f, 0xd2, 0xc1, 0xa1, 0x80,
1026         0x52, 0xfd, 0xf6, 0x3d, 0x99, 0x1b, 0x9c, 0x8a,
1027         0x27, 0x1b, 0x0c, 0x9a, 0xf3, 0xf9, 0xa2, 0x00,
1028         0x3e, 0x5b, 0xdf, 0xc2, 0xb4, 0x71, 0xa5, 0xbd,
1029         0xf8, 0xae, 0x63, 0xbb, 0x4a, 0xc9, 0xdd, 0x67,
1030         0xc1, 0x3e, 0x93, 0xee, 0xf1, 0x1f, 0x24, 0x5b
1031     };
1032
1033     result = CryptImportKey(hProv, abPubKey, 148, 0, 0, &hPubSignKey);
1034     ok(result, "%08lx\n", GetLastError());
1035     if (!result) return;
1036
1037     result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
1038     ok(result, "%08lx\n", GetLastError());
1039     if (!result) return;
1040
1041     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1042     ok(result, "%08lx\n", GetLastError());
1043     if (!result) return;
1044
1045     result = CryptVerifySignature(hHash, abSignatureMD2, 128, hPubSignKey, NULL, 0);
1046     ok(result, "%08lx\n", GetLastError());
1047     if (!result) return;
1048
1049     result = CryptVerifySignature(hHash, abSignatureMD2NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1050     ok(result, "%08lx\n", GetLastError());
1051     if (!result) return;
1052
1053     /* Next test fails on WinXP SP2. It seems that CPVerifySignature doesn't care about
1054      * the OID at all. */
1055     /*result = CryptVerifySignature(hHash, abSignatureMD2NoOID, 128, hPubSignKey, NULL, 0);
1056     ok(!result && GetLastError()==NTE_BAD_SIGNATURE, "%08lx\n", GetLastError());
1057     if (result) return;*/
1058
1059     result = CryptCreateHash(hProv, CALG_MD4, 0, 0, &hHash);
1060     ok(result, "%08lx\n", GetLastError());
1061     if (!result) return;
1062
1063     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1064     ok(result, "%08lx\n", GetLastError());
1065     if (!result) return;
1066
1067     result = CryptVerifySignature(hHash, abSignatureMD4, 128, hPubSignKey, NULL, 0);
1068     ok(result, "%08lx\n", GetLastError());
1069     if (!result) return;
1070
1071     result = CryptVerifySignature(hHash, abSignatureMD4NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1072     ok(result, "%08lx\n", GetLastError());
1073     if (!result) return;
1074
1075     result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
1076     ok(result, "%08lx\n", GetLastError());
1077     if (!result) return;
1078
1079     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1080     ok(result, "%08lx\n", GetLastError());
1081     if (!result) return;
1082
1083     result = CryptVerifySignature(hHash, abSignatureMD5, 128, hPubSignKey, NULL, 0);
1084     ok(result, "%08lx\n", GetLastError());
1085     if (!result) return;
1086
1087     result = CryptVerifySignature(hHash, abSignatureMD5NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1088     ok(result, "%08lx\n", GetLastError());
1089     if (!result) return;
1090
1091     result = CryptCreateHash(hProv, CALG_SHA, 0, 0, &hHash);
1092     ok(result, "%08lx\n", GetLastError());
1093     if (!result) return;
1094
1095     result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1096     ok(result, "%08lx\n", GetLastError());
1097     if (!result) return;
1098
1099     result = CryptVerifySignature(hHash, abSignatureSHA, 128, hPubSignKey, NULL, 0);
1100     ok(result, "%08lx\n", GetLastError());
1101     if (!result) return;
1102
1103     result = CryptVerifySignature(hHash, abSignatureSHANoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1104     ok(result, "%08lx\n", GetLastError());
1105     if (!result) return;
1106 }
1107
1108 static void test_rsa_encrypt(void)
1109 {
1110     HCRYPTKEY hRSAKey;
1111     BYTE abData[2048] = "Wine rocks!";
1112     BOOL result;
1113     DWORD dwLen;
1114
1115     /* It is allowed to use the key exchange key for encryption/decryption */
1116     result = CryptGetUserKey(hProv, AT_KEYEXCHANGE, &hRSAKey);
1117     ok (result, "%08lx\n", GetLastError());
1118     if (!result) return;
1119
1120     dwLen = 12;
1121     result = CryptEncrypt(hRSAKey, 0, TRUE, 0, NULL, &dwLen, (DWORD)sizeof(abData));
1122     ok(result, "CryptEncrypt failed: %08lx\n", GetLastError());
1123     ok(dwLen == 128, "Unexpected length %ld\n", dwLen);
1124     dwLen = 12;
1125     result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, (DWORD)sizeof(abData));
1126     ok (result, "%08lx\n", GetLastError());
1127     if (!result) return;
1128
1129     result = CryptDecrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen);
1130     ok (result && dwLen == 12 && !memcmp(abData, "Wine rocks!", 12), "%08lx\n", GetLastError());
1131
1132     CryptDestroyKey(hRSAKey);
1133
1134     /* It is not allowed to use the signature key for encryption/decryption */
1135     result = CryptGetUserKey(hProv, AT_SIGNATURE, &hRSAKey);
1136     ok (result, "%08lx\n", GetLastError());
1137     if (!result) return;
1138
1139     dwLen = 12;
1140     result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, (DWORD)sizeof(abData));
1141     ok (!result && GetLastError() == NTE_BAD_KEY, "%08lx\n", GetLastError());
1142
1143     CryptDestroyKey(hRSAKey);
1144 }
1145
1146 static void test_schannel_provider(void)
1147 {
1148     HCRYPTPROV hProv;
1149     HCRYPTKEY hRSAKey, hMasterSecret, hServerWriteKey, hServerWriteMACKey;
1150     HCRYPTHASH hMasterHash, hTLS1PRF, hHMAC;
1151     BOOL result;
1152     DWORD dwLen;
1153     SCHANNEL_ALG saSChannelAlg;
1154     CRYPT_DATA_BLOB data_blob;
1155     HMAC_INFO hmacInfo = { CALG_MD5, NULL, 0, NULL, 0 };
1156     BYTE abPlainPrivateKey[596] = {
1157         0x07, 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00,
1158         0x52, 0x53, 0x41, 0x32, 0x00, 0x04, 0x00, 0x00,
1159         0x01, 0x00, 0x01, 0x00, 0x9b, 0x64, 0xef, 0xce,
1160         0x31, 0x7c, 0xad, 0x56, 0xe2, 0x1e, 0x9b, 0x96,
1161         0xb3, 0xf0, 0x29, 0x88, 0x6e, 0xa8, 0xc2, 0x11,
1162         0x33, 0xd6, 0xcc, 0x8c, 0x69, 0xb2, 0x1a, 0xfd,
1163         0xfc, 0x23, 0x21, 0x30, 0x4d, 0x29, 0x45, 0xb6,
1164         0x3a, 0x67, 0x11, 0x80, 0x1a, 0x91, 0xf2, 0x9f,
1165         0x01, 0xac, 0xc0, 0x11, 0x50, 0x5f, 0xcd, 0xb9,
1166         0xad, 0x76, 0x9f, 0x6e, 0x91, 0x55, 0x71, 0xda,
1167         0x97, 0x96, 0x96, 0x22, 0x75, 0xb4, 0x83, 0x44,
1168         0x89, 0x9e, 0xf8, 0x44, 0x40, 0x7c, 0xd6, 0xcd,
1169         0x9d, 0x88, 0xd6, 0x88, 0xbc, 0x56, 0xb7, 0x64,
1170         0xe9, 0x2c, 0x24, 0x2f, 0x0d, 0x78, 0x55, 0x1c,
1171         0xb2, 0x67, 0xb1, 0x5e, 0xbc, 0x0c, 0xcf, 0x1c,
1172         0xe9, 0xd3, 0x9e, 0xa2, 0x15, 0x24, 0x73, 0xd6,
1173         0xdb, 0x6f, 0x83, 0xb2, 0xf8, 0xbc, 0xe7, 0x47,
1174         0x3b, 0x01, 0xef, 0x49, 0x08, 0x98, 0xd6, 0xa3,
1175         0xf9, 0x25, 0x57, 0xe9, 0x39, 0x3c, 0x53, 0x30,
1176         0x1b, 0xf2, 0xc9, 0x62, 0x31, 0x43, 0x5d, 0x84,
1177         0x24, 0x30, 0x21, 0x9a, 0xad, 0xdb, 0x62, 0x91,
1178         0xc8, 0x07, 0xd9, 0x2f, 0xd6, 0xb5, 0x37, 0x6f,
1179         0xfe, 0x7a, 0x12, 0xbc, 0xd9, 0xd2, 0x2b, 0xbf,
1180         0xd7, 0xb1, 0xfa, 0x7d, 0xc0, 0x48, 0xdd, 0x74,
1181         0xdd, 0x55, 0x04, 0xa1, 0x8b, 0xc1, 0x0a, 0xc4,
1182         0xa5, 0x57, 0x62, 0xee, 0x08, 0x8b, 0xf9, 0x19,
1183         0x6c, 0x52, 0x06, 0xf8, 0x73, 0x0f, 0x24, 0xc9,
1184         0x71, 0x9f, 0xc5, 0x45, 0x17, 0x3e, 0xae, 0x06,
1185         0x81, 0xa2, 0x96, 0x40, 0x06, 0xbf, 0xeb, 0x9e,
1186         0x80, 0x2b, 0x27, 0x20, 0x8f, 0x38, 0xcf, 0xeb,
1187         0xff, 0x3b, 0x38, 0x41, 0x35, 0x69, 0x66, 0x13,
1188         0x1d, 0x3c, 0x01, 0x3b, 0xf6, 0x37, 0xca, 0x9c,
1189         0x61, 0x74, 0x98, 0xcf, 0xc9, 0x6e, 0xe8, 0x90,
1190         0xc7, 0xb7, 0x33, 0xc0, 0x07, 0x3c, 0xf8, 0xc8,
1191         0xf6, 0xf2, 0xd7, 0xf0, 0x21, 0x62, 0x58, 0x8a,
1192         0x55, 0xbf, 0xa1, 0x2d, 0x3d, 0xa6, 0x69, 0xc5,
1193         0x02, 0x19, 0x31, 0xf0, 0x94, 0x0f, 0x45, 0x5c,
1194         0x95, 0x1b, 0x53, 0xbc, 0xf5, 0xb0, 0x1a, 0x8f,
1195         0xbf, 0x40, 0xe0, 0xc7, 0x73, 0xe7, 0x72, 0x6e,
1196         0xeb, 0xb1, 0x0f, 0x38, 0xc5, 0xf8, 0xee, 0x04,
1197         0xed, 0x34, 0x1a, 0x10, 0xf9, 0x53, 0x34, 0xf3,
1198         0x3e, 0xe6, 0x5c, 0xd1, 0x47, 0x65, 0xcd, 0xbd,
1199         0xf1, 0x06, 0xcb, 0xb4, 0xb1, 0x26, 0x39, 0x9f,
1200         0x71, 0xfe, 0x3d, 0xf8, 0x62, 0xab, 0x22, 0x8b,
1201         0x0e, 0xdc, 0xb9, 0xe8, 0x74, 0x06, 0xfc, 0x8c,
1202         0x25, 0xa1, 0xa9, 0xcf, 0x07, 0xf9, 0xac, 0x21,
1203         0x01, 0x7b, 0x1c, 0xdc, 0x94, 0xbd, 0x47, 0xe1,
1204         0xa0, 0x86, 0x59, 0x35, 0x6a, 0x6f, 0xb9, 0x70,
1205         0x26, 0x7c, 0x3c, 0xfd, 0xbd, 0x81, 0x39, 0x36,
1206         0x42, 0xc2, 0xbd, 0xbe, 0x84, 0x27, 0x9a, 0x69,
1207         0x81, 0xda, 0x99, 0x27, 0xc2, 0x4f, 0x62, 0x33,
1208         0xf4, 0x79, 0x30, 0xc5, 0x63, 0x54, 0x71, 0xf1,
1209         0x47, 0x22, 0x25, 0x9b, 0x6c, 0x00, 0x2f, 0x1c,
1210         0xf4, 0x1f, 0x85, 0xbc, 0xf6, 0x67, 0x6a, 0xe3,
1211         0xf6, 0x55, 0x8a, 0xef, 0xd0, 0x0b, 0xd3, 0xa2,
1212         0xc5, 0x51, 0x70, 0x15, 0x0a, 0xf0, 0x98, 0x4c,
1213         0xb7, 0x19, 0x62, 0x0e, 0x2d, 0x2a, 0x4a, 0x7d,
1214         0x7a, 0x0a, 0xc4, 0x17, 0xe3, 0x5d, 0x20, 0x52,
1215         0xa9, 0x98, 0xc3, 0xaa, 0x11, 0xf6, 0xbf, 0x4c,
1216         0x94, 0x99, 0x81, 0x89, 0xf0, 0x7f, 0x66, 0xaa,
1217         0xc8, 0x88, 0xd7, 0x31, 0x84, 0x71, 0xb6, 0x64,
1218         0x09, 0x76, 0x0b, 0x7f, 0x1a, 0x1f, 0x2e, 0xfe,
1219         0xcd, 0x59, 0x2a, 0x54, 0x11, 0x84, 0xd4, 0x6a,
1220         0x61, 0xdf, 0xaa, 0x76, 0x66, 0x9d, 0x82, 0x11,
1221         0x56, 0x3d, 0xd2, 0x52, 0xe6, 0x42, 0x5a, 0x77,
1222         0x92, 0x98, 0x34, 0xf3, 0x56, 0x6c, 0x96, 0x10,
1223         0x40, 0x59, 0x16, 0xcb, 0x77, 0x61, 0xe3, 0xbf,
1224         0x4b, 0xd4, 0x39, 0xfb, 0xb1, 0x4e, 0xc1, 0x74,
1225         0xec, 0x7a, 0xea, 0x3d, 0x68, 0xbb, 0x0b, 0xe6,
1226         0xc6, 0x06, 0xbf, 0xdd, 0x7f, 0x94, 0x42, 0xc0,
1227         0x0f, 0xe4, 0x92, 0x33, 0x6c, 0x6e, 0x1b, 0xba,
1228         0x73, 0xf9, 0x79, 0x84, 0xdf, 0x45, 0x00, 0xe4,
1229         0x94, 0x88, 0x9d, 0x08, 0x89, 0xcf, 0xf2, 0xa4,
1230         0xc5, 0x47, 0x45, 0x85, 0x86, 0xa5, 0xcc, 0xa8,
1231         0xf2, 0x5d, 0x58, 0x07
1232     };
1233     BYTE abTLS1Master[140] = {
1234         0x01, 0x02, 0x00, 0x00, 0x06, 0x4c, 0x00, 0x00,
1235         0x00, 0xa4, 0x00, 0x00, 0x5b, 0x13, 0xc7, 0x68,
1236         0xd8, 0x55, 0x23, 0x5d, 0xbc, 0xa6, 0x9d, 0x97,
1237         0x0e, 0xcd, 0x6b, 0xcf, 0xc0, 0xdc, 0xc5, 0x53,
1238         0x28, 0xa0, 0xca, 0xc1, 0x63, 0x4e, 0x3a, 0x24,
1239         0x22, 0xe5, 0x4d, 0x15, 0xbb, 0xa5, 0x06, 0xc3,
1240         0x98, 0x25, 0xdc, 0x35, 0xd3, 0xdb, 0xab, 0xb8,
1241         0x44, 0x1b, 0xfe, 0x63, 0x88, 0x7c, 0x2e, 0x6d,
1242         0x34, 0xd9, 0x0f, 0x7e, 0x2f, 0xc2, 0xb2, 0x6e,
1243         0x56, 0xfa, 0xab, 0xb2, 0x88, 0xf6, 0x15, 0x6e,
1244         0xa8, 0xcd, 0x70, 0x16, 0x94, 0x61, 0x07, 0x40,
1245         0x9e, 0x25, 0x22, 0xf8, 0x64, 0x9f, 0xcc, 0x0b,
1246         0xf1, 0x92, 0x4d, 0xfe, 0xc3, 0x5d, 0x52, 0xdb,
1247         0x0f, 0xff, 0x12, 0x0f, 0x49, 0x43, 0x7d, 0xc6,
1248         0x52, 0x61, 0xb0, 0x06, 0xc8, 0x1b, 0x90, 0xac,
1249         0x09, 0x7e, 0x4b, 0x95, 0x69, 0x3b, 0x0d, 0x41,
1250         0x1b, 0x4c, 0x65, 0x75, 0x4d, 0x85, 0x16, 0xc4,
1251         0xd3, 0x1e, 0x82, 0xb3
1252     };
1253     BYTE abServerSecret[33] = "Super Secret Server Secret 12345";
1254     BYTE abClientSecret[33] = "Super Secret Client Secret 12345";
1255     BYTE abHashedHandshakes[37] = "123456789012345678901234567890123456";
1256     BYTE abClientFinished[16] = "client finished";
1257     BYTE abData[16] = "Wine rocks!";
1258     BYTE abMD5Hash[16];
1259     static const BYTE abEncryptedData[16] = {
1260         0x13, 0xd2, 0xdd, 0xeb, 0x6c, 0x3f, 0xbe, 0xb2,
1261         0x04, 0x86, 0xb5, 0xe5, 0x08, 0xe5, 0xf3, 0x0d
1262     };
1263     static const BYTE abPRF[16] = {
1264         0xa8, 0xb2, 0xa6, 0xef, 0x83, 0x4e, 0x74, 0xb1,
1265         0xf3, 0xb1, 0x51, 0x5a, 0x1a, 0x2b, 0x11, 0x31
1266     };
1267     static const BYTE abMD5[16] = {
1268         0xe1, 0x65, 0x3f, 0xdb, 0xbb, 0x3d, 0x99, 0x3c,
1269         0x3d, 0xca, 0x6a, 0x6f, 0xfa, 0x15, 0x4e, 0xaa
1270     };
1271
1272     result = CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT);
1273     ok (result, "%08lx\n", GetLastError());
1274     if (!result) return;
1275
1276     /* To get deterministic results, we import the TLS1 master secret (which
1277      * is typically generated from a random generator). Therefore, we need
1278      * an RSA key. */
1279     dwLen = (DWORD)sizeof(abPlainPrivateKey);
1280     result = CryptImportKey(hProv, abPlainPrivateKey, dwLen, 0, 0, &hRSAKey);
1281     ok (result, "%08lx\n", GetLastError());
1282     if (!result) return;
1283
1284     dwLen = (DWORD)sizeof(abTLS1Master);
1285     result = CryptImportKey(hProv, abTLS1Master, dwLen, hRSAKey, 0, &hMasterSecret);
1286     ok (result, "%08lx\n", GetLastError());
1287     if (!result) return;
1288
1289     /* Setting the TLS1 client and server random parameters, as well as the
1290      * MAC and encryption algorithm parameters. */
1291     data_blob.cbData = 33;
1292     data_blob.pbData = abClientSecret;
1293     result = CryptSetKeyParam(hMasterSecret, KP_CLIENT_RANDOM, (BYTE*)&data_blob, 0);
1294     ok (result, "%08lx\n", GetLastError());
1295     if (!result) return;
1296
1297     data_blob.cbData = 33;
1298     data_blob.pbData = abServerSecret;
1299     result = CryptSetKeyParam(hMasterSecret, KP_SERVER_RANDOM, (BYTE*)&data_blob, 0);
1300     ok (result, "%08lx\n", GetLastError());
1301     if (!result) return;
1302
1303     saSChannelAlg.dwUse = SCHANNEL_ENC_KEY;
1304     saSChannelAlg.Algid = CALG_DES;
1305     saSChannelAlg.cBits = 64;
1306     saSChannelAlg.dwFlags = 0;
1307     saSChannelAlg.dwReserved = 0;
1308     result = CryptSetKeyParam(hMasterSecret, KP_SCHANNEL_ALG, (PBYTE)&saSChannelAlg, 0);
1309     ok (result, "%08lx\n", GetLastError());
1310     if (!result) return;
1311
1312     saSChannelAlg.dwUse = SCHANNEL_MAC_KEY;
1313     saSChannelAlg.Algid = CALG_MD5;
1314     saSChannelAlg.cBits = 128;
1315     saSChannelAlg.dwFlags = 0;
1316     saSChannelAlg.dwReserved = 0;
1317     result = CryptSetKeyParam(hMasterSecret, KP_SCHANNEL_ALG, (PBYTE)&saSChannelAlg, 0);
1318     ok (result, "%08lx\n", GetLastError());
1319     if (!result) return;
1320
1321     /* Deriving a hash from the master secret. This is due to the CryptoAPI architecture.
1322      * (Keys can only be derived from hashes, not from other keys.) */
1323     result = CryptCreateHash(hProv, CALG_SCHANNEL_MASTER_HASH, hMasterSecret, 0, &hMasterHash);
1324     ok (result, "%08lx\n", GetLastError());
1325     if (!result) return;
1326
1327     /* Deriving the server write encryption key from the master hash */
1328     result = CryptDeriveKey(hProv, CALG_SCHANNEL_ENC_KEY, hMasterHash, CRYPT_SERVER, &hServerWriteKey);
1329     ok (result, "%08lx\n", GetLastError());
1330     if (!result) return;
1331
1332     /* Encrypting some data with the server write encryption key and checking the result. */
1333     dwLen = 12;
1334     result = CryptEncrypt(hServerWriteKey, 0, TRUE, 0, abData, &dwLen, 16);
1335     ok (result && (dwLen == 16) && !memcmp(abData, abEncryptedData, 16), "%08lx\n", GetLastError());
1336
1337     /* Second test case: Test the TLS1 pseudo random number function. */
1338     result = CryptCreateHash(hProv, CALG_TLS1PRF, hMasterSecret, 0, &hTLS1PRF);
1339     ok (result, "%08lx\n", GetLastError());
1340     if (!result) return;
1341
1342     /* Set the label and seed parameters for the random number function */
1343     data_blob.cbData = 36;
1344     data_blob.pbData = abHashedHandshakes;
1345     result = CryptSetHashParam(hTLS1PRF, HP_TLS1PRF_SEED, (BYTE*)&data_blob, 0);
1346     ok (result, "%08lx\n", GetLastError());
1347     if (!result) return;
1348
1349     data_blob.cbData = 15;
1350     data_blob.pbData = abClientFinished;
1351     result = CryptSetHashParam(hTLS1PRF, HP_TLS1PRF_LABEL, (BYTE*)&data_blob, 0);
1352     ok (result, "%08lx\n", GetLastError());
1353     if (!result) return;
1354
1355     /* Generate some pseudo random bytes and check if they are correct. */
1356     dwLen = (DWORD)sizeof(abData);
1357     result = CryptGetHashParam(hTLS1PRF, HP_HASHVAL, abData, &dwLen, 0);
1358     ok (result && (dwLen==(DWORD)sizeof(abData)) && !memcmp(abData, abPRF, sizeof(abData)),
1359         "%08lx\n", GetLastError());
1360
1361     /* Third test case. Derive the server write mac key. Derive an HMAC object from this one.
1362      * Hash some data with the HMAC. Compare results. */
1363     result = CryptDeriveKey(hProv, CALG_SCHANNEL_MAC_KEY, hMasterHash, CRYPT_SERVER, &hServerWriteMACKey);
1364     ok (result, "%08lx\n", GetLastError());
1365     if (!result) return;
1366
1367     result = CryptCreateHash(hProv, CALG_HMAC, hServerWriteMACKey, 0, &hHMAC);
1368     ok (result, "%08lx\n", GetLastError());
1369     if (!result) return;
1370
1371     result = CryptSetHashParam(hHMAC, HP_HMAC_INFO, (PBYTE)&hmacInfo, 0);
1372     ok (result, "%08lx\n", GetLastError());
1373     if (!result) return;
1374
1375     result = CryptHashData(hHMAC, abData, (DWORD)sizeof(abData), 0);
1376     ok (result, "%08lx\n", GetLastError());
1377     if (!result) return;
1378
1379     dwLen = (DWORD)sizeof(abMD5Hash);
1380     result = CryptGetHashParam(hHMAC, HP_HASHVAL, abMD5Hash, &dwLen, 0);
1381     ok (result && (dwLen == 16) && !memcmp(abMD5Hash, abMD5, 16), "%08lx\n", GetLastError());
1382
1383     CryptDestroyHash(hHMAC);
1384     CryptDestroyHash(hTLS1PRF);
1385     CryptDestroyHash(hMasterHash);
1386     CryptDestroyKey(hServerWriteMACKey);
1387     CryptDestroyKey(hServerWriteKey);
1388     CryptDestroyKey(hRSAKey);
1389     CryptDestroyKey(hMasterSecret);
1390     CryptReleaseContext(hProv, 0);
1391     CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_DELETEKEYSET);
1392 }
1393
1394 static void test_enum_container(void)
1395 {
1396     BYTE abContainerName[256];
1397     DWORD dwBufferLen;
1398     BOOL result, fFound = FALSE;
1399
1400     /* If PP_ENUMCONTAINERS is queried with CRYPT_FIRST and abData == NULL, it returns
1401      * the maximum legal length of container names (which is MAX_PATH + 1 == 261) */
1402     result = CryptGetProvParam(hProv, PP_ENUMCONTAINERS, NULL, &dwBufferLen, CRYPT_FIRST);
1403     ok (result && dwBufferLen == MAX_PATH + 1, "%08lx\n", GetLastError());
1404
1405     /* If the result fits into abContainerName dwBufferLen is left untouched */
1406     dwBufferLen = (DWORD)sizeof(abContainerName);
1407     result = CryptGetProvParam(hProv, PP_ENUMCONTAINERS, abContainerName, &dwBufferLen, CRYPT_FIRST);
1408     ok (result && dwBufferLen == (DWORD)sizeof(abContainerName), "%08lx\n", GetLastError());
1409
1410     /* We only check, if the currently open 'winetest' container is among the enumerated. */
1411     do {
1412         if (!strcmp((const char*)abContainerName, "winetest")) fFound = TRUE;
1413         dwBufferLen = (DWORD)sizeof(abContainerName);
1414     } while (CryptGetProvParam(hProv, PP_ENUMCONTAINERS, abContainerName, &dwBufferLen, 0));
1415
1416     ok (fFound && GetLastError() == ERROR_NO_MORE_ITEMS, "%d, %08lx\n", fFound, GetLastError());
1417 }
1418
1419 static BYTE signBlob[] = {
1420 0x07,0x02,0x00,0x00,0x00,0x24,0x00,0x00,0x52,0x53,0x41,0x32,0x00,0x02,0x00,0x00,
1421 0x01,0x00,0x01,0x00,0xf1,0x82,0x9e,0x84,0xb5,0x79,0x9a,0xbe,0x4d,0x06,0x20,0x21,
1422 0xb1,0x89,0x0c,0xca,0xb0,0x35,0x72,0x18,0xc6,0x92,0xa8,0xe2,0xb1,0xe1,0xf6,0x56,
1423 0x53,0x99,0x47,0x10,0x6e,0x1c,0x81,0xaf,0xb8,0xf9,0x5f,0xfe,0x76,0x7f,0x2c,0x93,
1424 0xec,0x54,0x7e,0x5e,0xc2,0x25,0x3c,0x50,0x56,0x10,0x20,0x72,0x4a,0x93,0x03,0x12,
1425 0x29,0x98,0xcc,0xc9,0x47,0xbf,0xbf,0x93,0xcc,0xb0,0xe5,0x53,0x14,0xc8,0x7e,0x1f,
1426 0xa4,0x03,0x2d,0x8e,0x84,0x7a,0xd2,0xeb,0xf7,0x92,0x5e,0xa2,0xc7,0x6b,0x35,0x7d,
1427 0xcb,0x60,0xae,0xfb,0x07,0x78,0x11,0x73,0xb5,0x79,0xe5,0x7e,0x96,0xe3,0x50,0x95,
1428 0x80,0x0e,0x1c,0xf6,0x56,0xc6,0xe9,0x0a,0xaf,0x03,0xc6,0xdc,0x9a,0x81,0xcf,0x7a,
1429 0x63,0x16,0x43,0xcd,0xab,0x74,0xa1,0x7d,0xe7,0xe0,0x75,0x6d,0xbd,0x19,0xae,0x0b,
1430 0xa3,0x7f,0x6a,0x7b,0x05,0x4e,0xbc,0xec,0x18,0xfc,0x19,0xc2,0x00,0xf0,0x6a,0x2e,
1431 0xc4,0x31,0x73,0xba,0x07,0xcc,0x9d,0x57,0xeb,0xc7,0x7c,0x00,0x7d,0x5d,0x11,0x16,
1432 0x42,0x4b,0xe5,0x3a,0xf5,0xc7,0xf8,0xee,0xc3,0x2c,0x0d,0x86,0x03,0xe2,0xaf,0xb2,
1433 0xd2,0x91,0xdb,0x71,0xcd,0xdf,0x81,0x5f,0x06,0xfc,0x48,0x0d,0xb6,0x88,0x9f,0xc1,
1434 0x5e,0x24,0xa2,0x05,0x4f,0x30,0x2e,0x8f,0x8b,0x0d,0x76,0xa1,0x84,0xda,0x7b,0x44,
1435 0x70,0x85,0xf1,0x50,0xb1,0x21,0x3d,0xe2,0x57,0x3d,0xd0,0x01,0x93,0x49,0x8e,0xc5,
1436 0x0b,0x8b,0x0d,0x7b,0x08,0xe9,0x14,0xec,0x20,0x0d,0xea,0x02,0x00,0x63,0xe8,0x0a,
1437 0x52,0xe8,0xfb,0x21,0xbd,0x37,0xde,0x4c,0x4d,0xc2,0xf6,0xb9,0x0d,0x2a,0xc3,0xe2,
1438 0xc9,0xdf,0x48,0x3e,0x55,0x3d,0xe3,0xc0,0x22,0x37,0xf9,0x52,0xc0,0xd7,0x61,0x22,
1439 0xb6,0x85,0x86,0x07 };
1440
1441 static void test_null_provider(void)
1442 {
1443     HCRYPTPROV prov;
1444     HCRYPTKEY key;
1445     BOOL result;
1446     DWORD keySpec, dataLen;
1447
1448     result = CryptAcquireContext(NULL, szContainer, NULL, 0, 0);
1449     ok(!result && GetLastError() == NTE_BAD_PROV_TYPE,
1450      "Expected NTE_BAD_PROV_TYPE, got %08lx\n", GetLastError());
1451     result = CryptAcquireContext(NULL, szContainer, NULL, PROV_RSA_FULL, 0);
1452     ok(!result && GetLastError() == ERROR_INVALID_PARAMETER,
1453      "Expected ERROR_INVALID_PARAMETER, got %08lx\n", GetLastError());
1454     result = CryptAcquireContext(NULL, szContainer, NULL, PROV_RSA_FULL,
1455      CRYPT_DELETEKEYSET);
1456     ok(!result && GetLastError() == ERROR_INVALID_PARAMETER,
1457      "Expected ERROR_INVALID_PARAMETER, got %08lx\n", GetLastError());
1458     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1459      CRYPT_DELETEKEYSET);
1460     ok(!result && GetLastError() == NTE_BAD_KEYSET,
1461      "Expected NTE_BAD_KEYSET, got %08lx\n", GetLastError());
1462     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL, 0);
1463     ok(!result && GetLastError() == NTE_BAD_KEYSET,
1464      "Expected NTE_BAD_KEYSET, got %08lx\n", GetLastError());
1465
1466     /* Delete the default container. */
1467     CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
1468     /* Once you've deleted the default container you can't open it as if it
1469      * already exists.
1470      */
1471     result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, 0);
1472     ok(!result && GetLastError() == NTE_BAD_KEYSET,
1473      "Expected NTE_BAD_KEYSET, got %08lx\n", GetLastError());
1474     /* But you can always open the default container for CRYPT_VERIFYCONTEXT. */
1475     result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL,
1476      CRYPT_VERIFYCONTEXT);
1477     ok(result, "CryptAcquireContext failed: %08lx\n", GetLastError());
1478     if (!result) return;
1479     dataLen = sizeof(keySpec);
1480     result = CryptGetProvParam(prov, PP_KEYSPEC, (LPBYTE)&keySpec, &dataLen, 0);
1481     if (result)
1482         ok(keySpec == (AT_KEYEXCHANGE | AT_SIGNATURE),
1483          "Expected AT_KEYEXCHANGE | AT_SIGNATURE, got %08lx\n", keySpec);
1484     /* Even though PP_KEYSPEC says both AT_KEYEXCHANGE and AT_SIGNATURE are
1485      * supported, you can't get the keys from this container.
1486      */
1487     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1488     ok(!result && GetLastError() == NTE_NO_KEY,
1489      "Expected NTE_NO_KEY, got %08lx\n", GetLastError());
1490     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1491     ok(!result && GetLastError() == NTE_NO_KEY,
1492      "Expected NTE_NO_KEY, got %08lx\n", GetLastError());
1493     result = CryptReleaseContext(prov, 0);
1494     ok(result, "CryptReleaseContext failed: %08lx\n", GetLastError());
1495     /* You can create a new default container. */
1496     result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL,
1497      CRYPT_NEWKEYSET);
1498     ok(result, "CryptAcquireContext failed: %08lx\n", GetLastError());
1499     /* But you still can't get the keys (until one's been generated.) */
1500     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1501     ok(!result && GetLastError() == NTE_NO_KEY,
1502      "Expected NTE_NO_KEY, got %08lx\n", GetLastError());
1503     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1504     ok(!result && GetLastError() == NTE_NO_KEY,
1505      "Expected NTE_NO_KEY, got %08lx\n", GetLastError());
1506     CryptReleaseContext(prov, 0);
1507     CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
1508
1509     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1510      CRYPT_DELETEKEYSET);
1511     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL, 0);
1512     ok(!result && GetLastError() == NTE_BAD_KEYSET,
1513      "Expected NTE_BAD_KEYSET, got %08lx\n", GetLastError());
1514     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1515      CRYPT_VERIFYCONTEXT);
1516     ok(!result && GetLastError() == NTE_BAD_FLAGS,
1517      "Expected NTE_BAD_FLAGS, got %08lx\n", GetLastError());
1518     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1519      CRYPT_NEWKEYSET);
1520     ok(result, "CryptAcquireContext failed: %08lx\n", GetLastError());
1521     if (!result) return;
1522     dataLen = sizeof(keySpec);
1523     result = CryptGetProvParam(prov, PP_KEYSPEC, (LPBYTE)&keySpec, &dataLen, 0);
1524     if (result)
1525         ok(keySpec == (AT_KEYEXCHANGE | AT_SIGNATURE),
1526          "Expected AT_KEYEXCHANGE | AT_SIGNATURE, got %08lx\n", keySpec);
1527     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1528     ok(!result && GetLastError() == NTE_NO_KEY,
1529      "Expected NTE_NO_KEY, got %08lx\n", GetLastError());
1530     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1531     ok(!result && GetLastError() == NTE_NO_KEY,
1532      "Expected NTE_NO_KEY, got %08lx\n", GetLastError());
1533
1534     /* Importing a key exchange blob.. */
1535     result = CryptImportKey(prov, abPlainPrivateKey, sizeof(abPlainPrivateKey),
1536      0, 0, &key);
1537     ok(result, "CryptImportKey failed: %08lx\n", GetLastError());
1538     CryptDestroyKey(key);
1539     /* allows access to the key exchange key.. */
1540     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1541     ok(result, "CryptGetUserKey failed: %08lx\n", GetLastError());
1542     CryptDestroyKey(key);
1543     /* but not to the private key. */
1544     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1545     ok(!result && GetLastError() == NTE_NO_KEY,
1546      "Expected NTE_NO_KEY, got %08lx\n", GetLastError());
1547     CryptReleaseContext(prov, 0);
1548     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1549      CRYPT_DELETEKEYSET);
1550
1551     /* Whereas importing a sign blob.. */
1552     result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1553      CRYPT_NEWKEYSET);
1554     ok(result, "CryptAcquireContext failed: %08lx\n", GetLastError());
1555     if (!result) return;
1556     result = CryptImportKey(prov, signBlob, sizeof(signBlob), 0, 0, &key);
1557     ok(result, "CryptGenKey failed: %08lx\n", GetLastError());
1558     /* doesn't allow access to the key exchange key.. */
1559     result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1560     ok(!result && GetLastError() == NTE_NO_KEY,
1561      "Expected NTE_NO_KEY, got %08lx\n", GetLastError());
1562     /* but does to the private key. */
1563     result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1564     ok(result, "CryptGetUserKey failed: %08lx\n", GetLastError());
1565     CryptDestroyKey(key);
1566
1567     CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1568      CRYPT_DELETEKEYSET);
1569 }
1570
1571 START_TEST(rsaenh)
1572 {
1573     if (!init_environment())
1574         return;
1575     test_prov();
1576     test_gen_random();
1577     test_hashes();
1578     test_rc4();
1579     test_rc2();
1580     test_des();
1581     test_3des112();
1582     test_3des();
1583     test_hmac();
1584     test_mac();
1585     test_block_cipher_modes();
1586     test_import_private();
1587     test_verify_signature();
1588     test_rsa_encrypt();
1589     test_enum_container();
1590     clean_up_environment();
1591     test_schannel_provider();
1592     test_null_provider();
1593 }