?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 735ae92a6c6e93f1d42ab1ae3fd17e22de57873e
[wine/hacks.git] / dlls / rsaenh / tests / rsaenh.c
blobb51a0a526ee205760f99c00f3be6a09a20b017cb
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, %08x\n", result, GetLastError());
65
66 if (!CryptAcquireContext(&hProv, szContainer, szProvider, PROV_RSA_FULL, 0))
67 {
68 ok(GetLastError()==NTE_BAD_KEYSET, "%08x\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, "%08x\n", GetLastError());
73 if (!result) return 0;
74 result = CryptGenKey(hProv, AT_KEYEXCHANGE, 0, &hKey);
75 ok(result, "%08x\n", GetLastError());
76 if (result) CryptDestroyKey(hKey);
77 result = CryptGenKey(hProv, AT_SIGNATURE, 0, &hKey);
78 ok(result, "%08x\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, "%08x\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, "%08x, %d\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, "%08x, %d\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, "%08x\n", GetLastError());
123
124 result = CryptGenRandom(hProv, sizeof(rnd2), rnd2);
125 ok(result, "%08x\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, "%08x\n", GetLastError());
143 return FALSE;
144 }
145 ok(result, "%08x\n", GetLastError());
146 if (!result) return FALSE;
147 result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
148 ok(result, "%08x\n", GetLastError());
149 if (!result) return FALSE;
150 result = CryptDeriveKey(hProv, aiAlgid, hHash, (len << 16) | CRYPT_EXPORTABLE, phKey);
151 ok(result, "%08x\n", GetLastError());
152 if (!result) return FALSE;
153 len = 2000;
154 result = CryptGetHashParam(hHash, HP_HASHVAL, pbData, &len, 0);
155 ok(result, "%08x\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, "%08x\n", GetLastError());
188 } else {
189 result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
190 ok(result, "%08x\n", GetLastError());
191
192 len = sizeof(DWORD);
193 result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
194 ok(result && (hashlen == 16), "%08x, hashlen: %d\n", GetLastError(), hashlen);
195
196 len = 16;
197 result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
198 ok(result, "%08x\n", GetLastError());
199
200 ok(!memcmp(pbHashValue, md2hash, 16), "Wrong MD2 hash!\n");
201
202 result = CryptDestroyHash(hHash);
203 ok(result, "%08x\n", GetLastError());
204 }
205
206 /* MD4 Hashing */
207 result = CryptCreateHash(hProv, CALG_MD4, 0, 0, &hHash);
208 ok(result, "%08x\n", GetLastError());
209
210 result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
211 ok(result, "%08x\n", GetLastError());
212
213 len = sizeof(DWORD);
214 result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
215 ok(result && (hashlen == 16), "%08x, hashlen: %d\n", GetLastError(), hashlen);
216
217 len = 16;
218 result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
219 ok(result, "%08x\n", GetLastError());
220
221 ok(!memcmp(pbHashValue, md4hash, 16), "Wrong MD4 hash!\n");
222
223 result = CryptDestroyHash(hHash);
224 ok(result, "%08x\n", GetLastError());
225
226 /* MD5 Hashing */
227 result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
228 ok(result, "%08x\n", GetLastError());
229
230 result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
231 ok(result, "%08x\n", GetLastError());
232
233 len = sizeof(DWORD);
234 result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
235 ok(result && (hashlen == 16), "%08x, hashlen: %d\n", GetLastError(), hashlen);
236
237 len = 16;
238 result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0);
239 ok(result, "%08x\n", GetLastError());
240
241 ok(!memcmp(pbHashValue, md5hash, 16), "Wrong MD5 hash!\n");
242
243 result = CryptDestroyHash(hHash);
244 ok(result, "%08x\n", GetLastError());
245
246 /* SHA1 Hashing */
247 result = CryptCreateHash(hProv, CALG_SHA, 0, 0, &hHash);
248 ok(result, "%08x\n", GetLastError());
249
250 result = CryptHashData(hHash, (BYTE*)pbData, 5, 0);
251 ok(result, "%08x\n", GetLastError());
252
253 if(pCryptDuplicateHash) {
254 result = pCryptDuplicateHash(hHash, 0, 0, &hHashClone);
255 ok(result, "%08x\n", GetLastError());
256
257 result = CryptHashData(hHashClone, (BYTE*)pbData+5, sizeof(pbData)-5, 0);
258 ok(result, "%08x\n", GetLastError());
259
260 len = sizeof(DWORD);
261 result = CryptGetHashParam(hHashClone, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0);
262 ok(result && (hashlen == 20), "%08x, hashlen: %d\n", GetLastError(), hashlen);
263
264 len = 20;
265 result = CryptGetHashParam(hHashClone, HP_HASHVAL, pbHashValue, &len, 0);
266 ok(result, "%08x\n", GetLastError());
267
268 ok(!memcmp(pbHashValue, sha1hash, 20), "Wrong SHA1 hash!\n");
269
270 result = CryptDestroyHash(hHashClone);
271 ok(result, "%08x\n", GetLastError());
272 }
273
274 result = CryptDestroyHash(hHash);
275 ok(result, "%08x\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, "%08x\n", GetLastError());
305
306 dwLen = 23;
307 result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, NULL, &dwLen, 24);
308 ok(result, "CryptEncrypt failed: %08x\n", GetLastError());
309 ok(dwLen == 24, "Unexpected length %d\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 "%08x, dwLen: %d\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 "%08x, dwLen: %d\n", GetLastError(), dwLen);
320
321 dwMode = CRYPT_MODE_CBC;
322 result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
323 ok(result, "%08x\n", GetLastError());
324
325 dwLen = 23;
326 result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, NULL, &dwLen, 24);
327 ok(result, "CryptEncrypt failed: %08x\n", GetLastError());
328 ok(dwLen == 24, "Unexpected length %d\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 "%08x, dwLen: %d\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 "%08x, dwLen: %d\n", GetLastError(), dwLen);
338
339 dwMode = CRYPT_MODE_CFB;
340 result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
341 ok(result, "%08x\n", GetLastError());
342
343 dwLen = 16;
344 result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, FALSE, 0, abData, &dwLen, 24);
345 ok(result && dwLen == 16, "%08x, dwLen: %d\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 "%08x, dwLen: %d\n", GetLastError(), dwLen);
351
352 dwLen = 8;
353 result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, FALSE, 0, abData, &dwLen);
354 ok(result && dwLen == 8, "%08x, dwLen: %d\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 "%08x, dwLen: %d\n", GetLastError(), dwLen);
360
361 dwMode = CRYPT_MODE_OFB;
362 result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
363 ok(result, "%08x\n", GetLastError());
364
365 dwLen = 23;
366 result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, abData, &dwLen, 24);
367 ok(!result && GetLastError() == NTE_BAD_ALGID, "%08x\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, "%08x\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, "%08x\n", GetLastError());
390
391 result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwLen);
392 ok(result, "%08x\n", GetLastError());
393
394 result = CryptDestroyKey(hKey);
395 ok(result, "%08x\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, "%08x\n", GetLastError());
410 return;
411 }
412
413 dwMode = CRYPT_MODE_ECB;
414 result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
415 ok(result, "%08x\n", GetLastError());
416
417 dwLen = sizeof(DWORD);
418 result = CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0);
419 ok(result, "%08x\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, "%08x\n", GetLastError());
426
427 result = CryptDecrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwLen);
428 ok(result, "%08x\n", GetLastError());
429
430 result = CryptDestroyKey(hKey);
431 ok(result, "%08x\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, "%08x\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, "%08x\n", GetLastError());
458
459 result = CryptDestroyKey(hKey);
460 ok(result, "%08x\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, "%08x\n", GetLastError());
482 } else {
483 result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
484 ok(result, "%08x\n", GetLastError());
485
486 dwLen = 16;
487 result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &dwLen, 0);
488 ok(result, "%08x\n", GetLastError());
489
490 result = CryptDeriveKey(hProv, CALG_RC2, hHash, 56 << 16, &hKey);
491 ok(result, "%08x\n", GetLastError());
492
493 dwLen = sizeof(DWORD);
494 result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
495 ok(result, "%08x\n", GetLastError());
496
497 dwMode = CRYPT_MODE_CBC;
498 result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
499 ok(result, "%08x\n", GetLastError());
500
501 dwLen = sizeof(DWORD);
502 result = CryptGetKeyParam(hKey, KP_MODE_BITS, (BYTE*)&dwModeBits, &dwLen, 0);
503 ok(result, "%08x\n", GetLastError());
504
505 dwLen = sizeof(DWORD);
506 result = CryptGetKeyParam(hKey, KP_PERMISSIONS, (BYTE*)&dwModeBits, &dwLen, 0);
507 ok(result, "%08x\n", GetLastError());
508
509 dwLen = sizeof(DWORD);
510 result = CryptGetKeyParam(hKey, KP_BLOCKLEN, (BYTE*)&dwModeBits, &dwLen, 0);
511 ok(result, "%08x\n", GetLastError());
512
513 result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0);
514 ok(result, "%08x\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, "%08x\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, "%08x\n", GetLastError());
530
531 dwDataLen = 13;
532 result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwDataLen, 24);
533 ok(result, "%08x\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, "%08x\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, "%08x\n", GetLastError());
545
546 result = CryptDestroyKey(hKey);
547 ok(result, "%08x\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, "%08x\n", GetLastError());
571 } else {
572 result = CryptHashData(hHash, (BYTE*)pbData, sizeof(pbData), 0);
573 ok(result, "%08x\n", GetLastError());
574
575 dwLen = 16;
576 result = CryptGetHashParam(hHash, HP_HASHVAL, pszBuffer, &dwLen, 0);
577 ok(result, "%08x\n", GetLastError());
578
579 result = CryptDeriveKey(hProv, CALG_RC4, hHash, 56 << 16, &hKey);
580 ok(result, "%08x\n", GetLastError());
581
582 dwLen = sizeof(DWORD);
583 result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
584 ok(result, "%08x\n", GetLastError());
585
586 dwLen = sizeof(DWORD);
587 result = CryptGetKeyParam(hKey, KP_BLOCKLEN, (BYTE*)&dwKeyLen, &dwLen, 0);
588 ok(result, "%08x\n", GetLastError());
589
590 result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0);
591 ok(result, "%08x\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, "%08x\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, "%08x\n", GetLastError());
607
608 dwDataLen = 16;
609 result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, NULL, &dwDataLen, 24);
610 ok(result, "%08x\n", GetLastError());
611 dwDataLen = 16;
612 result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, pbData, &dwDataLen, 24);
613 ok(result, "%08x\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, "%08x\n", GetLastError());
619
620 result = CryptDestroyKey(hKey);
621 ok(result, "%08x\n", GetLastError());
622 }
623 }
624
625 static void test_hmac(void) {
626 HCRYPTKEY hKey;
627 HCRYPTHASH hHash;
628 BOOL result;
629 /* Using CALG_MD2 here fails on Windows 2003, why ? */
630 HMAC_INFO hmacInfo = { CALG_MD5, NULL, 0, NULL, 0 };
631 DWORD dwLen;
632 BYTE abData[256];
633 static const BYTE hmac[16] = {
634 0x1a, 0x7d, 0x49, 0xc5, 0x9b, 0x2d, 0x0b, 0x9c,
635 0xcf, 0x10, 0x6b, 0xb6, 0x7d, 0x0f, 0x13, 0x32 };
636 int i;
637
638 for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abData[i] = (BYTE)i;
639
640 if (!derive_key(CALG_RC2, &hKey, 56)) return;
641
642 result = CryptCreateHash(hProv, CALG_HMAC, hKey, 0, &hHash);
643 ok(result, "%08x\n", GetLastError());
644 if (!result) return;
645
646 result = CryptSetHashParam(hHash, HP_HMAC_INFO, (BYTE*)&hmacInfo, 0);
647 ok(result, "%08x\n", GetLastError());
648
649 result = CryptHashData(hHash, (BYTE*)abData, sizeof(abData), 0);
650 ok(result, "%08x\n", GetLastError());
651
652 dwLen = sizeof(abData)/sizeof(BYTE);
653 result = CryptGetHashParam(hHash, HP_HASHVAL, abData, &dwLen, 0);
654 ok(result, "%08x\n", GetLastError());
655
656 ok(!memcmp(abData, hmac, sizeof(hmac)), "HMAC failed!\n");
657
658 result = CryptDestroyHash(hHash);
659 ok(result, "%08x\n", GetLastError());
660
661 result = CryptDestroyKey(hKey);
662 ok(result, "%08x\n", GetLastError());
663
664 /* Provoke errors */
665 result = CryptCreateHash(hProv, CALG_HMAC, 0, 0, &hHash);
666 ok(!result && GetLastError() == NTE_BAD_KEY, "%08x\n", GetLastError());
667 }
668
669 static void test_mac(void) {
670 HCRYPTKEY hKey;
671 HCRYPTHASH hHash;
672 BOOL result;
673 DWORD dwLen;
674 BYTE abData[256], abEnc[264];
675 static const BYTE mac[8] = { 0x0d, 0x3e, 0x15, 0x6b, 0x85, 0x63, 0x5c, 0x11 };
676 int i;
677
678 for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abData[i] = (BYTE)i;
679 for (i=0; i<sizeof(abData)/sizeof(BYTE); i++) abEnc[i] = (BYTE)i;
680
681 if (!derive_key(CALG_RC2, &hKey, 56)) return;
682
683 dwLen = 256;
684 result = CryptEncrypt(hKey, (HCRYPTHASH)NULL, TRUE, 0, abEnc, &dwLen, 264);
685 ok (result && dwLen == 264, "%08x, dwLen: %d\n", GetLastError(), dwLen);
686
687 result = CryptCreateHash(hProv, CALG_MAC, hKey, 0, &hHash);
688 ok(result, "%08x\n", GetLastError());
689 if (!result) return;
690
691 result = CryptHashData(hHash, (BYTE*)abData, sizeof(abData), 0);
692 ok(result, "%08x\n", GetLastError());
693
694 dwLen = sizeof(abData)/sizeof(BYTE);
695 result = CryptGetHashParam(hHash, HP_HASHVAL, abData, &dwLen, 0);
696 ok(result && dwLen == 8, "%08x, dwLen: %d\n", GetLastError(), dwLen);
697
698 ok(!memcmp(abData, mac, sizeof(mac)), "MAC failed!\n");
699
700 result = CryptDestroyHash(hHash);
701 ok(result, "%08x\n", GetLastError());
702
703 result = CryptDestroyKey(hKey);
704 ok(result, "%08x\n", GetLastError());
705
706 /* Provoke errors */
707 if (!derive_key(CALG_RC4, &hKey, 56)) return;
708
709 result = CryptCreateHash(hProv, CALG_MAC, hKey, 0, &hHash);
710 ok(!result && GetLastError() == NTE_BAD_KEY, "%08x\n", GetLastError());
711
712 result = CryptDestroyKey(hKey);
713 ok(result, "%08x\n", GetLastError());
714 }
715
716 static BYTE abPlainPrivateKey[596] = {
717 0x07, 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00,
718 0x52, 0x53, 0x41, 0x32, 0x00, 0x04, 0x00, 0x00,
719 0x01, 0x00, 0x01, 0x00, 0x9b, 0x64, 0xef, 0xce,
720 0x31, 0x7c, 0xad, 0x56, 0xe2, 0x1e, 0x9b, 0x96,
721 0xb3, 0xf0, 0x29, 0x88, 0x6e, 0xa8, 0xc2, 0x11,
722 0x33, 0xd6, 0xcc, 0x8c, 0x69, 0xb2, 0x1a, 0xfd,
723 0xfc, 0x23, 0x21, 0x30, 0x4d, 0x29, 0x45, 0xb6,
724 0x3a, 0x67, 0x11, 0x80, 0x1a, 0x91, 0xf2, 0x9f,
725 0x01, 0xac, 0xc0, 0x11, 0x50, 0x5f, 0xcd, 0xb9,
726 0xad, 0x76, 0x9f, 0x6e, 0x91, 0x55, 0x71, 0xda,
727 0x97, 0x96, 0x96, 0x22, 0x75, 0xb4, 0x83, 0x44,
728 0x89, 0x9e, 0xf8, 0x44, 0x40, 0x7c, 0xd6, 0xcd,
729 0x9d, 0x88, 0xd6, 0x88, 0xbc, 0x56, 0xb7, 0x64,
730 0xe9, 0x2c, 0x24, 0x2f, 0x0d, 0x78, 0x55, 0x1c,
731 0xb2, 0x67, 0xb1, 0x5e, 0xbc, 0x0c, 0xcf, 0x1c,
732 0xe9, 0xd3, 0x9e, 0xa2, 0x15, 0x24, 0x73, 0xd6,
733 0xdb, 0x6f, 0x83, 0xb2, 0xf8, 0xbc, 0xe7, 0x47,
734 0x3b, 0x01, 0xef, 0x49, 0x08, 0x98, 0xd6, 0xa3,
735 0xf9, 0x25, 0x57, 0xe9, 0x39, 0x3c, 0x53, 0x30,
736 0x1b, 0xf2, 0xc9, 0x62, 0x31, 0x43, 0x5d, 0x84,
737 0x24, 0x30, 0x21, 0x9a, 0xad, 0xdb, 0x62, 0x91,
738 0xc8, 0x07, 0xd9, 0x2f, 0xd6, 0xb5, 0x37, 0x6f,
739 0xfe, 0x7a, 0x12, 0xbc, 0xd9, 0xd2, 0x2b, 0xbf,
740 0xd7, 0xb1, 0xfa, 0x7d, 0xc0, 0x48, 0xdd, 0x74,
741 0xdd, 0x55, 0x04, 0xa1, 0x8b, 0xc1, 0x0a, 0xc4,
742 0xa5, 0x57, 0x62, 0xee, 0x08, 0x8b, 0xf9, 0x19,
743 0x6c, 0x52, 0x06, 0xf8, 0x73, 0x0f, 0x24, 0xc9,
744 0x71, 0x9f, 0xc5, 0x45, 0x17, 0x3e, 0xae, 0x06,
745 0x81, 0xa2, 0x96, 0x40, 0x06, 0xbf, 0xeb, 0x9e,
746 0x80, 0x2b, 0x27, 0x20, 0x8f, 0x38, 0xcf, 0xeb,
747 0xff, 0x3b, 0x38, 0x41, 0x35, 0x69, 0x66, 0x13,
748 0x1d, 0x3c, 0x01, 0x3b, 0xf6, 0x37, 0xca, 0x9c,
749 0x61, 0x74, 0x98, 0xcf, 0xc9, 0x6e, 0xe8, 0x90,
750 0xc7, 0xb7, 0x33, 0xc0, 0x07, 0x3c, 0xf8, 0xc8,
751 0xf6, 0xf2, 0xd7, 0xf0, 0x21, 0x62, 0x58, 0x8a,
752 0x55, 0xbf, 0xa1, 0x2d, 0x3d, 0xa6, 0x69, 0xc5,
753 0x02, 0x19, 0x31, 0xf0, 0x94, 0x0f, 0x45, 0x5c,
754 0x95, 0x1b, 0x53, 0xbc, 0xf5, 0xb0, 0x1a, 0x8f,
755 0xbf, 0x40, 0xe0, 0xc7, 0x73, 0xe7, 0x72, 0x6e,
756 0xeb, 0xb1, 0x0f, 0x38, 0xc5, 0xf8, 0xee, 0x04,
757 0xed, 0x34, 0x1a, 0x10, 0xf9, 0x53, 0x34, 0xf3,
758 0x3e, 0xe6, 0x5c, 0xd1, 0x47, 0x65, 0xcd, 0xbd,
759 0xf1, 0x06, 0xcb, 0xb4, 0xb1, 0x26, 0x39, 0x9f,
760 0x71, 0xfe, 0x3d, 0xf8, 0x62, 0xab, 0x22, 0x8b,
761 0x0e, 0xdc, 0xb9, 0xe8, 0x74, 0x06, 0xfc, 0x8c,
762 0x25, 0xa1, 0xa9, 0xcf, 0x07, 0xf9, 0xac, 0x21,
763 0x01, 0x7b, 0x1c, 0xdc, 0x94, 0xbd, 0x47, 0xe1,
764 0xa0, 0x86, 0x59, 0x35, 0x6a, 0x6f, 0xb9, 0x70,
765 0x26, 0x7c, 0x3c, 0xfd, 0xbd, 0x81, 0x39, 0x36,
766 0x42, 0xc2, 0xbd, 0xbe, 0x84, 0x27, 0x9a, 0x69,
767 0x81, 0xda, 0x99, 0x27, 0xc2, 0x4f, 0x62, 0x33,
768 0xf4, 0x79, 0x30, 0xc5, 0x63, 0x54, 0x71, 0xf1,
769 0x47, 0x22, 0x25, 0x9b, 0x6c, 0x00, 0x2f, 0x1c,
770 0xf4, 0x1f, 0x85, 0xbc, 0xf6, 0x67, 0x6a, 0xe3,
771 0xf6, 0x55, 0x8a, 0xef, 0xd0, 0x0b, 0xd3, 0xa2,
772 0xc5, 0x51, 0x70, 0x15, 0x0a, 0xf0, 0x98, 0x4c,
773 0xb7, 0x19, 0x62, 0x0e, 0x2d, 0x2a, 0x4a, 0x7d,
774 0x7a, 0x0a, 0xc4, 0x17, 0xe3, 0x5d, 0x20, 0x52,
775 0xa9, 0x98, 0xc3, 0xaa, 0x11, 0xf6, 0xbf, 0x4c,
776 0x94, 0x99, 0x81, 0x89, 0xf0, 0x7f, 0x66, 0xaa,
777 0xc8, 0x88, 0xd7, 0x31, 0x84, 0x71, 0xb6, 0x64,
778 0x09, 0x76, 0x0b, 0x7f, 0x1a, 0x1f, 0x2e, 0xfe,
779 0xcd, 0x59, 0x2a, 0x54, 0x11, 0x84, 0xd4, 0x6a,
780 0x61, 0xdf, 0xaa, 0x76, 0x66, 0x9d, 0x82, 0x11,
781 0x56, 0x3d, 0xd2, 0x52, 0xe6, 0x42, 0x5a, 0x77,
782 0x92, 0x98, 0x34, 0xf3, 0x56, 0x6c, 0x96, 0x10,
783 0x40, 0x59, 0x16, 0xcb, 0x77, 0x61, 0xe3, 0xbf,
784 0x4b, 0xd4, 0x39, 0xfb, 0xb1, 0x4e, 0xc1, 0x74,
785 0xec, 0x7a, 0xea, 0x3d, 0x68, 0xbb, 0x0b, 0xe6,
786 0xc6, 0x06, 0xbf, 0xdd, 0x7f, 0x94, 0x42, 0xc0,
787 0x0f, 0xe4, 0x92, 0x33, 0x6c, 0x6e, 0x1b, 0xba,
788 0x73, 0xf9, 0x79, 0x84, 0xdf, 0x45, 0x00, 0xe4,
789 0x94, 0x88, 0x9d, 0x08, 0x89, 0xcf, 0xf2, 0xa4,
790 0xc5, 0x47, 0x45, 0x85, 0x86, 0xa5, 0xcc, 0xa8,
791 0xf2, 0x5d, 0x58, 0x07
792 };
793
794 static void test_import_private(void)
795 {
796 DWORD dwLen;
797 HCRYPTKEY hKeyExchangeKey, hSessionKey;
798 BOOL result;
799 static BYTE abSessionKey[148] = {
800 0x01, 0x02, 0x00, 0x00, 0x01, 0x68, 0x00, 0x00,
801 0x00, 0xa4, 0x00, 0x00, 0xb8, 0xa4, 0xdf, 0x5e,
802 0x9e, 0xb1, 0xbf, 0x85, 0x3d, 0x24, 0x2d, 0x1e,
803 0x69, 0xb7, 0x67, 0x13, 0x8e, 0x78, 0xf2, 0xdf,
804 0xc6, 0x69, 0xce, 0x46, 0x7e, 0xf2, 0xf2, 0x33,
805 0x20, 0x6f, 0xa1, 0xa5, 0x59, 0x83, 0x25, 0xcb,
806 0x3a, 0xb1, 0x8a, 0x12, 0x63, 0x02, 0x3c, 0xfb,
807 0x4a, 0xfa, 0xef, 0x8e, 0xf7, 0x29, 0x57, 0xb1,
808 0x9e, 0xa7, 0xf3, 0x02, 0xfd, 0xca, 0xdf, 0x5a,
809 0x1f, 0x71, 0xb6, 0x26, 0x09, 0x24, 0x39, 0xda,
810 0xc0, 0xde, 0x2a, 0x0e, 0xcd, 0x1f, 0xe5, 0xb6,
811 0x4f, 0x82, 0xa0, 0xa9, 0x90, 0xd3, 0xd9, 0x6a,
812 0x43, 0x14, 0x2a, 0xf7, 0xac, 0xd5, 0xa0, 0x54,
813 0x93, 0xc4, 0xb9, 0xe7, 0x24, 0x84, 0x4d, 0x69,
814 0x5e, 0xcc, 0x2a, 0x32, 0xb5, 0xfb, 0xe4, 0xb4,
815 0x08, 0xd5, 0x36, 0x58, 0x59, 0x40, 0xfb, 0x29,
816 0x7f, 0xa7, 0x17, 0x25, 0xc4, 0x0d, 0x78, 0x37,
817 0x04, 0x8c, 0x49, 0x92
818 };
819 static BYTE abEncryptedMessage[12] = {
820 0x40, 0x64, 0x28, 0xe8, 0x8a, 0xe7, 0xa4, 0xd4,
821 0x1c, 0xfd, 0xde, 0x71
822 };
823
824 dwLen = (DWORD)sizeof(abPlainPrivateKey);
825 result = CryptImportKey(hProv, abPlainPrivateKey, dwLen, 0, 0, &hKeyExchangeKey);
826 if (!result) {
827 /* rsaenh compiled without OpenSSL */
828 ok(GetLastError() == NTE_FAIL, "%08x\n", GetLastError());
829 return;
830 }
831
832 dwLen = (DWORD)sizeof(abSessionKey);
833 result = CryptImportKey(hProv, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey);
834 ok(result, "%08x\n", GetLastError());
835 if (!result) return;
836
837 dwLen = (DWORD)sizeof(abEncryptedMessage);
838 result = CryptDecrypt(hSessionKey, 0, TRUE, 0, abEncryptedMessage, &dwLen);
839 ok(result && dwLen == 12 && !memcmp(abEncryptedMessage, "Wine rocks!",12),
840 "%08x, len: %d\n", GetLastError(), dwLen);
841
842 if (!derive_key(CALG_RC4, &hSessionKey, 56)) return;
843
844 dwLen = (DWORD)sizeof(abSessionKey);
845 result = CryptExportKey(hSessionKey, hKeyExchangeKey, SIMPLEBLOB, 0, abSessionKey, &dwLen);
846 ok(result, "%08x\n", GetLastError());
847 if (!result) return;
848
849 dwLen = (DWORD)sizeof(abSessionKey);
850 result = CryptImportKey(hProv, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey);
851 ok(result, "%08x\n", GetLastError());
852 if (!result) return;
853 }
854
855 static void test_verify_signature(void) {
856 HCRYPTHASH hHash;
857 HCRYPTKEY hPubSignKey;
858 BYTE abData[] = "Wine rocks!";
859 BOOL result;
860 BYTE abPubKey[148] = {
861 0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
862 0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00,
863 0x01, 0x00, 0x01, 0x00, 0x71, 0x64, 0x9f, 0x19,
864 0x89, 0x1c, 0x21, 0xcc, 0x36, 0xa3, 0xc9, 0x27,
865 0x08, 0x8a, 0x09, 0xc6, 0xbe, 0xeb, 0xd3, 0xf8,
866 0x19, 0xa9, 0x92, 0x57, 0xe4, 0xb9, 0x5d, 0xda,
867 0x88, 0x93, 0xe4, 0x6b, 0x38, 0x77, 0x14, 0x8a,
868 0x96, 0xc0, 0xb6, 0x4e, 0x42, 0xf5, 0x01, 0xdc,
869 0xf0, 0xeb, 0x3c, 0xc7, 0x7b, 0xc4, 0xfd, 0x7c,
870 0xde, 0x93, 0x34, 0x0a, 0x92, 0xe5, 0x97, 0x9c,
871 0x3e, 0x65, 0xb8, 0x91, 0x2f, 0xe3, 0xf3, 0x89,
872 0xcd, 0x6c, 0x26, 0xa4, 0x6c, 0xc7, 0x6d, 0x0b,
873 0x2c, 0xa2, 0x0b, 0x29, 0xe2, 0xfc, 0x30, 0xfa,
874 0x20, 0xdb, 0x4c, 0xb8, 0x91, 0xb8, 0x69, 0x63,
875 0x96, 0x41, 0xc2, 0xb4, 0x60, 0xeb, 0xcd, 0xff,
876 0x3a, 0x1f, 0x94, 0xb1, 0x23, 0xcf, 0x0f, 0x49,
877 0xad, 0xd5, 0x33, 0x85, 0x71, 0xaf, 0x12, 0x87,
878 0x84, 0xef, 0xa0, 0xea, 0xe1, 0xc1, 0xd4, 0xc7,
879 0xe1, 0x21, 0x50, 0xac
880 };
881 /* md2 with hash oid */
882 BYTE abSignatureMD2[128] = {
883 0x4a, 0x4e, 0xb7, 0x5e, 0x32, 0xda, 0xdb, 0x67,
884 0x9f, 0x77, 0x84, 0x32, 0x00, 0xba, 0x5f, 0x6b,
885 0x0d, 0xcf, 0xd9, 0x99, 0xbd, 0x96, 0x31, 0xda,
886 0x23, 0x4c, 0xd9, 0x4a, 0x90, 0x84, 0x20, 0x59,
887 0x51, 0xdc, 0xd4, 0x93, 0x3a, 0xae, 0x0a, 0x0a,
888 0xa1, 0x76, 0xfa, 0xb5, 0x68, 0xee, 0xc7, 0x34,
889 0x41, 0xd3, 0xe7, 0x5a, 0x0e, 0x22, 0x61, 0x40,
890 0xea, 0x24, 0x56, 0xf1, 0x91, 0x5a, 0xf7, 0xa7,
891 0x5b, 0xf4, 0x98, 0x6b, 0xc3, 0xef, 0xad, 0xc0,
892 0x5e, 0x6b, 0x87, 0x76, 0xcb, 0x1f, 0x62, 0x06,
893 0x7c, 0xf6, 0x48, 0x97, 0x81, 0x8d, 0xef, 0x51,
894 0x51, 0xdc, 0x21, 0x91, 0x57, 0x1e, 0x79, 0x6f,
895 0x49, 0xb5, 0xde, 0x31, 0x07, 0x45, 0x99, 0x46,
896 0xc3, 0x4f, 0xca, 0x2d, 0x0e, 0x4c, 0x10, 0x25,
897 0xcb, 0x1a, 0x98, 0x63, 0x41, 0x93, 0x47, 0xc0,
898 0xb2, 0xbc, 0x10, 0x3c, 0xe7, 0xd4, 0x3c, 0x1e
899 };
900 /* md2 without hash oid */
901 BYTE abSignatureMD2NoOID[128] = {
902 0x0c, 0x21, 0x3e, 0x60, 0xf9, 0xd0, 0x36, 0x2d,
903 0xe1, 0x10, 0x45, 0x45, 0x85, 0x03, 0x29, 0x19,
904 0xef, 0x19, 0xd9, 0xa6, 0x7e, 0x9c, 0x0d, 0xbd,
905 0x03, 0x0e, 0xb9, 0x51, 0x9e, 0x74, 0x79, 0xc4,
906 0xde, 0x25, 0xf2, 0x35, 0x74, 0x55, 0xbc, 0x65,
907 0x7e, 0x33, 0x28, 0xa8, 0x1e, 0x72, 0xaa, 0x99,
908 0xdd, 0xf5, 0x26, 0x20, 0x29, 0xf8, 0xa6, 0xdf,
909 0x28, 0x4b, 0x1c, 0xdb, 0xa1, 0x41, 0x56, 0xbc,
910 0xf9, 0x9c, 0x66, 0xc0, 0x37, 0x41, 0x55, 0xa0,
911 0xe2, 0xec, 0xbf, 0x71, 0xf0, 0x5d, 0x25, 0x01,
912 0x75, 0x91, 0xe2, 0x81, 0xb2, 0x9f, 0x57, 0xa7,
913 0x5c, 0xd2, 0xfa, 0x66, 0xdb, 0x71, 0x2b, 0x1f,
914 0xad, 0x30, 0xde, 0xea, 0x49, 0x73, 0x30, 0x6a,
915 0x22, 0x54, 0x49, 0x4e, 0xae, 0xf6, 0x88, 0xc9,
916 0xff, 0x71, 0xba, 0xbf, 0x27, 0xc5, 0xfa, 0x06,
917 0xe2, 0x91, 0x71, 0x8a, 0x7e, 0x0c, 0xc2, 0x07
918 };
919 /* md4 with hash oid */
920 BYTE abSignatureMD4[128] = {
921 0x1c, 0x78, 0xaa, 0xea, 0x74, 0xf4, 0x83, 0x51,
922 0xae, 0x66, 0xe3, 0xa9, 0x1c, 0x03, 0x39, 0x1b,
923 0xac, 0x7e, 0x4e, 0x85, 0x7e, 0x1c, 0x38, 0xd2,
924 0x82, 0x43, 0xb3, 0x6f, 0x6f, 0x46, 0x45, 0x8e,
925 0x17, 0x74, 0x58, 0x29, 0xca, 0xe1, 0x03, 0x13,
926 0x45, 0x79, 0x34, 0xdf, 0x5c, 0xd6, 0xc3, 0xf9,
927 0x7a, 0x1c, 0x9d, 0xff, 0x6f, 0x03, 0x7d, 0x0f,
928 0x59, 0x1a, 0x2d, 0x0e, 0x94, 0xb4, 0x75, 0x96,
929 0xd1, 0x48, 0x63, 0x6e, 0xb2, 0xc4, 0x5c, 0xd9,
930 0xab, 0x49, 0xb4, 0x90, 0xd9, 0x57, 0x04, 0x6e,
931 0x4c, 0xb6, 0xea, 0x00, 0x94, 0x4a, 0x34, 0xa0,
932 0xd9, 0x63, 0xef, 0x2c, 0xde, 0x5b, 0xb9, 0xbe,
933 0x35, 0xc8, 0xc1, 0x31, 0xb5, 0x31, 0x15, 0x18,
934 0x90, 0x39, 0xf5, 0x2a, 0x34, 0x6d, 0xb4, 0xab,
935 0x09, 0x34, 0x69, 0x54, 0x4d, 0x11, 0x2f, 0xf3,
936 0xa2, 0x36, 0x0e, 0xa8, 0x45, 0xe7, 0x36, 0xac
937 };
938 /* md4 without hash oid */
939 BYTE abSignatureMD4NoOID[128] = {
940 0xd3, 0x60, 0xb2, 0xb0, 0x22, 0x0a, 0x99, 0xda,
941 0x04, 0x85, 0x64, 0xc6, 0xc6, 0xdb, 0x11, 0x24,
942 0xe9, 0x68, 0x2d, 0xf7, 0x09, 0xef, 0xb6, 0xa0,
943 0xa2, 0xfe, 0x45, 0xee, 0x85, 0x49, 0xcd, 0x36,
944 0xf7, 0xc7, 0x9d, 0x2b, 0x4c, 0x68, 0xda, 0x85,
945 0x8c, 0x50, 0xcc, 0x4f, 0x4b, 0xe1, 0x82, 0xc3,
946 0xbe, 0xa3, 0xf1, 0x78, 0x6b, 0x60, 0x42, 0x3f,
947 0x67, 0x22, 0x14, 0xe4, 0xe1, 0xa4, 0x6e, 0xa9,
948 0x4e, 0xf1, 0xd4, 0xb0, 0xce, 0x82, 0xac, 0x06,
949 0xba, 0x2c, 0xbc, 0xf7, 0xcb, 0xf6, 0x0c, 0x3f,
950 0xf6, 0x79, 0xfe, 0xb3, 0xd8, 0x5a, 0xbc, 0xdb,
951 0x05, 0x41, 0xa4, 0x07, 0x57, 0x9e, 0xa2, 0x96,
952 0xfc, 0x60, 0x4b, 0xf7, 0x6f, 0x86, 0x26, 0x1f,
953 0xc2, 0x2c, 0x67, 0x08, 0xcd, 0x7f, 0x91, 0xe9,
954 0x16, 0xb5, 0x0e, 0xd9, 0xc4, 0xc4, 0x97, 0xeb,
955 0x91, 0x3f, 0x20, 0x6c, 0xf0, 0x68, 0x86, 0x7f
956 };
957 /* md5 with hash oid */
958 BYTE abSignatureMD5[128] = {
959 0x4f, 0xe0, 0x8c, 0x9b, 0x43, 0xdd, 0x02, 0xe5,
960 0xf4, 0xa1, 0xdd, 0x88, 0x4c, 0x9c, 0x40, 0x0f,
961 0x6c, 0x43, 0x86, 0x64, 0x00, 0xe6, 0xac, 0xf7,
962 0xd0, 0x92, 0xaa, 0xc4, 0x62, 0x9a, 0x48, 0x98,
963 0x1a, 0x56, 0x6d, 0x75, 0xec, 0x04, 0x89, 0xec,
964 0x69, 0x93, 0xd6, 0x61, 0x37, 0xb2, 0x36, 0xb5,
965 0xb2, 0xba, 0xf2, 0xf5, 0x21, 0x0c, 0xf1, 0x04,
966 0xc8, 0x2d, 0xf5, 0xa0, 0x8d, 0x6d, 0x10, 0x0b,
967 0x68, 0x63, 0xf2, 0x08, 0x68, 0xdc, 0xbd, 0x95,
968 0x25, 0x7d, 0xee, 0x63, 0x5c, 0x3b, 0x98, 0x4c,
969 0xea, 0x41, 0xdc, 0x6a, 0x8b, 0x6c, 0xbb, 0x29,
970 0x2b, 0x1c, 0x5c, 0x8b, 0x7d, 0x94, 0x24, 0xa9,
971 0x7a, 0x62, 0x94, 0xf3, 0x3a, 0x6a, 0xb2, 0x4c,
972 0x33, 0x59, 0x00, 0xcd, 0x7d, 0x37, 0x79, 0x90,
973 0x31, 0xd1, 0xd9, 0x84, 0x12, 0xe5, 0x08, 0x5e,
974 0xb3, 0x60, 0x61, 0x27, 0x78, 0x37, 0x63, 0x01
975 };
976 /* md5 without hash oid */
977 BYTE abSignatureMD5NoOID[128] = {
978 0xc6, 0xad, 0x5c, 0x2b, 0x9b, 0xe0, 0x99, 0x2f,
979 0x5e, 0x55, 0x04, 0x32, 0x65, 0xe0, 0xb5, 0x75,
980 0x01, 0x9a, 0x11, 0x4d, 0x0e, 0x9a, 0xe1, 0x9f,
981 0xc7, 0xbf, 0x77, 0x6d, 0xa9, 0xfd, 0xcc, 0x9d,
982 0x8b, 0xd1, 0x31, 0xed, 0x5a, 0xd2, 0xe5, 0x5f,
983 0x42, 0x3b, 0xb5, 0x3c, 0x32, 0x30, 0x88, 0x49,
984 0xcb, 0x67, 0xb8, 0x2e, 0xc9, 0xf5, 0x2b, 0xc8,
985 0x35, 0x71, 0xb5, 0x1b, 0x32, 0x3f, 0x44, 0x4c,
986 0x66, 0x93, 0xcb, 0xe8, 0x48, 0x7c, 0x14, 0x23,
987 0xfb, 0x12, 0xa5, 0xb7, 0x86, 0x94, 0x6b, 0x19,
988 0x17, 0x20, 0xc6, 0xb8, 0x09, 0xe8, 0xbb, 0xdb,
989 0x00, 0x2b, 0x96, 0x4a, 0x93, 0x00, 0x26, 0xd3,
990 0x07, 0xa0, 0x06, 0xce, 0x5a, 0x13, 0x69, 0x6b,
991 0x62, 0x5a, 0x56, 0x61, 0x6a, 0xd8, 0x11, 0x3b,
992 0xd5, 0x67, 0xc7, 0x4d, 0xf6, 0x66, 0x63, 0xc5,
993 0xe3, 0x8f, 0x7c, 0x7c, 0xb1, 0x3e, 0x55, 0x43
994 };
995 /* sha with hash oid */
996 BYTE abSignatureSHA[128] = {
997 0x5a, 0x4c, 0x66, 0xc9, 0x30, 0x67, 0xcb, 0x91,
998 0x3c, 0x4d, 0xd5, 0x8d, 0xea, 0x4e, 0x85, 0xcd,
999 0xd9, 0x68, 0x3a, 0xf3, 0x24, 0x3c, 0x99, 0x24,
1000 0x25, 0x32, 0x93, 0x3d, 0xd6, 0x2f, 0x86, 0x94,
1001 0x23, 0x09, 0xee, 0x02, 0xd4, 0x15, 0xdc, 0x5f,
1002 0x0e, 0x44, 0x45, 0x13, 0x5f, 0x18, 0x5d, 0x1a,
1003 0xd7, 0x0b, 0xd1, 0x23, 0xd6, 0x35, 0x98, 0x52,
1004 0x57, 0x45, 0x74, 0x92, 0xe3, 0x50, 0xb4, 0x20,
1005 0x28, 0x2a, 0x11, 0xbf, 0x49, 0xb4, 0x2c, 0xc5,
1006 0xd4, 0x1a, 0x27, 0x4e, 0xdf, 0xa0, 0xb5, 0x7a,
1007 0xc8, 0x14, 0xdd, 0x9b, 0xb6, 0xca, 0xd6, 0xff,
1008 0xb2, 0x6b, 0xd8, 0x98, 0x67, 0x80, 0xab, 0x53,
1009 0x52, 0xbb, 0xe1, 0x2a, 0xce, 0x79, 0x2f, 0x00,
1010 0x53, 0x26, 0xd8, 0xa7, 0x43, 0xca, 0x72, 0x0e,
1011 0x68, 0x97, 0x37, 0x71, 0x87, 0xc2, 0x6a, 0x98,
1012 0xbb, 0x6c, 0xa0, 0x01, 0xff, 0x04, 0x9d, 0xa6
1013 };
1014 /* sha without hash oid */
1015 BYTE abSignatureSHANoOID[128] = {
1016 0x86, 0xa6, 0x2b, 0x9a, 0x04, 0xda, 0x47, 0xc6,
1017 0x4f, 0x97, 0x8a, 0x8a, 0xf4, 0xfa, 0x63, 0x1a,
1018 0x32, 0x89, 0x56, 0x41, 0x37, 0x91, 0x15, 0x2f,
1019 0x2d, 0x1c, 0x8f, 0xdc, 0x88, 0x40, 0xbb, 0x37,
1020 0x3e, 0x06, 0x33, 0x1b, 0xde, 0xda, 0x7c, 0x65,
1021 0x91, 0x35, 0xca, 0x45, 0x17, 0x0e, 0x24, 0xbe,
1022 0x9e, 0xf6, 0x4e, 0x8a, 0xa4, 0x3e, 0xca, 0xe6,
1023 0x11, 0x36, 0xb8, 0x3a, 0xf0, 0xde, 0x71, 0xfe,
1024 0xdd, 0xb3, 0xcb, 0x6c, 0x39, 0xe0, 0x5f, 0x0c,
1025 0x9e, 0xa8, 0x40, 0x26, 0x9c, 0x81, 0xe9, 0xc4,
1026 0x15, 0x90, 0xbf, 0x4f, 0xd2, 0xc1, 0xa1, 0x80,
1027 0x52, 0xfd, 0xf6, 0x3d, 0x99, 0x1b, 0x9c, 0x8a,
1028 0x27, 0x1b, 0x0c, 0x9a, 0xf3, 0xf9, 0xa2, 0x00,
1029 0x3e, 0x5b, 0xdf, 0xc2, 0xb4, 0x71, 0xa5, 0xbd,
1030 0xf8, 0xae, 0x63, 0xbb, 0x4a, 0xc9, 0xdd, 0x67,
1031 0xc1, 0x3e, 0x93, 0xee, 0xf1, 0x1f, 0x24, 0x5b
1032 };
1033
1034 result = CryptImportKey(hProv, abPubKey, 148, 0, 0, &hPubSignKey);
1035 ok(result, "%08x\n", GetLastError());
1036 if (!result) return;
1037
1038 result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash);
1039 ok(result, "%08x\n", GetLastError());
1040 if (!result) return;
1041
1042 result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1043 ok(result, "%08x\n", GetLastError());
1044 if (!result) return;
1045
1046 result = CryptVerifySignature(hHash, abSignatureMD2, 128, hPubSignKey, NULL, 0);
1047 ok(result, "%08x\n", GetLastError());
1048 if (!result) return;
1049
1050 result = CryptVerifySignature(hHash, abSignatureMD2NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1051 ok(result, "%08x\n", GetLastError());
1052 if (!result) return;
1053
1054 /* Next test fails on WinXP SP2. It seems that CPVerifySignature doesn't care about
1055 * the OID at all. */
1056 /*result = CryptVerifySignature(hHash, abSignatureMD2NoOID, 128, hPubSignKey, NULL, 0);
1057 ok(!result && GetLastError()==NTE_BAD_SIGNATURE, "%08lx\n", GetLastError());
1058 if (result) return;*/
1059
1060 result = CryptCreateHash(hProv, CALG_MD4, 0, 0, &hHash);
1061 ok(result, "%08x\n", GetLastError());
1062 if (!result) return;
1063
1064 result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1065 ok(result, "%08x\n", GetLastError());
1066 if (!result) return;
1067
1068 result = CryptVerifySignature(hHash, abSignatureMD4, 128, hPubSignKey, NULL, 0);
1069 ok(result, "%08x\n", GetLastError());
1070 if (!result) return;
1071
1072 result = CryptVerifySignature(hHash, abSignatureMD4NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1073 ok(result, "%08x\n", GetLastError());
1074 if (!result) return;
1075
1076 result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash);
1077 ok(result, "%08x\n", GetLastError());
1078 if (!result) return;
1079
1080 result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1081 ok(result, "%08x\n", GetLastError());
1082 if (!result) return;
1083
1084 result = CryptVerifySignature(hHash, abSignatureMD5, 128, hPubSignKey, NULL, 0);
1085 ok(result, "%08x\n", GetLastError());
1086 if (!result) return;
1087
1088 result = CryptVerifySignature(hHash, abSignatureMD5NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1089 ok(result, "%08x\n", GetLastError());
1090 if (!result) return;
1091
1092 result = CryptCreateHash(hProv, CALG_SHA, 0, 0, &hHash);
1093 ok(result, "%08x\n", GetLastError());
1094 if (!result) return;
1095
1096 result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0);
1097 ok(result, "%08x\n", GetLastError());
1098 if (!result) return;
1099
1100 result = CryptVerifySignature(hHash, abSignatureSHA, 128, hPubSignKey, NULL, 0);
1101 ok(result, "%08x\n", GetLastError());
1102 if (!result) return;
1103
1104 result = CryptVerifySignature(hHash, abSignatureSHANoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID);
1105 ok(result, "%08x\n", GetLastError());
1106 if (!result) return;
1107 }
1108
1109 static void test_rsa_encrypt(void)
1110 {
1111 HCRYPTKEY hRSAKey;
1112 BYTE abData[2048] = "Wine rocks!";
1113 BOOL result;
1114 DWORD dwLen;
1115
1116 /* It is allowed to use the key exchange key for encryption/decryption */
1117 result = CryptGetUserKey(hProv, AT_KEYEXCHANGE, &hRSAKey);
1118 ok (result, "%08x\n", GetLastError());
1119 if (!result) return;
1120
1121 dwLen = 12;
1122 result = CryptEncrypt(hRSAKey, 0, TRUE, 0, NULL, &dwLen, (DWORD)sizeof(abData));
1123 ok(result, "CryptEncrypt failed: %08x\n", GetLastError());
1124 ok(dwLen == 128, "Unexpected length %d\n", dwLen);
1125 dwLen = 12;
1126 result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, (DWORD)sizeof(abData));
1127 ok (result, "%08x\n", GetLastError());
1128 if (!result) return;
1129
1130 result = CryptDecrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen);
1131 ok (result && dwLen == 12 && !memcmp(abData, "Wine rocks!", 12), "%08x\n", GetLastError());
1132
1133 CryptDestroyKey(hRSAKey);
1134
1135 /* It is not allowed to use the signature key for encryption/decryption */
1136 result = CryptGetUserKey(hProv, AT_SIGNATURE, &hRSAKey);
1137 ok (result, "%08x\n", GetLastError());
1138 if (!result) return;
1139
1140 dwLen = 12;
1141 result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, (DWORD)sizeof(abData));
1142 ok (!result && GetLastError() == NTE_BAD_KEY, "%08x\n", GetLastError());
1143
1144 CryptDestroyKey(hRSAKey);
1145 }
1146
1147 static void test_import_export(void)
1148 {
1149 DWORD dwLen, dwDataLen;
1150 HCRYPTKEY hPublicKey;
1151 BOOL result;
1152 ALG_ID algID;
1153 BYTE emptyKey[2048];
1154 static BYTE abPlainPublicKey[84] = {
1155 0x06, 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00,
1156 0x52, 0x53, 0x41, 0x31, 0x00, 0x02, 0x00, 0x00,
1157 0x01, 0x00, 0x01, 0x00, 0x11, 0x11, 0x11, 0x11,
1158 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1159 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1160 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1161 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1162 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1163 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1164 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1165 0x11, 0x11, 0x11, 0x11
1166 };
1167
1168 dwLen=84;
1169 result = CryptImportKey(hProv, abPlainPublicKey, dwLen, 0, 0, &hPublicKey);
1170 ok(result, "failed to import the public key\n");
1171
1172 dwDataLen=sizeof(algID);
1173 result = CryptGetKeyParam(hPublicKey, KP_ALGID, (LPBYTE)&algID, &dwDataLen, 0);
1174 ok(result, "failed to get the KP_ALGID from the imported public key\n");
1175 ok(algID == CALG_RSA_KEYX, "Expected CALG_RSA_KEYX, got %x\n", algID);
1176
1177 result = CryptExportKey(hPublicKey, 0, PUBLICKEYBLOB, 0, emptyKey, &dwLen);
1178 ok(result, "failed to export the fresh imported public key\n");
1179 ok(dwLen == 84, "Expected exported key to be 84 bytes long but got %d bytes.\n",dwLen);
1180 ok(!memcmp(emptyKey, abPlainPublicKey, dwLen), "exported key is different from the imported key\n");
1181 }
1182
1183 static void test_schannel_provider(void)
1184 {
1185 HCRYPTPROV hProv;
1186 HCRYPTKEY hRSAKey, hMasterSecret, hServerWriteKey, hServerWriteMACKey;
1187 HCRYPTHASH hMasterHash, hTLS1PRF, hHMAC;
1188 BOOL result;
1189 DWORD dwLen;
1190 SCHANNEL_ALG saSChannelAlg;
1191 CRYPT_DATA_BLOB data_blob;
1192 HMAC_INFO hmacInfo = { CALG_MD5, NULL, 0, NULL, 0 };
1193 BYTE abPlainPrivateKey[596] = {
1194 0x07, 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00,
1195 0x52, 0x53, 0x41, 0x32, 0x00, 0x04, 0x00, 0x00,
1196 0x01, 0x00, 0x01, 0x00, 0x9b, 0x64, 0xef, 0xce,
1197 0x31, 0x7c, 0xad, 0x56, 0xe2, 0x1e, 0x9b, 0x96,
1198 0xb3, 0xf0, 0x29, 0x88, 0x6e, 0xa8, 0xc2, 0x11,
1199 0x33, 0xd6, 0xcc, 0x8c, 0x69, 0xb2, 0x1a, 0xfd,
1200 0xfc, 0x23, 0x21, 0x30, 0x4d, 0x29, 0x45, 0xb6,
1201 0x3a, 0x67, 0x11, 0x80, 0x1a, 0x91, 0xf2, 0x9f,
1202 0x01, 0xac, 0xc0, 0x11, 0x50, 0x5f, 0xcd, 0xb9,
1203 0xad, 0x76, 0x9f, 0x6e, 0x91, 0x55, 0x71, 0xda,
1204 0x97, 0x96, 0x96, 0x22, 0x75, 0xb4, 0x83, 0x44,
1205 0x89, 0x9e, 0xf8, 0x44, 0x40, 0x7c, 0xd6, 0xcd,
1206 0x9d, 0x88, 0xd6, 0x88, 0xbc, 0x56, 0xb7, 0x64,
1207 0xe9, 0x2c, 0x24, 0x2f, 0x0d, 0x78, 0x55, 0x1c,
1208 0xb2, 0x67, 0xb1, 0x5e, 0xbc, 0x0c, 0xcf, 0x1c,
1209 0xe9, 0xd3, 0x9e, 0xa2, 0x15, 0x24, 0x73, 0xd6,
1210 0xdb, 0x6f, 0x83, 0xb2, 0xf8, 0xbc, 0xe7, 0x47,
1211 0x3b, 0x01, 0xef, 0x49, 0x08, 0x98, 0xd6, 0xa3,
1212 0xf9, 0x25, 0x57, 0xe9, 0x39, 0x3c, 0x53, 0x30,
1213 0x1b, 0xf2, 0xc9, 0x62, 0x31, 0x43, 0x5d, 0x84,
1214 0x24, 0x30, 0x21, 0x9a, 0xad, 0xdb, 0x62, 0x91,
1215 0xc8, 0x07, 0xd9, 0x2f, 0xd6, 0xb5, 0x37, 0x6f,
1216 0xfe, 0x7a, 0x12, 0xbc, 0xd9, 0xd2, 0x2b, 0xbf,
1217 0xd7, 0xb1, 0xfa, 0x7d, 0xc0, 0x48, 0xdd, 0x74,
1218 0xdd, 0x55, 0x04, 0xa1, 0x8b, 0xc1, 0x0a, 0xc4,
1219 0xa5, 0x57, 0x62, 0xee, 0x08, 0x8b, 0xf9, 0x19,
1220 0x6c, 0x52, 0x06, 0xf8, 0x73, 0x0f, 0x24, 0xc9,
1221 0x71, 0x9f, 0xc5, 0x45, 0x17, 0x3e, 0xae, 0x06,
1222 0x81, 0xa2, 0x96, 0x40, 0x06, 0xbf, 0xeb, 0x9e,
1223 0x80, 0x2b, 0x27, 0x20, 0x8f, 0x38, 0xcf, 0xeb,
1224 0xff, 0x3b, 0x38, 0x41, 0x35, 0x69, 0x66, 0x13,
1225 0x1d, 0x3c, 0x01, 0x3b, 0xf6, 0x37, 0xca, 0x9c,
1226 0x61, 0x74, 0x98, 0xcf, 0xc9, 0x6e, 0xe8, 0x90,
1227 0xc7, 0xb7, 0x33, 0xc0, 0x07, 0x3c, 0xf8, 0xc8,
1228 0xf6, 0xf2, 0xd7, 0xf0, 0x21, 0x62, 0x58, 0x8a,
1229 0x55, 0xbf, 0xa1, 0x2d, 0x3d, 0xa6, 0x69, 0xc5,
1230 0x02, 0x19, 0x31, 0xf0, 0x94, 0x0f, 0x45, 0x5c,
1231 0x95, 0x1b, 0x53, 0xbc, 0xf5, 0xb0, 0x1a, 0x8f,
1232 0xbf, 0x40, 0xe0, 0xc7, 0x73, 0xe7, 0x72, 0x6e,
1233 0xeb, 0xb1, 0x0f, 0x38, 0xc5, 0xf8, 0xee, 0x04,
1234 0xed, 0x34, 0x1a, 0x10, 0xf9, 0x53, 0x34, 0xf3,
1235 0x3e, 0xe6, 0x5c, 0xd1, 0x47, 0x65, 0xcd, 0xbd,
1236 0xf1, 0x06, 0xcb, 0xb4, 0xb1, 0x26, 0x39, 0x9f,
1237 0x71, 0xfe, 0x3d, 0xf8, 0x62, 0xab, 0x22, 0x8b,
1238 0x0e, 0xdc, 0xb9, 0xe8, 0x74, 0x06, 0xfc, 0x8c,
1239 0x25, 0xa1, 0xa9, 0xcf, 0x07, 0xf9, 0xac, 0x21,
1240 0x01, 0x7b, 0x1c, 0xdc, 0x94, 0xbd, 0x47, 0xe1,
1241 0xa0, 0x86, 0x59, 0x35, 0x6a, 0x6f, 0xb9, 0x70,
1242 0x26, 0x7c, 0x3c, 0xfd, 0xbd, 0x81, 0x39, 0x36,
1243 0x42, 0xc2, 0xbd, 0xbe, 0x84, 0x27, 0x9a, 0x69,
1244 0x81, 0xda, 0x99, 0x27, 0xc2, 0x4f, 0x62, 0x33,
1245 0xf4, 0x79, 0x30, 0xc5, 0x63, 0x54, 0x71, 0xf1,
1246 0x47, 0x22, 0x25, 0x9b, 0x6c, 0x00, 0x2f, 0x1c,
1247 0xf4, 0x1f, 0x85, 0xbc, 0xf6, 0x67, 0x6a, 0xe3,
1248 0xf6, 0x55, 0x8a, 0xef, 0xd0, 0x0b, 0xd3, 0xa2,
1249 0xc5, 0x51, 0x70, 0x15, 0x0a, 0xf0, 0x98, 0x4c,
1250 0xb7, 0x19, 0x62, 0x0e, 0x2d, 0x2a, 0x4a, 0x7d,
1251 0x7a, 0x0a, 0xc4, 0x17, 0xe3, 0x5d, 0x20, 0x52,
1252 0xa9, 0x98, 0xc3, 0xaa, 0x11, 0xf6, 0xbf, 0x4c,
1253 0x94, 0x99, 0x81, 0x89, 0xf0, 0x7f, 0x66, 0xaa,
1254 0xc8, 0x88, 0xd7, 0x31, 0x84, 0x71, 0xb6, 0x64,
1255 0x09, 0x76, 0x0b, 0x7f, 0x1a, 0x1f, 0x2e, 0xfe,
1256 0xcd, 0x59, 0x2a, 0x54, 0x11, 0x84, 0xd4, 0x6a,
1257 0x61, 0xdf, 0xaa, 0x76, 0x66, 0x9d, 0x82, 0x11,
1258 0x56, 0x3d, 0xd2, 0x52, 0xe6, 0x42, 0x5a, 0x77,
1259 0x92, 0x98, 0x34, 0xf3, 0x56, 0x6c, 0x96, 0x10,
1260 0x40, 0x59, 0x16, 0xcb, 0x77, 0x61, 0xe3, 0xbf,
1261 0x4b, 0xd4, 0x39, 0xfb, 0xb1, 0x4e, 0xc1, 0x74,
1262 0xec, 0x7a, 0xea, 0x3d, 0x68, 0xbb, 0x0b, 0xe6,
1263 0xc6, 0x06, 0xbf, 0xdd, 0x7f, 0x94, 0x42, 0xc0,
1264 0x0f, 0xe4, 0x92, 0x33, 0x6c, 0x6e, 0x1b, 0xba,
1265 0x73, 0xf9, 0x79, 0x84, 0xdf, 0x45, 0x00, 0xe4,
1266 0x94, 0x88, 0x9d, 0x08, 0x89, 0xcf, 0xf2, 0xa4,
1267 0xc5, 0x47, 0x45, 0x85, 0x86, 0xa5, 0xcc, 0xa8,
1268 0xf2, 0x5d, 0x58, 0x07
1269 };
1270 BYTE abTLS1Master[140] = {
1271 0x01, 0x02, 0x00, 0x00, 0x06, 0x4c, 0x00, 0x00,
1272 0x00, 0xa4, 0x00, 0x00, 0x5b, 0x13, 0xc7, 0x68,
1273 0xd8, 0x55, 0x23, 0x5d, 0xbc, 0xa6, 0x9d, 0x97,
1274 0x0e, 0xcd, 0x6b, 0xcf, 0xc0, 0xdc, 0xc5, 0x53,
1275 0x28, 0xa0, 0xca, 0xc1, 0x63, 0x4e, 0x3a, 0x24,
1276 0x22, 0xe5, 0x4d, 0x15, 0xbb, 0xa5, 0x06, 0xc3,
1277 0x98, 0x25, 0xdc, 0x35, 0xd3, 0xdb, 0xab, 0xb8,
1278 0x44, 0x1b, 0xfe, 0x63, 0x88, 0x7c, 0x2e, 0x6d,
1279 0x34, 0xd9, 0x0f, 0x7e, 0x2f, 0xc2, 0xb2, 0x6e,
1280 0x56, 0xfa, 0xab, 0xb2, 0x88, 0xf6, 0x15, 0x6e,
1281 0xa8, 0xcd, 0x70, 0x16, 0x94, 0x61, 0x07, 0x40,
1282 0x9e, 0x25, 0x22, 0xf8, 0x64, 0x9f, 0xcc, 0x0b,
1283 0xf1, 0x92, 0x4d, 0xfe, 0xc3, 0x5d, 0x52, 0xdb,
1284 0x0f, 0xff, 0x12, 0x0f, 0x49, 0x43, 0x7d, 0xc6,
1285 0x52, 0x61, 0xb0, 0x06, 0xc8, 0x1b, 0x90, 0xac,
1286 0x09, 0x7e, 0x4b, 0x95, 0x69, 0x3b, 0x0d, 0x41,
1287 0x1b, 0x4c, 0x65, 0x75, 0x4d, 0x85, 0x16, 0xc4,
1288 0xd3, 0x1e, 0x82, 0xb3
1289 };
1290 BYTE abServerSecret[33] = "Super Secret Server Secret 12345";
1291 BYTE abClientSecret[33] = "Super Secret Client Secret 12345";
1292 BYTE abHashedHandshakes[37] = "123456789012345678901234567890123456";
1293 BYTE abClientFinished[16] = "client finished";
1294 BYTE abData[16] = "Wine rocks!";
1295 BYTE abMD5Hash[16];
1296 static const BYTE abEncryptedData[16] = {
1297 0x13, 0xd2, 0xdd, 0xeb, 0x6c, 0x3f, 0xbe, 0xb2,
1298 0x04, 0x86, 0xb5, 0xe5, 0x08, 0xe5, 0xf3, 0x0d
1299 };
1300 static const BYTE abPRF[16] = {
1301 0xa8, 0xb2, 0xa6, 0xef, 0x83, 0x4e, 0x74, 0xb1,
1302 0xf3, 0xb1, 0x51, 0x5a, 0x1a, 0x2b, 0x11, 0x31
1303 };
1304 static const BYTE abMD5[16] = {
1305 0xe1, 0x65, 0x3f, 0xdb, 0xbb, 0x3d, 0x99, 0x3c,
1306 0x3d, 0xca, 0x6a, 0x6f, 0xfa, 0x15, 0x4e, 0xaa
1307 };
1308
1309 result = CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT);
1310 ok (result, "%08x\n", GetLastError());
1311 if (!result) return;
1312
1313 /* To get deterministic results, we import the TLS1 master secret (which
1314 * is typically generated from a random generator). Therefore, we need
1315 * an RSA key. */
1316 dwLen = (DWORD)sizeof(abPlainPrivateKey);
1317 result = CryptImportKey(hProv, abPlainPrivateKey, dwLen, 0, 0, &hRSAKey);
1318 ok (result, "%08x\n", GetLastError());
1319 if (!result) return;
1320
1321 dwLen = (DWORD)sizeof(abTLS1Master);
1322 result = CryptImportKey(hProv, abTLS1Master, dwLen, hRSAKey, 0, &hMasterSecret);
1323 ok (result, "%08x\n", GetLastError());
1324 if (!result) return;
1325
1326 /* Setting the TLS1 client and server random parameters, as well as the
1327 * MAC and encryption algorithm parameters. */
1328 data_blob.cbData = 33;
1329 data_blob.pbData = abClientSecret;
1330 result = CryptSetKeyParam(hMasterSecret, KP_CLIENT_RANDOM, (BYTE*)&data_blob, 0);
1331 ok (result, "%08x\n", GetLastError());
1332 if (!result) return;
1333
1334 data_blob.cbData = 33;
1335 data_blob.pbData = abServerSecret;
1336 result = CryptSetKeyParam(hMasterSecret, KP_SERVER_RANDOM, (BYTE*)&data_blob, 0);
1337 ok (result, "%08x\n", GetLastError());
1338 if (!result) return;
1339
1340 saSChannelAlg.dwUse = SCHANNEL_ENC_KEY;
1341 saSChannelAlg.Algid = CALG_DES;
1342 saSChannelAlg.cBits = 64;
1343 saSChannelAlg.dwFlags = 0;
1344 saSChannelAlg.dwReserved = 0;
1345 result = CryptSetKeyParam(hMasterSecret, KP_SCHANNEL_ALG, (PBYTE)&saSChannelAlg, 0);
1346 ok (result, "%08x\n", GetLastError());
1347 if (!result) return;
1348
1349 saSChannelAlg.dwUse = SCHANNEL_MAC_KEY;
1350 saSChannelAlg.Algid = CALG_MD5;
1351 saSChannelAlg.cBits = 128;
1352 saSChannelAlg.dwFlags = 0;
1353 saSChannelAlg.dwReserved = 0;
1354 result = CryptSetKeyParam(hMasterSecret, KP_SCHANNEL_ALG, (PBYTE)&saSChannelAlg, 0);
1355 ok (result, "%08x\n", GetLastError());
1356 if (!result) return;
1357
1358 /* Deriving a hash from the master secret. This is due to the CryptoAPI architecture.
1359 * (Keys can only be derived from hashes, not from other keys.) */
1360 result = CryptCreateHash(hProv, CALG_SCHANNEL_MASTER_HASH, hMasterSecret, 0, &hMasterHash);
1361 ok (result, "%08x\n", GetLastError());
1362 if (!result) return;
1363
1364 /* Deriving the server write encryption key from the master hash */
1365 result = CryptDeriveKey(hProv, CALG_SCHANNEL_ENC_KEY, hMasterHash, CRYPT_SERVER, &hServerWriteKey);
1366 ok (result, "%08x\n", GetLastError());
1367 if (!result) return;
1368
1369 /* Encrypting some data with the server write encryption key and checking the result. */
1370 dwLen = 12;
1371 result = CryptEncrypt(hServerWriteKey, 0, TRUE, 0, abData, &dwLen, 16);
1372 ok (result && (dwLen == 16) && !memcmp(abData, abEncryptedData, 16), "%08x\n", GetLastError());
1373
1374 /* Second test case: Test the TLS1 pseudo random number function. */
1375 result = CryptCreateHash(hProv, CALG_TLS1PRF, hMasterSecret, 0, &hTLS1PRF);
1376 ok (result, "%08x\n", GetLastError());
1377 if (!result) return;
1378
1379 /* Set the label and seed parameters for the random number function */
1380 data_blob.cbData = 36;
1381 data_blob.pbData = abHashedHandshakes;
1382 result = CryptSetHashParam(hTLS1PRF, HP_TLS1PRF_SEED, (BYTE*)&data_blob, 0);
1383 ok (result, "%08x\n", GetLastError());
1384 if (!result) return;
1385
1386 data_blob.cbData = 15;
1387 data_blob.pbData = abClientFinished;
1388 result = CryptSetHashParam(hTLS1PRF, HP_TLS1PRF_LABEL, (BYTE*)&data_blob, 0);
1389 ok (result, "%08x\n", GetLastError());
1390 if (!result) return;
1391
1392 /* Generate some pseudo random bytes and check if they are correct. */
1393 dwLen = (DWORD)sizeof(abData);
1394 result = CryptGetHashParam(hTLS1PRF, HP_HASHVAL, abData, &dwLen, 0);
1395 ok (result && (dwLen==(DWORD)sizeof(abData)) && !memcmp(abData, abPRF, sizeof(abData)),
1396 "%08x\n", GetLastError());
1397
1398 /* Third test case. Derive the server write mac key. Derive an HMAC object from this one.
1399 * Hash some data with the HMAC. Compare results. */
1400 result = CryptDeriveKey(hProv, CALG_SCHANNEL_MAC_KEY, hMasterHash, CRYPT_SERVER, &hServerWriteMACKey);
1401 ok (result, "%08x\n", GetLastError());
1402 if (!result) return;
1403
1404 result = CryptCreateHash(hProv, CALG_HMAC, hServerWriteMACKey, 0, &hHMAC);
1405 ok (result, "%08x\n", GetLastError());
1406 if (!result) return;
1407
1408 result = CryptSetHashParam(hHMAC, HP_HMAC_INFO, (PBYTE)&hmacInfo, 0);
1409 ok (result, "%08x\n", GetLastError());
1410 if (!result) return;
1411
1412 result = CryptHashData(hHMAC, abData, (DWORD)sizeof(abData), 0);
1413 ok (result, "%08x\n", GetLastError());
1414 if (!result) return;
1415
1416 dwLen = (DWORD)sizeof(abMD5Hash);
1417 result = CryptGetHashParam(hHMAC, HP_HASHVAL, abMD5Hash, &dwLen, 0);
1418 ok (result && (dwLen == 16) && !memcmp(abMD5Hash, abMD5, 16), "%08x\n", GetLastError());
1419
1420 CryptDestroyHash(hHMAC);
1421 CryptDestroyHash(hTLS1PRF);
1422 CryptDestroyHash(hMasterHash);
1423 CryptDestroyKey(hServerWriteMACKey);
1424 CryptDestroyKey(hServerWriteKey);
1425 CryptDestroyKey(hRSAKey);
1426 CryptDestroyKey(hMasterSecret);
1427 CryptReleaseContext(hProv, 0);
1428 CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_DELETEKEYSET);
1429 }
1430
1431 static void test_enum_container(void)
1432 {
1433 BYTE abContainerName[256];
1434 DWORD dwBufferLen;
1435 BOOL result, fFound = FALSE;
1436
1437 /* If PP_ENUMCONTAINERS is queried with CRYPT_FIRST and abData == NULL, it returns
1438 * the maximum legal length of container names (which is MAX_PATH + 1 == 261) */
1439 result = CryptGetProvParam(hProv, PP_ENUMCONTAINERS, NULL, &dwBufferLen, CRYPT_FIRST);
1440 ok (result && dwBufferLen == MAX_PATH + 1, "%08x\n", GetLastError());
1441
1442 /* If the result fits into abContainerName dwBufferLen is left untouched */
1443 dwBufferLen = (DWORD)sizeof(abContainerName);
1444 result = CryptGetProvParam(hProv, PP_ENUMCONTAINERS, abContainerName, &dwBufferLen, CRYPT_FIRST);
1445 ok (result && dwBufferLen == (DWORD)sizeof(abContainerName), "%08x\n", GetLastError());
1446
1447 /* We only check, if the currently open 'winetest' container is among the enumerated. */
1448 do {
1449 if (!strcmp((const char*)abContainerName, "winetest")) fFound = TRUE;
1450 dwBufferLen = (DWORD)sizeof(abContainerName);
1451 } while (CryptGetProvParam(hProv, PP_ENUMCONTAINERS, abContainerName, &dwBufferLen, 0));
1452
1453 ok (fFound && GetLastError() == ERROR_NO_MORE_ITEMS, "%d, %08x\n", fFound, GetLastError());
1454 }
1455
1456 static BYTE signBlob[] = {
1457 0x07,0x02,0x00,0x00,0x00,0x24,0x00,0x00,0x52,0x53,0x41,0x32,0x00,0x02,0x00,0x00,
1458 0x01,0x00,0x01,0x00,0xf1,0x82,0x9e,0x84,0xb5,0x79,0x9a,0xbe,0x4d,0x06,0x20,0x21,
1459 0xb1,0x89,0x0c,0xca,0xb0,0x35,0x72,0x18,0xc6,0x92,0xa8,0xe2,0xb1,0xe1,0xf6,0x56,
1460 0x53,0x99,0x47,0x10,0x6e,0x1c,0x81,0xaf,0xb8,0xf9,0x5f,0xfe,0x76,0x7f,0x2c,0x93,
1461 0xec,0x54,0x7e,0x5e,0xc2,0x25,0x3c,0x50,0x56,0x10,0x20,0x72,0x4a,0x93,0x03,0x12,
1462 0x29,0x98,0xcc,0xc9,0x47,0xbf,0xbf,0x93,0xcc,0xb0,0xe5,0x53,0x14,0xc8,0x7e,0x1f,
1463 0xa4,0x03,0x2d,0x8e,0x84,0x7a,0xd2,0xeb,0xf7,0x92,0x5e,0xa2,0xc7,0x6b,0x35,0x7d,
1464 0xcb,0x60,0xae,0xfb,0x07,0x78,0x11,0x73,0xb5,0x79,0xe5,0x7e,0x96,0xe3,0x50,0x95,
1465 0x80,0x0e,0x1c,0xf6,0x56,0xc6,0xe9,0x0a,0xaf,0x03,0xc6,0xdc,0x9a,0x81,0xcf,0x7a,
1466 0x63,0x16,0x43,0xcd,0xab,0x74,0xa1,0x7d,0xe7,0xe0,0x75,0x6d,0xbd,0x19,0xae,0x0b,
1467 0xa3,0x7f,0x6a,0x7b,0x05,0x4e,0xbc,0xec,0x18,0xfc,0x19,0xc2,0x00,0xf0,0x6a,0x2e,
1468 0xc4,0x31,0x73,0xba,0x07,0xcc,0x9d,0x57,0xeb,0xc7,0x7c,0x00,0x7d,0x5d,0x11,0x16,
1469 0x42,0x4b,0xe5,0x3a,0xf5,0xc7,0xf8,0xee,0xc3,0x2c,0x0d,0x86,0x03,0xe2,0xaf,0xb2,
1470 0xd2,0x91,0xdb,0x71,0xcd,0xdf,0x81,0x5f,0x06,0xfc,0x48,0x0d,0xb6,0x88,0x9f,0xc1,
1471 0x5e,0x24,0xa2,0x05,0x4f,0x30,0x2e,0x8f,0x8b,0x0d,0x76,0xa1,0x84,0xda,0x7b,0x44,
1472 0x70,0x85,0xf1,0x50,0xb1,0x21,0x3d,0xe2,0x57,0x3d,0xd0,0x01,0x93,0x49,0x8e,0xc5,
1473 0x0b,0x8b,0x0d,0x7b,0x08,0xe9,0x14,0xec,0x20,0x0d,0xea,0x02,0x00,0x63,0xe8,0x0a,
1474 0x52,0xe8,0xfb,0x21,0xbd,0x37,0xde,0x4c,0x4d,0xc2,0xf6,0xb9,0x0d,0x2a,0xc3,0xe2,
1475 0xc9,0xdf,0x48,0x3e,0x55,0x3d,0xe3,0xc0,0x22,0x37,0xf9,0x52,0xc0,0xd7,0x61,0x22,
1476 0xb6,0x85,0x86,0x07 };
1477
1478 static void test_null_provider(void)
1479 {
1480 HCRYPTPROV prov;
1481 HCRYPTKEY key;
1482 BOOL result;
1483 DWORD keySpec, dataLen;
1484
1485 result = CryptAcquireContext(NULL, szContainer, NULL, 0, 0);
1486 ok(!result && GetLastError() == NTE_BAD_PROV_TYPE,
1487 "Expected NTE_BAD_PROV_TYPE, got %08x\n", GetLastError());
1488 result = CryptAcquireContext(NULL, szContainer, NULL, PROV_RSA_FULL, 0);
1489 ok(!result && GetLastError() == ERROR_INVALID_PARAMETER,
1490 "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
1491 result = CryptAcquireContext(NULL, szContainer, NULL, PROV_RSA_FULL,
1492 CRYPT_DELETEKEYSET);
1493 ok(!result && GetLastError() == ERROR_INVALID_PARAMETER,
1494 "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
1495 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1496 CRYPT_DELETEKEYSET);
1497 ok(!result && GetLastError() == NTE_BAD_KEYSET,
1498 "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
1499 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL, 0);
1500 ok(!result && GetLastError() == NTE_BAD_KEYSET,
1501 "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
1502
1503 /* Delete the default container. */
1504 CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
1505 /* Once you've deleted the default container you can't open it as if it
1506 * already exists.
1507 */
1508 result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, 0);
1509 ok(!result && GetLastError() == NTE_BAD_KEYSET,
1510 "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
1511 /* But you can always open the default container for CRYPT_VERIFYCONTEXT. */
1512 result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL,
1513 CRYPT_VERIFYCONTEXT);
1514 ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
1515 if (!result) return;
1516 dataLen = sizeof(keySpec);
1517 result = CryptGetProvParam(prov, PP_KEYSPEC, (LPBYTE)&keySpec, &dataLen, 0);
1518 if (result)
1519 ok(keySpec == (AT_KEYEXCHANGE | AT_SIGNATURE),
1520 "Expected AT_KEYEXCHANGE | AT_SIGNATURE, got %08x\n", keySpec);
1521 /* Even though PP_KEYSPEC says both AT_KEYEXCHANGE and AT_SIGNATURE are
1522 * supported, you can't get the keys from this container.
1523 */
1524 result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1525 ok(!result && GetLastError() == NTE_NO_KEY,
1526 "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1527 result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1528 ok(!result && GetLastError() == NTE_NO_KEY,
1529 "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1530 result = CryptReleaseContext(prov, 0);
1531 ok(result, "CryptReleaseContext failed: %08x\n", GetLastError());
1532 /* You can create a new default container. */
1533 result = CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL,
1534 CRYPT_NEWKEYSET);
1535 ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
1536 /* But you still can't get the keys (until one's been generated.) */
1537 result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1538 ok(!result && GetLastError() == NTE_NO_KEY,
1539 "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1540 result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1541 ok(!result && GetLastError() == NTE_NO_KEY,
1542 "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1543 CryptReleaseContext(prov, 0);
1544 CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
1545
1546 CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1547 CRYPT_DELETEKEYSET);
1548 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL, 0);
1549 ok(!result && GetLastError() == NTE_BAD_KEYSET,
1550 "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
1551 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1552 CRYPT_VERIFYCONTEXT);
1553 ok(!result && GetLastError() == NTE_BAD_FLAGS,
1554 "Expected NTE_BAD_FLAGS, got %08x\n", GetLastError());
1555 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1556 CRYPT_NEWKEYSET);
1557 ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
1558 if (!result) return;
1559 dataLen = sizeof(keySpec);
1560 result = CryptGetProvParam(prov, PP_KEYSPEC, (LPBYTE)&keySpec, &dataLen, 0);
1561 if (result)
1562 ok(keySpec == (AT_KEYEXCHANGE | AT_SIGNATURE),
1563 "Expected AT_KEYEXCHANGE | AT_SIGNATURE, got %08x\n", keySpec);
1564 result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1565 ok(!result && GetLastError() == NTE_NO_KEY,
1566 "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1567 result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1568 ok(!result && GetLastError() == NTE_NO_KEY,
1569 "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1570
1571 /* Importing a key exchange blob.. */
1572 result = CryptImportKey(prov, abPlainPrivateKey, sizeof(abPlainPrivateKey),
1573 0, 0, &key);
1574 ok(result, "CryptImportKey failed: %08x\n", GetLastError());
1575 CryptDestroyKey(key);
1576 /* allows access to the key exchange key.. */
1577 result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1578 ok(result, "CryptGetUserKey failed: %08x\n", GetLastError());
1579 CryptDestroyKey(key);
1580 /* but not to the private key. */
1581 result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1582 ok(!result && GetLastError() == NTE_NO_KEY,
1583 "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1584 CryptReleaseContext(prov, 0);
1585 CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1586 CRYPT_DELETEKEYSET);
1587
1588 /* Whereas importing a sign blob.. */
1589 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1590 CRYPT_NEWKEYSET);
1591 ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
1592 if (!result) return;
1593 result = CryptImportKey(prov, signBlob, sizeof(signBlob), 0, 0, &key);
1594 ok(result, "CryptGenKey failed: %08x\n", GetLastError());
1595 /* doesn't allow access to the key exchange key.. */
1596 result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1597 ok(!result && GetLastError() == NTE_NO_KEY,
1598 "Expected NTE_NO_KEY, got %08x\n", GetLastError());
1599 /* but does to the private key. */
1600 result = CryptGetUserKey(prov, AT_SIGNATURE, &key);
1601 ok(result, "CryptGetUserKey failed: %08x\n", GetLastError());
1602 CryptDestroyKey(key);
1603
1604 CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1605 CRYPT_DELETEKEYSET);
1606
1607
1608 /* test for the bug in accessing the user key in a container
1609 */
1610 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1611 CRYPT_NEWKEYSET);
1612 ok(result, "CryptAcquireContext failed: %08x\n", GetLastError());
1613 result = CryptGenKey(prov, AT_KEYEXCHANGE, 0, &key);
1614 ok(result, "CryptGenKey with AT_KEYEXCHANGE failed with error %08x\n", GetLastError());
1615 CryptDestroyKey(key);
1616 CryptReleaseContext(prov,0);
1617 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,0);
1618 ok(result, "CryptAcquireContext failed: 0x%08x\n", GetLastError());
1619 result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key);
1620 ok (result, "CryptGetUserKey failed with error %08x\n", GetLastError());
1621 CryptDestroyKey(key);
1622
1623 CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1624 CRYPT_DELETEKEYSET);
1625
1626 /* test the machine key set */
1627 CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1628 CRYPT_DELETEKEYSET|CRYPT_MACHINE_KEYSET);
1629 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1630 CRYPT_NEWKEYSET|CRYPT_MACHINE_KEYSET);
1631 ok(result, "CryptAcquireContext with CRYPT_MACHINE_KEYSET failed: %08x\n", GetLastError());
1632 CryptReleaseContext(prov, 0);
1633 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1634 CRYPT_MACHINE_KEYSET);
1635 ok(result, "CryptAcquireContext with CRYPT_MACHINE_KEYSET failed: %08x\n", GetLastError());
1636 CryptReleaseContext(prov,0);
1637 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1638 CRYPT_DELETEKEYSET|CRYPT_MACHINE_KEYSET);
1639 ok(result, "CryptAcquireContext with CRYPT_DELETEKEYSET|CRYPT_MACHINE_KEYSET failed: %08x\n",
1640 GetLastError());
1641 result = CryptAcquireContext(&prov, szContainer, NULL, PROV_RSA_FULL,
1642 CRYPT_MACHINE_KEYSET);
1643 ok(!result && GetLastError() == NTE_BAD_KEYSET ,
1644 "Expected NTE_BAD_KEYSET, got %08x\n", GetLastError());
1645
1646 }
1647
1648 START_TEST(rsaenh)
1649 {
1650 if (!init_environment())
1651 return;
1652 test_prov();
1653 test_gen_random();
1654 test_hashes();
1655 test_rc4();
1656 test_rc2();
1657 test_des();
1658 test_3des112();
1659 test_3des();
1660 test_hmac();
1661 test_mac();
1662 test_block_cipher_modes();
1663 test_import_private();
1664 test_verify_signature();
1665 test_rsa_encrypt();
1666 test_import_export();
1667 test_enum_container();
1668 clean_up_environment();
1669 test_schannel_provider();
1670 test_null_provider();
1671 }
useful hacks and other patches not (yet) suitable for mainline