ReactOS 0.4.16-dev-287-g2d3f3a1
msg.c
Go to the documentation of this file.
1/*
2 * Unit test suite for crypt32.dll's CryptMsg functions
3 *
4 * Copyright 2007 Juan Lang
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 <stdio.h>
22#include <stdarg.h>
23#include <windef.h>
24#include <winbase.h>
25#include <winerror.h>
26#define CMSG_SIGNER_ENCODE_INFO_HAS_CMS_FIELDS
27#define CMSG_SIGNED_ENCODE_INFO_HAS_CMS_FIELDS
28#include <wincrypt.h>
29
30#include "wine/test.h"
31
32static BOOL have_nt = TRUE;
34static char oid_rsa_md5[] = szOID_RSA_MD5;
35
36static BOOL (WINAPI * pCryptAcquireContextA)
38static BOOL (WINAPI * pCryptAcquireContextW)
40
41static void init_function_pointers(void)
42{
43 HMODULE hAdvapi32 = GetModuleHandleA("advapi32.dll");
44
45#define GET_PROC(dll, func) \
46 p ## func = (void *)GetProcAddress(dll, #func); \
47 if(!p ## func) \
48 trace("GetProcAddress(%s) failed\n", #func);
49
52
53#undef GET_PROC
54}
55
56static void test_msg_open_to_encode(void)
57{
59
60 /* Crash
61 msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED, NULL,
62 NULL, NULL);
63 msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, NULL, NULL,
64 NULL);
65 msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, NULL, NULL,
66 NULL);
67 */
68
69 /* Bad encodings */
70 SetLastError(0xdeadbeef);
73 "Expected E_INVALIDARG, got %x\n", GetLastError());
74 SetLastError(0xdeadbeef);
77 "Expected E_INVALIDARG, got %x\n", GetLastError());
78
79 /* Bad message types */
80 SetLastError(0xdeadbeef);
83 "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
84 SetLastError(0xdeadbeef);
86 NULL, NULL, NULL);
88 "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
89 SetLastError(0xdeadbeef);
93 "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
94 SetLastError(0xdeadbeef);
96 NULL, NULL);
98 "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
99}
100
101static void test_msg_open_to_decode(void)
102{
104 CMSG_STREAM_INFO streamInfo = { 0 };
105
106 SetLastError(0xdeadbeef);
107 msg = CryptMsgOpenToDecode(0, 0, 0, 0, NULL, NULL);
109 "Expected E_INVALIDARG, got %x\n", GetLastError());
110
111 /* Bad encodings */
112 SetLastError(0xdeadbeef);
115 "Expected E_INVALIDARG, got %x\n", GetLastError());
116 SetLastError(0xdeadbeef);
119 "Expected E_INVALIDARG, got %x\n", GetLastError());
120
121 /* The message type can be explicit... */
123 NULL);
124 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
127 NULL);
128 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
131 NULL);
132 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
135 NULL);
136 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
140 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
142 /* or implicit.. */
144 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
146 /* or even invalid. */
148 NULL);
149 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
152 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
154
155 /* And even though the stream info parameter "must be set to NULL" for
156 * CMSG_HASHED, it's still accepted.
157 */
159 &streamInfo);
160 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
162}
163
164static void test_msg_get_param(void)
165{
166 BOOL ret;
168 DWORD size, i, value;
169
170 /* Crash
171 ret = CryptMsgGetParam(NULL, 0, 0, NULL, NULL);
172 ret = CryptMsgGetParam(NULL, 0, 0, NULL, &size);
173 ret = CryptMsgGetParam(msg, 0, 0, NULL, NULL);
174 */
175
176 /* Decoded messages */
178 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
179 /* For decoded messages, the type is always available */
180 size = 0;
182 ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
183 size = sizeof(value);
185 ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
186 /* For this (empty) message, the type isn't set */
187 ok(value == 0, "Expected type 0, got %d\n", value);
189
191 NULL);
192 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
193 /* For explicitly typed messages, the type is known. */
194 size = sizeof(value);
196 ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
197 ok(value == CMSG_DATA, "Expected CMSG_DATA, got %d\n", value);
199 {
200 size = 0;
201 ret = CryptMsgGetParam(msg, i, 0, NULL, &size);
202 ok(!ret, "Parameter %d: expected failure\n", i);
203 }
205
207 NULL);
208 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
209 size = sizeof(value);
211 ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
212 ok(value == CMSG_ENVELOPED, "Expected CMSG_ENVELOPED, got %d\n", value);
214 {
215 size = 0;
216 ret = CryptMsgGetParam(msg, i, 0, NULL, &size);
217 ok(!ret, "Parameter %d: expected failure\n", i);
218 }
220
222 NULL);
223 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
224 size = sizeof(value);
226 ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
227 ok(value == CMSG_HASHED, "Expected CMSG_HASHED, got %d\n", value);
229 {
230 size = 0;
231 ret = CryptMsgGetParam(msg, i, 0, NULL, &size);
232 ok(!ret, "Parameter %d: expected failure\n", i);
233 }
235
237 NULL);
238 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
239 size = sizeof(value);
241 ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
242 ok(value == CMSG_SIGNED, "Expected CMSG_SIGNED, got %d\n", value);
244 {
245 size = 0;
246 ret = CryptMsgGetParam(msg, i, 0, NULL, &size);
247 ok(!ret, "Parameter %d: expected failure\n", i);
248 }
250
251 /* Explicitly typed messages get their types set, even if they're invalid */
253 NULL);
254 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
255 size = sizeof(value);
257 ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
258 ok(value == CMSG_ENCRYPTED, "Expected CMSG_ENCRYPTED, got %d\n", value);
260
262 ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
263 size = sizeof(value);
265 ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
266 ok(value == 1000, "Expected 1000, got %d\n", value);
268}
269
270static void test_msg_close(void)
271{
272 BOOL ret;
274
275 /* NULL succeeds.. */
277 ok(ret, "CryptMsgClose failed: %x\n", GetLastError());
278 /* but an arbitrary pointer crashes. */
279 if (0)
282 NULL);
283 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
285 ok(ret, "CryptMsgClose failed: %x\n", GetLastError());
286}
287
289 const BYTE *expected, DWORD expectedSize)
290{
291 DWORD size;
292 LPBYTE buf;
293 BOOL ret;
294
295 size = 0xdeadbeef;
297 ok(ret || broken(GetLastError() == OSS_LIMITED /* Win9x */ ||
298 GetLastError() == CRYPT_E_INVALID_MSG_TYPE /* Win9x, for some params */),
299 "%s: CryptMsgGetParam failed: %08x\n", test, GetLastError());
300 if (!ret)
301 {
302 win_skip("parameter %d not supported, skipping tests\n", param);
303 return;
304 }
307 ok(ret, "%s: CryptMsgGetParam failed: %08x\n", test, GetLastError());
308 ok(size == expectedSize, "%s: expected size %d, got %d\n", test,
309 expectedSize, size);
310 if (size == expectedSize && size)
311 ok(!memcmp(buf, expected, size), "%s: unexpected data\n", test);
313}
314
315static void test_data_msg_open(void)
316{
318 CMSG_HASHED_ENCODE_INFO hashInfo = { 0 };
319 CMSG_STREAM_INFO streamInfo = { 0 };
320 char oid[] = "1.2.3";
321
322 /* The data message type takes no additional info */
323 SetLastError(0xdeadbeef);
325 NULL, NULL);
327 "Expected E_INVALIDARG, got %x\n", GetLastError());
329 NULL);
330 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
332
333 /* An empty stream info is allowed. */
335 &streamInfo);
336 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
338
339 /* Passing a bogus inner OID succeeds for a non-streamed message.. */
341 NULL);
342 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
344 /* and still succeeds when CMSG_DETACHED_FLAG is passed.. */
346 CMSG_DATA, NULL, oid, NULL);
347 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
349 /* and when a stream info is given, even though you're not supposed to be
350 * able to use anything but szOID_RSA_data when streaming is being used.
351 */
353 CMSG_DATA, NULL, oid, &streamInfo);
354 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
356}
357
358static const BYTE msgData[] = { 1, 2, 3, 4 };
359
360static BOOL WINAPI nop_stream_output(const void *pvArg, BYTE *pb, DWORD cb,
361 BOOL final)
362{
363 return TRUE;
364}
365
366static const BYTE dataEmptyBareContent[] = { 0x04,0x00 };
367
368static void test_data_msg_update(void)
369{
371 BOOL ret;
372 CMSG_STREAM_INFO streamInfo = { 0 };
373
375 NULL);
376 /* Can't update a message that wasn't opened detached with final = FALSE */
377 SetLastError(0xdeadbeef);
380 "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
381 /* Updating it with final = TRUE succeeds */
383 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
384 /* Any subsequent update will fail, as the last was final */
385 SetLastError(0xdeadbeef);
388 "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
390
392 NULL);
393 /* Starting with Vista, can update a message with no data. */
395 ok(ret || broken(!ret), "CryptMsgUpdate failed: %08x\n", GetLastError());
396 if (ret)
397 {
398 DWORD size;
399
401 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
402 if (ret)
403 {
405
406 if (buf)
407 {
409 &size);
410 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
411 if (ret)
412 {
413 ok(size == sizeof(dataEmptyBareContent),
414 "unexpected size %d\n", size);
416 "unexpected value\n");
417 }
419 }
420 }
421 }
423
426 if (have_nt)
427 {
428 /* Doesn't appear to be able to update CMSG-DATA with non-final updates.
429 * On Win9x, this sometimes succeeds, sometimes fails with
430 * GetLastError() == 0, so it's not worth checking there.
431 */
432 SetLastError(0xdeadbeef);
434 ok(!ret &&
436 broken(GetLastError() == ERROR_SUCCESS)), /* Older NT4 */
437 "Expected E_INVALIDARG, got %x\n", GetLastError());
438 SetLastError(0xdeadbeef);
440 ok(!ret &&
442 broken(GetLastError() == ERROR_SUCCESS)), /* Older NT4 */
443 "Expected E_INVALIDARG, got %x\n", GetLastError());
444 }
445 else
446 skip("not updating CMSG_DATA with a non-final update\n");
448 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
450
451 if (!old_crypt32)
452 {
453 /* Calling update after opening with an empty stream info (with a bogus
454 * output function) yields an error:
455 */
456 /* Crashes on some Win9x */
458 &streamInfo);
459 SetLastError(0xdeadbeef);
463 "Expected STATUS_ACCESS_VIOLATION or STATUS_ILLEGAL_INSTRUCTION, got %x\n",
464 GetLastError());
466 }
467 /* Calling update with a valid output function succeeds, even if the data
468 * exceeds the size specified in the stream info.
469 */
472 &streamInfo);
474 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
476 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
478}
479
480static void test_data_msg_get_param(void)
481{
483 DWORD size;
484 BOOL ret;
485 CMSG_STREAM_INFO streamInfo = { 0, nop_stream_output, NULL };
486
488 NULL);
489
490 /* Content and bare content are always gettable when not streaming */
491 size = 0;
493 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
494 size = 0;
496 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
497 /* But for this type of message, the signer and hash aren't applicable,
498 * and the type isn't available.
499 */
500 size = 0;
501 SetLastError(0xdeadbeef);
504 "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
505 SetLastError(0xdeadbeef);
508 "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
511 "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
513
514 /* Can't get content or bare content when streaming */
516 NULL, &streamInfo);
517 SetLastError(0xdeadbeef);
519 ok((!ret && GetLastError() == E_INVALIDARG) || broken(ret /* Win9x */),
520 "Expected E_INVALIDARG, got %x\n", GetLastError());
521 SetLastError(0xdeadbeef);
523 ok((!ret && GetLastError() == E_INVALIDARG) || broken(ret /* Win9x */),
524 "Expected E_INVALIDARG, got %x\n", GetLastError());
526}
527
528static const BYTE dataEmptyContent[] = {
5290x30,0x0f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x02,
5300x04,0x00 };
531static const BYTE dataBareContent[] = { 0x04,0x04,0x01,0x02,0x03,0x04 };
532static const BYTE dataContent[] = {
5330x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,
5340x04,0x04,0x01,0x02,0x03,0x04 };
535
537{
540};
541
542static BOOL WINAPI accumulating_stream_output(const void *pvArg, BYTE *pb,
543 DWORD cb, BOOL final)
544{
545 struct update_accum *accum = (struct update_accum *)pvArg;
546 BOOL ret = FALSE;
547
548 if (accum->cUpdates)
549 accum->updates = CryptMemRealloc(accum->updates,
550 (accum->cUpdates + 1) * sizeof(CRYPT_DATA_BLOB));
551 else
552 accum->updates = CryptMemAlloc(sizeof(CRYPT_DATA_BLOB));
553 if (accum->updates)
554 {
555 CRYPT_DATA_BLOB *blob = &accum->updates[accum->cUpdates];
556
557 blob->pbData = CryptMemAlloc(cb);
558 if (blob->pbData)
559 {
560 memcpy(blob->pbData, pb, cb);
561 blob->cbData = cb;
562 ret = TRUE;
563 }
564 accum->cUpdates++;
565 }
566 return ret;
567}
568
569/* The updates of a (bogus) definite-length encoded message */
570static BYTE u1[] = { 0x30,0x0f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
571 0x07,0x01,0xa0,0x02,0x04,0x00 };
572static BYTE u2[] = { 0x01,0x02,0x03,0x04 };
573static CRYPT_DATA_BLOB b1[] = {
574 { sizeof(u1), u1 },
575 { sizeof(u2), u2 },
576 { sizeof(u2), u2 },
577};
578static const struct update_accum a1 = { ARRAY_SIZE(b1), b1 };
579/* The updates of a definite-length encoded message */
580static BYTE u3[] = { 0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
581 0x07,0x01,0xa0,0x06,0x04,0x04 };
582static CRYPT_DATA_BLOB b2[] = {
583 { sizeof(u3), u3 },
584 { sizeof(u2), u2 },
585};
586static const struct update_accum a2 = { ARRAY_SIZE(b2), b2 };
587/* The updates of an indefinite-length encoded message */
588static BYTE u4[] = { 0x30,0x80,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
589 0x07,0x01,0xa0,0x80,0x24,0x80 };
590static BYTE u5[] = { 0x04,0x04 };
591static BYTE u6[] = { 0x00,0x00,0x00,0x00,0x00,0x00 };
592static CRYPT_DATA_BLOB b3[] = {
593 { sizeof(u4), u4 },
594 { sizeof(u5), u5 },
595 { sizeof(u2), u2 },
596 { sizeof(u5), u5 },
597 { sizeof(u2), u2 },
598 { sizeof(u6), u6 },
599};
600static const struct update_accum a3 = { ARRAY_SIZE(b3), b3 };
601
603 const struct update_accum *got)
604{
605 DWORD i;
606
607 ok(expected->cUpdates == got->cUpdates,
608 "%s: expected %d updates, got %d\n", header, expected->cUpdates,
609 got->cUpdates);
610 if (expected->cUpdates == got->cUpdates)
611 for (i = 0; i < min(expected->cUpdates, got->cUpdates); i++)
612 {
613 ok(expected->updates[i].cbData == got->updates[i].cbData,
614 "%s, update %d: expected %d bytes, got %d\n", header, i,
615 expected->updates[i].cbData, got->updates[i].cbData);
616 if (expected->updates[i].cbData && expected->updates[i].cbData ==
617 got->updates[i].cbData)
618 ok(!memcmp(expected->updates[i].pbData, got->updates[i].pbData,
619 got->updates[i].cbData), "%s, update %d: unexpected value\n",
620 header, i);
621 }
622}
623
624/* Frees the updates stored in accum */
625static void free_updates(struct update_accum *accum)
626{
627 DWORD i;
628
629 for (i = 0; i < accum->cUpdates; i++)
630 CryptMemFree(accum->updates[i].pbData);
631 CryptMemFree(accum->updates);
632 accum->updates = NULL;
633 accum->cUpdates = 0;
634}
635
636static void test_data_msg_encoding(void)
637{
639 BOOL ret;
640 static char oid[] = "1.2.3";
641 struct update_accum accum = { 0, NULL };
642 CMSG_STREAM_INFO streamInfo = { 0, accumulating_stream_output, &accum };
643
645 NULL);
646 check_param("data empty bare content", msg, CMSG_BARE_CONTENT_PARAM,
648 check_param("data empty content", msg, CMSG_CONTENT_PARAM, dataEmptyContent,
649 sizeof(dataEmptyContent));
651 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
652 check_param("data bare content", msg, CMSG_BARE_CONTENT_PARAM,
655 sizeof(dataContent));
657 /* Same test, but with CMSG_BARE_CONTENT_FLAG set */
660 check_param("data empty bare content", msg, CMSG_BARE_CONTENT_PARAM,
662 check_param("data empty content", msg, CMSG_CONTENT_PARAM, dataEmptyContent,
663 sizeof(dataEmptyContent));
665 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
666 check_param("data bare content", msg, CMSG_BARE_CONTENT_PARAM,
669 sizeof(dataContent));
671 /* The inner OID is apparently ignored */
673 NULL);
674 check_param("data bogus oid bare content", msg, CMSG_BARE_CONTENT_PARAM,
676 check_param("data bogus oid content", msg, CMSG_CONTENT_PARAM,
679 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
680 check_param("data bare content", msg, CMSG_BARE_CONTENT_PARAM,
683 sizeof(dataContent));
685 /* A streaming message is DER encoded if the length is not 0xffffffff, but
686 * curiously, updates aren't validated to make sure they don't exceed the
687 * stated length. (The resulting output will of course fail to decode.)
688 */
690 NULL, &streamInfo);
694 check_updates("bogus data message with definite length", &a1, &accum);
695 free_updates(&accum);
696 /* A valid definite-length encoding: */
697 streamInfo.cbContent = sizeof(msgData);
699 NULL, &streamInfo);
702 check_updates("data message with definite length", &a2, &accum);
703 free_updates(&accum);
704 /* An indefinite-length encoding: */
705 streamInfo.cbContent = 0xffffffff;
707 NULL, &streamInfo);
711 check_updates("data message with indefinite length", &a3, &accum);
712 free_updates(&accum);
713}
714
715static void test_data_msg(void)
716{
721}
722
723static void test_hash_msg_open(void)
724{
726 CMSG_HASHED_ENCODE_INFO hashInfo = { 0 };
727 CMSG_STREAM_INFO streamInfo = { 0, nop_stream_output, NULL };
728
729 SetLastError(0xdeadbeef);
731 NULL, NULL);
733 "Expected E_INVALIDARG, got %x\n", GetLastError());
734 hashInfo.cbSize = sizeof(hashInfo);
735 SetLastError(0xdeadbeef);
737 NULL, NULL);
739 "Expected CRYPT_E_UNKNOWN_ALGO, got %x\n", GetLastError());
742 NULL, NULL);
743 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
746 CMSG_HASHED, &hashInfo, NULL, NULL);
747 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
750 CMSG_HASHED, &hashInfo, NULL, &streamInfo);
751 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
753}
754
755static void test_hash_msg_update(void)
756{
758 BOOL ret;
759 CMSG_HASHED_ENCODE_INFO hashInfo = { sizeof(hashInfo), 0,
760 { oid_rsa_md5, { 0, NULL } }, NULL };
761 CMSG_STREAM_INFO streamInfo = { 0, nop_stream_output, NULL };
762
764 CMSG_HASHED, &hashInfo, NULL, NULL);
765 /* Detached hashed messages opened in non-streaming mode allow non-final
766 * updates..
767 */
769 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
770 /* including non-final updates with no data.. */
772 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
773 /* and final updates with no data. */
775 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
776 /* But no updates are allowed after the final update. */
777 SetLastError(0xdeadbeef);
780 "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
781 SetLastError(0xdeadbeef);
784 "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
786 /* Non-detached messages, in contrast, don't allow non-final updates in
787 * non-streaming mode.
788 */
790 NULL, NULL);
791 SetLastError(0xdeadbeef);
794 "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
795 /* Final updates (including empty ones) are allowed. */
797 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
799 /* And, of course, streaming mode allows non-final updates */
801 NULL, &streamInfo);
803 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
805 /* Setting pfnStreamOutput to NULL results in no error. (In what appears
806 * to be a bug, it isn't actually used - see encoding tests.)
807 */
808 streamInfo.pfnStreamOutput = NULL;
810 NULL, &streamInfo);
812 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
814}
815
816static const BYTE emptyHashParam[] = {
8170xd4,0x1d,0x8c,0xd9,0x8f,0x00,0xb2,0x04,0xe9,0x80,0x09,0x98,0xec,0xf8,0x42,
8180x7e };
819
820static void test_hash_msg_get_param(void)
821{
823 BOOL ret;
824 CMSG_HASHED_ENCODE_INFO hashInfo = { sizeof(hashInfo), 0,
825 { oid_rsa_md5, { 0, NULL } }, NULL };
827 CMSG_STREAM_INFO streamInfo = { 0, nop_stream_output, NULL };
828 BYTE buf[16];
829
831 NULL, NULL);
832 /* Content and bare content are always gettable for non-streamed messages */
833 size = 0;
835 ok(ret || broken(GetLastError() == OSS_LIMITED /* Win9x */),
836 "CryptMsgGetParam failed: %08x\n", GetLastError());
837 size = 0;
839 ok(ret || broken(GetLastError() == OSS_LIMITED /* Win9x */),
840 "CryptMsgGetParam failed: %08x\n", GetLastError());
841 /* For an encoded hash message, the hash data aren't available */
842 SetLastError(0xdeadbeef);
845 GetLastError() == OSS_LIMITED /* Win9x */),
846 "Expected CRYPT_E_INVALID_MSG_TYPE or OSS_LIMITED, got %08x\n",
847 GetLastError());
848 /* The hash is also available. */
849 size = 0;
851 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
852 ok(size == sizeof(buf), "Unexpected size %d\n", size);
854 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
855 ok(size == sizeof(buf), "Unexpected size %d\n", size);
856 if (size == sizeof(buf))
857 ok(!memcmp(buf, emptyHashParam, size), "Unexpected value\n");
858 /* By getting the hash, further updates are not allowed */
859 SetLastError(0xdeadbeef);
861 ok(!ret &&
862 (GetLastError() == NTE_BAD_HASH_STATE /* NT */ ||
863 GetLastError() == NTE_BAD_ALGID /* 9x */ ||
864 GetLastError() == CRYPT_E_MSG_ERROR /* Vista */ ||
865 broken(GetLastError() == ERROR_SUCCESS) /* Some Win9x */),
866 "Expected NTE_BAD_HASH_STATE or NTE_BAD_ALGID or CRYPT_E_MSG_ERROR, got 0x%x\n", GetLastError());
867
868 /* Even after a final update, the hash data aren't available */
869 SetLastError(0xdeadbeef);
872 "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
873 /* The version is also available, and should be zero for this message. */
874 size = 0;
877 "CryptMsgGetParam failed: %08x\n", GetLastError());
878 size = sizeof(value);
881 "CryptMsgGetParam failed: %08x\n", GetLastError());
882 if (ret)
883 ok(value == 0, "Expected version 0, got %d\n", value);
884 /* As usual, the type isn't available. */
886 ok(!ret, "Expected failure\n");
888
890 NULL, &streamInfo);
891 /* Streamed messages don't allow you to get the content or bare content. */
892 SetLastError(0xdeadbeef);
894 ok(!ret && (GetLastError() == E_INVALIDARG ||
895 GetLastError() == OSS_LIMITED /* Win9x */),
896 "Expected E_INVALIDARG or OSS_LIMITED, got %x\n", GetLastError());
897 SetLastError(0xdeadbeef);
899 ok(!ret && (GetLastError() == E_INVALIDARG ||
900 GetLastError() == OSS_LIMITED /* Win9x */),
901 "Expected E_INVALIDARG or OSS_LIMITED, got %x\n", GetLastError());
902 /* The hash is still available. */
903 size = 0;
905 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
906 ok(size == sizeof(buf), "Unexpected size %d\n", size);
908 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
909 if (size == sizeof(buf))
910 ok(!memcmp(buf, emptyHashParam, size), "Unexpected value\n");
911 /* After updating the hash, further updates aren't allowed on streamed
912 * messages either.
913 */
914 SetLastError(0xdeadbeef);
916 ok(!ret &&
917 (GetLastError() == NTE_BAD_HASH_STATE /* NT */ ||
918 GetLastError() == NTE_BAD_ALGID /* 9x */ ||
919 GetLastError() == CRYPT_E_MSG_ERROR /* Vista */ ||
920 broken(GetLastError() == ERROR_SUCCESS) /* Some Win9x */),
921 "Expected NTE_BAD_HASH_STATE or NTE_BAD_ALGID or CRYPT_E_MSG_ERROR, got 0x%x\n", GetLastError());
922
924}
925
926static const BYTE hashEmptyBareContent[] = {
9270x30,0x17,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
9280x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x04,0x00 };
929static const BYTE hashEmptyContent[] = {
9300x30,0x26,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x19,
9310x30,0x17,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
9320x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x04,0x00 };
933static const BYTE hashBareContent[] = {
9340x30,0x38,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
9350x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
9360x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x04,0x10,0x08,0xd6,0xc0,
9370x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f };
938static const BYTE hashContent[] = {
9390x30,0x47,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x3a,
9400x30,0x38,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
9410x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
9420x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x04,0x10,0x08,0xd6,0xc0,
9430x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f };
944
9460x30,0x20,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
9470x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
9480x07,0x01,0x04,0x00 };
9500x30,0x2f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x22,
9510x30,0x20,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
9520x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
9530x07,0x01,0x04,0x00 };
9550x30,0x30,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
9560x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
9570x07,0x01,0x04,0x10,0x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,
9580x9d,0x2a,0x8f,0x26,0x2f };
959static const BYTE detachedHashContent[] = {
9600x30,0x3f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x32,
9610x30,0x30,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
9620x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
9630x07,0x01,0x04,0x10,0x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,
9640x9d,0x2a,0x8f,0x26,0x2f };
965
966static void test_hash_msg_encoding(void)
967{
969 CMSG_HASHED_ENCODE_INFO hashInfo = { sizeof(hashInfo), 0 };
970 BOOL ret;
971 struct update_accum accum = { 0, NULL }, empty_accum = { 0, NULL };
972 CMSG_STREAM_INFO streamInfo = { 0, accumulating_stream_output, &accum };
973
976 NULL, NULL);
977 check_param("hash empty bare content", msg, CMSG_BARE_CONTENT_PARAM,
979 check_param("hash empty content", msg, CMSG_CONTENT_PARAM,
982 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
983 check_param("hash bare content", msg, CMSG_BARE_CONTENT_PARAM,
985 check_param("hash content", msg, CMSG_CONTENT_PARAM,
986 hashContent, sizeof(hashContent));
988 /* Same test, but with CMSG_BARE_CONTENT_FLAG set */
990 CMSG_HASHED, &hashInfo, NULL, NULL);
991 check_param("hash empty bare content", msg, CMSG_BARE_CONTENT_PARAM,
993 check_param("hash empty content", msg, CMSG_CONTENT_PARAM,
996 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
997 check_param("hash bare content", msg, CMSG_BARE_CONTENT_PARAM,
999 check_param("hash content", msg, CMSG_CONTENT_PARAM,
1000 hashContent, sizeof(hashContent));
1002 /* Same test, but with CMSG_DETACHED_FLAG set */
1004 CMSG_HASHED, &hashInfo, NULL, NULL);
1005 check_param("detached hash empty bare content", msg,
1007 sizeof(hashEmptyBareContent));
1008 check_param("detached hash empty content", msg, CMSG_CONTENT_PARAM,
1010 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
1011 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1012 check_param("detached hash not final bare content", msg,
1015 check_param("detached hash not final content", msg, CMSG_CONTENT_PARAM,
1017 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1018 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
1019 check_param("detached hash bare content", msg, CMSG_BARE_CONTENT_PARAM,
1021 check_param("detached hash content", msg, CMSG_CONTENT_PARAM,
1023 check_param("detached hash bare content", msg, CMSG_BARE_CONTENT_PARAM,
1025 check_param("detached hash content", msg, CMSG_CONTENT_PARAM,
1028 /* In what appears to be a bug, streamed updates to hash messages don't
1029 * call the output function.
1030 */
1032 NULL, &streamInfo);
1034 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1035 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1036 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1038 check_updates("empty hash message", &empty_accum, &accum);
1039 free_updates(&accum);
1040
1041 streamInfo.cbContent = sizeof(msgData);
1043 NULL, &streamInfo);
1044 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1045 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1047 check_updates("hash message", &empty_accum, &accum);
1048 free_updates(&accum);
1049
1050 streamInfo.cbContent = sizeof(msgData);
1052 CMSG_HASHED, &hashInfo, NULL, &streamInfo);
1053 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1054 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1056 check_updates("detached hash message", &empty_accum, &accum);
1057 free_updates(&accum);
1058}
1059
1060static void test_hash_msg(void)
1061{
1066}
1067
1068static const CHAR cspNameA[] = { 'W','i','n','e','C','r','y','p','t','T','e',
1069 'm','p',0 };
1070static const WCHAR cspNameW[] = { 'W','i','n','e','C','r','y','p','t','T','e',
1071 'm','p',0 };
1072static BYTE serialNum[] = { 1 };
1073static BYTE encodedCommonName[] = { 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,
1074 0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1075
1076static void test_signed_msg_open(void)
1077{
1078 HCRYPTMSG msg;
1079 BOOL ret;
1080 CMSG_SIGNED_ENCODE_INFO signInfo = { 0 };
1081 CMSG_SIGNER_ENCODE_INFO signer = { sizeof(signer), 0 };
1082 CERT_INFO certInfo = { 0 };
1083
1084 SetLastError(0xdeadbeef);
1086 NULL, NULL);
1088 "Expected E_INVALIDARG, got %x\n", GetLastError());
1089 signInfo.cbSize = sizeof(signInfo);
1091 NULL, NULL);
1092 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1094
1095 signInfo.cSigners = 1;
1096 signInfo.rgSigners = &signer;
1097 /* With signer.pCertInfo unset, attempting to open this message this
1098 * crashes.
1099 */
1100 signer.pCertInfo = &certInfo;
1101 /* The cert info must contain a serial number and an issuer. */
1102 SetLastError(0xdeadbeef);
1104 NULL, NULL);
1105 /* NT: E_INVALIDARG, 9x: unchanged or CRYPT_E_UNKNOWN_ALGO */
1106 ok(!msg && (GetLastError() == E_INVALIDARG || GetLastError() == 0xdeadbeef
1108 "Expected E_INVALIDARG or 0xdeadbeef or CRYPT_E_UNKNOWN_ALGO, got 0x%x\n",
1109 GetLastError());
1110
1111 certInfo.SerialNumber.cbData = sizeof(serialNum);
1112 certInfo.SerialNumber.pbData = serialNum;
1113 SetLastError(0xdeadbeef);
1115 NULL, NULL);
1116 /* NT: E_INVALIDARG, 9x: unchanged or CRYPT_E_UNKNOWN_ALGO */
1117 ok(!msg && (GetLastError() == E_INVALIDARG || GetLastError() == 0xdeadbeef
1119 "Expected E_INVALIDARG or 0xdeadbeef or CRYPT_E_UNKNOWN_ALGO, got 0x%x\n",
1120 GetLastError());
1121
1122 certInfo.Issuer.cbData = sizeof(encodedCommonName);
1123 certInfo.Issuer.pbData = encodedCommonName;
1124 SetLastError(0xdeadbeef);
1126 NULL, NULL);
1127 ok(!msg && (GetLastError() == E_INVALIDARG ||
1129 "Expected E_INVALIDARG or CRYPT_E_UNKNOWN_ALGO, got %x\n", GetLastError());
1130
1131 /* The signer's hCryptProv must be set to something. Whether it's usable
1132 * or not will be checked after the hash algorithm is checked (see next
1133 * test.)
1134 */
1135 signer.hCryptProv = 1;
1136 SetLastError(0xdeadbeef);
1138 NULL, NULL);
1140 "Expected CRYPT_E_UNKNOWN_ALGO, got %x\n", GetLastError());
1141 /* The signer's hash algorithm must also be set. */
1143 SetLastError(0xdeadbeef);
1144 /* Crashes in advapi32 in wine, don't do it */
1145 if (0) {
1147 &signInfo, NULL, NULL);
1149 "Expected ERROR_INVALID_PARAMETER, got %x\n", GetLastError());
1150 }
1151 /* The signer's hCryptProv must also be valid. */
1152 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1154 if (!ret && GetLastError() == NTE_EXISTS) {
1155 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1156 PROV_RSA_FULL, 0);
1157 }
1158 ok(ret, "CryptAcquireContext failed: 0x%x\n", GetLastError());
1159
1160 if (ret) {
1162 NULL, NULL);
1163 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1165 }
1166
1167 /* pCertInfo must still be set, but can be empty if the SignerId's issuer
1168 * and serial number are set.
1169 */
1170 certInfo.Issuer.cbData = 0;
1171 certInfo.SerialNumber.cbData = 0;
1172 signer.SignerId.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
1173 U(signer.SignerId).IssuerSerialNumber.Issuer.cbData =
1174 sizeof(encodedCommonName);
1175 U(signer.SignerId).IssuerSerialNumber.Issuer.pbData = encodedCommonName;
1176 U(signer.SignerId).IssuerSerialNumber.SerialNumber.cbData =
1177 sizeof(serialNum);
1178 U(signer.SignerId).IssuerSerialNumber.SerialNumber.pbData = serialNum;
1180 NULL, NULL);
1181 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1183
1185 pCryptAcquireContextA(&signer.hCryptProv, cspNameA, MS_DEF_PROV_A,
1187}
1188
1189static const BYTE privKey[] = {
1190 0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41, 0x32, 0x00,
1191 0x02, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x79, 0x10, 0x1c, 0xd0, 0x6b, 0x10,
1192 0x18, 0x30, 0x94, 0x61, 0xdc, 0x0e, 0xcb, 0x96, 0x4e, 0x21, 0x3f, 0x79, 0xcd,
1193 0xa9, 0x17, 0x62, 0xbc, 0xbb, 0x61, 0x4c, 0xe0, 0x75, 0x38, 0x6c, 0xf3, 0xde,
1194 0x60, 0x86, 0x03, 0x97, 0x65, 0xeb, 0x1e, 0x6b, 0xdb, 0x53, 0x85, 0xad, 0x68,
1195 0x21, 0xf1, 0x5d, 0xe7, 0x1f, 0xe6, 0x53, 0xb4, 0xbb, 0x59, 0x3e, 0x14, 0x27,
1196 0xb1, 0x83, 0xa7, 0x3a, 0x54, 0xe2, 0x8f, 0x65, 0x8e, 0x6a, 0x4a, 0xcf, 0x3b,
1197 0x1f, 0x65, 0xff, 0xfe, 0xf1, 0x31, 0x3a, 0x37, 0x7a, 0x8b, 0xcb, 0xc6, 0xd4,
1198 0x98, 0x50, 0x36, 0x67, 0xe4, 0xa1, 0xe8, 0x7e, 0x8a, 0xc5, 0x23, 0xf2, 0x77,
1199 0xf5, 0x37, 0x61, 0x49, 0x72, 0x59, 0xe8, 0x3d, 0xf7, 0x60, 0xb2, 0x77, 0xca,
1200 0x78, 0x54, 0x6d, 0x65, 0x9e, 0x03, 0x97, 0x1b, 0x61, 0xbd, 0x0c, 0xd8, 0x06,
1201 0x63, 0xe2, 0xc5, 0x48, 0xef, 0xb3, 0xe2, 0x6e, 0x98, 0x7d, 0xbd, 0x4e, 0x72,
1202 0x91, 0xdb, 0x31, 0x57, 0xe3, 0x65, 0x3a, 0x49, 0xca, 0xec, 0xd2, 0x02, 0x4e,
1203 0x22, 0x7e, 0x72, 0x8e, 0xf9, 0x79, 0x84, 0x82, 0xdf, 0x7b, 0x92, 0x2d, 0xaf,
1204 0xc9, 0xe4, 0x33, 0xef, 0x89, 0x5c, 0x66, 0x99, 0xd8, 0x80, 0x81, 0x47, 0x2b,
1205 0xb1, 0x66, 0x02, 0x84, 0x59, 0x7b, 0xc3, 0xbe, 0x98, 0x45, 0x4a, 0x3d, 0xdd,
1206 0xea, 0x2b, 0xdf, 0x4e, 0xb4, 0x24, 0x6b, 0xec, 0xe7, 0xd9, 0x0c, 0x45, 0xb8,
1207 0xbe, 0xca, 0x69, 0x37, 0x92, 0x4c, 0x38, 0x6b, 0x96, 0x6d, 0xcd, 0x86, 0x67,
1208 0x5c, 0xea, 0x54, 0x94, 0xa4, 0xca, 0xa4, 0x02, 0xa5, 0x21, 0x4d, 0xae, 0x40,
1209 0x8f, 0x9d, 0x51, 0x83, 0xf2, 0x3f, 0x33, 0xc1, 0x72, 0xb4, 0x1d, 0x94, 0x6e,
1210 0x7d, 0xe4, 0x27, 0x3f, 0xea, 0xff, 0xe5, 0x9b, 0xa7, 0x5e, 0x55, 0x8e, 0x0d,
1211 0x69, 0x1c, 0x7a, 0xff, 0x81, 0x9d, 0x53, 0x52, 0x97, 0x9a, 0x76, 0x79, 0xda,
1212 0x93, 0x32, 0x16, 0xec, 0x69, 0x51, 0x1a, 0x4e, 0xc3, 0xf1, 0x72, 0x80, 0x78,
1213 0x5e, 0x66, 0x4a, 0x8d, 0x85, 0x2f, 0x3f, 0xb2, 0xa7 };
1214static BYTE pubKey[] = {
12150x30,0x48,0x02,0x41,0x00,0xe2,0x54,0x3a,0xa7,0x83,0xb1,0x27,0x14,0x3e,0x59,
12160xbb,0xb4,0x53,0xe6,0x1f,0xe7,0x5d,0xf1,0x21,0x68,0xad,0x85,0x53,0xdb,0x6b,
12170x1e,0xeb,0x65,0x97,0x03,0x86,0x60,0xde,0xf3,0x6c,0x38,0x75,0xe0,0x4c,0x61,
12180xbb,0xbc,0x62,0x17,0xa9,0xcd,0x79,0x3f,0x21,0x4e,0x96,0xcb,0x0e,0xdc,0x61,
12190x94,0x30,0x18,0x10,0x6b,0xd0,0x1c,0x10,0x79,0x02,0x03,0x01,0x00,0x01 };
1220
1221static void test_signed_msg_update(void)
1222{
1223 HCRYPTMSG msg;
1224 BOOL ret;
1225 CMSG_SIGNED_ENCODE_INFO signInfo = { sizeof(signInfo), 0 };
1226 CMSG_SIGNER_ENCODE_INFO signer = { sizeof(signer), 0 };
1227 CERT_INFO certInfo = { 0 };
1228 HCRYPTKEY key;
1229
1230 certInfo.SerialNumber.cbData = sizeof(serialNum);
1231 certInfo.SerialNumber.pbData = serialNum;
1232 certInfo.Issuer.cbData = sizeof(encodedCommonName);
1233 certInfo.Issuer.pbData = encodedCommonName;
1234 signer.pCertInfo = &certInfo;
1236 signInfo.cSigners = 1;
1237 signInfo.rgSigners = &signer;
1238
1239 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1241 if (!ret && GetLastError() == NTE_EXISTS) {
1242 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1243 PROV_RSA_FULL, 0);
1244 }
1245 ok(ret, "CryptAcquireContext failed: 0x%x\n", GetLastError());
1246
1247 if (!ret) {
1248 skip("No context for tests\n");
1249 return;
1250 }
1251
1253 CMSG_DETACHED_FLAG, CMSG_SIGNED, &signInfo, NULL, NULL);
1254 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1255 /* Detached CMSG_SIGNED allows non-final updates. */
1256 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
1257 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1258 /* Detached CMSG_SIGNED also allows non-final updates with no data. */
1260 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1261 /* The final update requires a private key in the hCryptProv, in order to
1262 * generate the signature.
1263 */
1264 SetLastError(0xdeadbeef);
1265 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1266 ok(!ret &&
1268 GetLastError() == NTE_NO_KEY ||
1269 broken(GetLastError() == ERROR_SUCCESS)), /* Some Win9x */
1270 "Expected NTE_BAD_KEYSET or NTE_NO_KEY, got %x\n", GetLastError());
1271 ret = CryptImportKey(signer.hCryptProv, privKey, sizeof(privKey),
1272 0, 0, &key);
1273 ok(ret, "CryptImportKey failed: %08x\n", GetLastError());
1274 /* The final update should be able to succeed now that a key exists, but
1275 * the previous (invalid) final update prevents it.
1276 */
1277 SetLastError(0xdeadbeef);
1278 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1280 "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
1282
1284 CMSG_DETACHED_FLAG, CMSG_SIGNED, &signInfo, NULL, NULL);
1285 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1286 /* Detached CMSG_SIGNED allows non-final updates. */
1287 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
1288 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1289 /* Detached CMSG_SIGNED also allows non-final updates with no data. */
1291 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1292 /* Now that the private key exists, the final update can succeed (even
1293 * with no data.)
1294 */
1295 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1296 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1297 /* But no updates are allowed after the final update. */
1298 SetLastError(0xdeadbeef);
1301 "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
1302 SetLastError(0xdeadbeef);
1303 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1305 "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
1307
1309 NULL, NULL);
1310 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1311 /* Non-detached messages don't allow non-final updates.. */
1312 SetLastError(0xdeadbeef);
1313 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
1315 "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
1316 /* but they do allow final ones. */
1317 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1318 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
1321 NULL, NULL);
1322 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1323 /* They also allow final updates with no data. */
1324 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1325 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
1327
1330 pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL, PROV_RSA_FULL,
1332}
1333
13350x30,0x50,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,
13360xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x31,0x37,0x30,0x35,0x02,
13370x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
13380x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,
13390x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,
13400x04,0x06,0x00,0x05,0x00,0x04,0x00 };
1341static const BYTE signedEmptyContent[] = {
13420x30,0x5f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,0x52,
13430x30,0x50,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,
13440xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x31,0x37,0x30,0x35,0x02,
13450x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
13460x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,
13470x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,
13480x04,0x06,0x00,0x05,0x00,0x04,0x00 };
13500x30,0x81,0x99,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
13510x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,
13520xf7,0x0d,0x01,0x07,0x01,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,
13530x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
13540x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,
13550x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,
13560x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,
13570x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,
13580xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,
13590xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,
13600xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1361static const BYTE detachedSignedContent[] = {
13620x30,0x81,0xaa,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
13630x81,0x9c,0x30,0x81,0x99,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
13640x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,
13650x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,
13660x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,
13670x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,
13680x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,
13690x05,0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,
13700x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,
13710x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,
13720x64,0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,
13730xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1374static const BYTE signedBareContent[] = {
13750x30,0x81,0xa1,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
13760x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,
13770xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x31,0x77,
13780x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,
13790x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,
13800x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,
13810x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,
13820x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,
13830xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,
13840x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,
13850xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1386static const BYTE signedContent[] = {
13870x30,0x81,0xb2,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
13880x81,0xa4,0x30,0x81,0xa1,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
13890x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,
13900x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,
13910x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,
13920x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
13930x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
13940x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,
13950xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,
13960x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,
13970x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,
13980xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,
13990x0d };
1400static const BYTE signedHash[] = {
14010x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,
14020x2f };
14040x30,0x46,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,0x39,
14050x30,0x37,0x02,0x01,0x03,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,
14060xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x31,0x1e,0x30,0x1c,0x02,
14070x01,0x03,0x80,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
14080x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
1409static const BYTE signedEncodedSigner[] = {
14100x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,
14110x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,
14120x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,
14130x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,
14140x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,
14150xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,
14160x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,
14170xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
14190x30,0x82,0x01,0x00,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,
14200x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,
14210x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x31,
14220x81,0xd5,0x30,0x81,0xd2,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,
14230x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
14240x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,
14250x0d,0x02,0x05,0x05,0x00,0xa0,0x5b,0x30,0x18,0x06,0x09,0x2a,0x86,0x48,0x86,
14260xf7,0x0d,0x01,0x09,0x03,0x31,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,
14270x01,0x07,0x01,0x30,0x1e,0x06,0x03,0x55,0x04,0x03,0x31,0x17,0x30,0x15,0x31,
14280x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,
14290x4c,0x61,0x6e,0x67,0x00,0x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,
14300x01,0x09,0x04,0x31,0x12,0x04,0x10,0x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,
14310xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f,0x30,0x04,0x06,0x00,0x05,0x00,0x04,
14320x40,0xbf,0x65,0xde,0x7a,0x3e,0xa2,0x19,0x59,0xc3,0xc7,0x02,0x53,0xc9,0x72,
14330xcd,0x74,0x96,0x70,0x0b,0x3b,0xcf,0x8b,0xd9,0x17,0x5c,0xc5,0xd1,0x83,0x41,
14340x32,0x93,0xa6,0xf3,0x52,0x83,0x94,0xa9,0x6b,0x0a,0x92,0xcf,0xaf,0x12,0xfa,
14350x40,0x53,0x12,0x84,0x03,0xab,0x10,0xa2,0x3d,0xe6,0x9f,0x5a,0xbf,0xc5,0xb8,
14360xff,0xc6,0x33,0x63,0x34 };
1437static BYTE cert[] = {
14380x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,
14390x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
14400x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
14410x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
14420x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,
14430x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,
14440x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,0x30,
14450x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,
14460xff,0x02,0x01,0x01 };
14480x30,0x81,0x95,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
14490x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
14500x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
14510x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
14520x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
14530x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
14540x67,0x00,0x30,0x22,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
14550x01,0x01,0x05,0x00,0x03,0x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
14560x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,
14570x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,
14580x01,0x01 };
14600x30,0x81,0xce,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
14610x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0xa0,0x7c,0x30,0x7a,
14620x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,
14630x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,
14640x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,
14650x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
14660x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,
14670x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,
14680x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,
14690x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,
14700x01,0x01,0x31,0x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,
14710x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,
14720x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,
14730xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
14750x30,0x82,0x01,0x1f,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,
14760x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,
14770x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0xa0,
14780x7c,0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
14790x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
14800x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
14810x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
14820x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
14830x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
14840x67,0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,
14850x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,
14860x01,0xff,0x02,0x01,0x01,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,
14870x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
14880x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,
14890x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,
14900x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,
14910x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,
14920xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,
14930xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,
14940xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1495static BYTE crl[] = { 0x30,0x2c,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
14960x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
14970x6e,0x67,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,
14980x30,0x30,0x30,0x30,0x5a };
15000x30,0x81,0x80,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
15010x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0xa1,0x2e,0x30,0x2c,
15020x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
15030x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x18,0x0f,0x31,
15040x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x31,
15050x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,
15060x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,
15070x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,
15080x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
15100x30,0x81,0xd1,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
15110x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,
15120xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0xa1,0x2e,
15130x30,0x2c,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,
15140x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x18,
15150x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,
15160x5a,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,
15170x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
15180x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,
15190x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0x81,0xa6,
15200x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,
15210x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,
15220xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,
15230x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,
15240xa8,0x0d };
15260x30,0x81,0xfe,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
15270x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0xa0,0x7c,0x30,0x7a,
15280x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,
15290x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,
15300x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,
15310x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
15320x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,
15330x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,
15340x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,
15350x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,
15360x01,0x01,0xa1,0x2e,0x30,0x2c,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
15370x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
15380x6e,0x67,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,
15390x30,0x30,0x30,0x30,0x5a,0x31,0x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,
15400x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
15410x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,
15420x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,
15430x04,0x00 };
15450x30,0x82,0x01,0x4f,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,
15460x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,
15470x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0xa0,
15480x7c,0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
15490x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
15500x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
15510x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
15520x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
15530x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
15540x67,0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,
15550x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,
15560x01,0xff,0x02,0x01,0x01,0xa1,0x2e,0x30,0x2c,0x30,0x02,0x06,0x00,0x30,0x15,
15570x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
15580x20,0x4c,0x61,0x6e,0x67,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
15590x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x31,0x77,0x30,0x75,0x02,0x01,0x01,
15600x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,
15610x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,
15620x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,
15630x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,
15640xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,
15650xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,
15660x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,
15670x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
15690x30,0x81,0xeb,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
15700x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0xa0,0x81,0x98,0x30,
15710x81,0x95,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,
15720x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
15730x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
15740x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
15750x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,
15760x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,
15770x00,0x30,0x22,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,
15780x01,0x05,0x00,0x03,0x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,
15790x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,
15800x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,
15810x01,0x31,0x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,
15820x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
15830x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,
15840x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
15860x30,0x81,0xcf,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
15870x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
15880x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
15890x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
15900x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
15910x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
15920x67,0x00,0x30,0x5c,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
15930x01,0x01,0x05,0x00,0x03,0x4b,0x00,0x30,0x48,0x02,0x41,0x00,0xe2,0x54,0x3a,
15940xa7,0x83,0xb1,0x27,0x14,0x3e,0x59,0xbb,0xb4,0x53,0xe6,0x1f,0xe7,0x5d,0xf1,
15950x21,0x68,0xad,0x85,0x53,0xdb,0x6b,0x1e,0xeb,0x65,0x97,0x03,0x86,0x60,0xde,
15960xf3,0x6c,0x38,0x75,0xe0,0x4c,0x61,0xbb,0xbc,0x62,0x17,0xa9,0xcd,0x79,0x3f,
15970x21,0x4e,0x96,0xcb,0x0e,0xdc,0x61,0x94,0x30,0x18,0x10,0x6b,0xd0,0x1c,0x10,
15980x79,0x02,0x03,0x01,0x00,0x01,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,0x55,
15990x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
16010x30,0x82,0x01,0x38,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
16020xa0,0x82,0x01,0x29,0x30,0x82,0x01,0x25,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,
16030x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,
16040x00,0xa0,0x81,0xd2,0x30,0x81,0xcf,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,
16050x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
16060x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,
16070x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,
16080x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,
16090x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
16100x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x5c,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,
16110x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x03,0x4b,0x00,0x30,0x48,0x02,0x41,
16120x00,0xe2,0x54,0x3a,0xa7,0x83,0xb1,0x27,0x14,0x3e,0x59,0xbb,0xb4,0x53,0xe6,
16130x1f,0xe7,0x5d,0xf1,0x21,0x68,0xad,0x85,0x53,0xdb,0x6b,0x1e,0xeb,0x65,0x97,
16140x03,0x86,0x60,0xde,0xf3,0x6c,0x38,0x75,0xe0,0x4c,0x61,0xbb,0xbc,0x62,0x17,
16150xa9,0xcd,0x79,0x3f,0x21,0x4e,0x96,0xcb,0x0e,0xdc,0x61,0x94,0x30,0x18,0x10,
16160x6b,0xd0,0x1c,0x10,0x79,0x02,0x03,0x01,0x00,0x01,0xa3,0x16,0x30,0x14,0x30,
16170x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,
16180xff,0x02,0x01,0x01,0x31,0x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,
16190x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
16200x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,
16210x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,
16220x00 };
16240x30,0x82,0x01,0x89,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
16250xa0,0x82,0x01,0x7a,0x30,0x82,0x01,0x76,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,
16260x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,
16270x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,
16280x02,0x03,0x04,0xa0,0x81,0xd2,0x30,0x81,0xcf,0x02,0x01,0x01,0x30,0x02,0x06,
16290x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,
16300x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,
16310x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,
16320x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,
16330x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,
16340x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x5c,0x30,0x0d,0x06,0x09,0x2a,
16350x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x03,0x4b,0x00,0x30,0x48,
16360x02,0x41,0x00,0xe2,0x54,0x3a,0xa7,0x83,0xb1,0x27,0x14,0x3e,0x59,0xbb,0xb4,
16370x53,0xe6,0x1f,0xe7,0x5d,0xf1,0x21,0x68,0xad,0x85,0x53,0xdb,0x6b,0x1e,0xeb,
16380x65,0x97,0x03,0x86,0x60,0xde,0xf3,0x6c,0x38,0x75,0xe0,0x4c,0x61,0xbb,0xbc,
16390x62,0x17,0xa9,0xcd,0x79,0x3f,0x21,0x4e,0x96,0xcb,0x0e,0xdc,0x61,0x94,0x30,
16400x18,0x10,0x6b,0xd0,0x1c,0x10,0x79,0x02,0x03,0x01,0x00,0x01,0xa3,0x16,0x30,
16410x14,0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,
16420x01,0x01,0xff,0x02,0x01,0x01,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,
16430x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,
16440x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,
16450x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,
16460x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,
16470xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,
16480xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,
16490x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,
16500x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1651
1653{
1654 HCRYPTMSG msg;
1655 CMSG_SIGNED_ENCODE_INFO signInfo = { sizeof(signInfo), 0 };
1656 CMSG_SIGNER_ENCODE_INFO signer = { sizeof(signer), 0 };
1657 CERT_INFO certInfo = { 0 };
1658 CERT_BLOB encodedCert = { sizeof(cert), cert };
1659 CRL_BLOB encodedCrl = { sizeof(crl), crl };
1660 char oid_common_name[] = szOID_COMMON_NAME;
1663 CRYPT_ATTRIBUTE attr = { oid_common_name, 1, &commonName };
1664 BOOL ret;
1665 HCRYPTKEY key;
1666 DWORD size;
1667
1668 certInfo.SerialNumber.cbData = sizeof(serialNum);
1669 certInfo.SerialNumber.pbData = serialNum;
1670 certInfo.Issuer.cbData = sizeof(encodedCommonName);
1671 certInfo.Issuer.pbData = encodedCommonName;
1672 signer.pCertInfo = &certInfo;
1674 signInfo.cSigners = 1;
1675 signInfo.rgSigners = &signer;
1676
1677 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1679 if (!ret && GetLastError() == NTE_EXISTS) {
1680 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1681 PROV_RSA_FULL, 0);
1682 }
1683 ok(ret, "CryptAcquireContext failed: 0x%x\n", GetLastError());
1684
1685 if (!ret) {
1686 skip("No context for tests\n");
1687 return;
1688 }
1689
1690 ret = CryptImportKey(signer.hCryptProv, privKey, sizeof(privKey),
1691 0, 0, &key);
1692 ok(ret, "CryptImportKey failed: %08x\n", GetLastError());
1693
1695 CMSG_DETACHED_FLAG, CMSG_SIGNED, &signInfo, NULL, NULL);
1696 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1697
1698 check_param("detached signed empty bare content", msg,
1700 sizeof(signedEmptyBareContent));
1701 check_param("detached signed empty content", msg, CMSG_CONTENT_PARAM,
1703 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1704 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1705 check_param("detached signed hash", msg, CMSG_COMPUTED_HASH_PARAM,
1706 signedHash, sizeof(signedHash));
1707 check_param("detached signed bare content", msg, CMSG_BARE_CONTENT_PARAM,
1709 check_param("detached signed content", msg, CMSG_CONTENT_PARAM,
1711 SetLastError(0xdeadbeef);
1714 broken(GetLastError() == CRYPT_E_INVALID_MSG_TYPE /* Win9x */)),
1715 "Expected CRYPT_E_INVALID_INDEX, got %x\n", GetLastError());
1716 check_param("detached signed encoded signer", msg, CMSG_ENCODED_SIGNER,
1718
1720
1721 certInfo.SerialNumber.cbData = 0;
1722 certInfo.Issuer.cbData = 0;
1723 signer.SignerId.dwIdChoice = CERT_ID_KEY_IDENTIFIER;
1724 U(signer.SignerId).KeyId.cbData = sizeof(serialNum);
1725 U(signer.SignerId).KeyId.pbData = serialNum;
1727 NULL, NULL);
1728 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1729 check_param("signed key id empty content", msg, CMSG_CONTENT_PARAM,
1732
1733 certInfo.SerialNumber.cbData = sizeof(serialNum);
1734 certInfo.SerialNumber.pbData = serialNum;
1735 certInfo.Issuer.cbData = sizeof(encodedCommonName);
1736 certInfo.Issuer.pbData = encodedCommonName;
1737 signer.SignerId.dwIdChoice = 0;
1739 NULL, NULL);
1740 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1741
1742 check_param("signed empty bare content", msg, CMSG_BARE_CONTENT_PARAM,
1744 check_param("signed empty content", msg, CMSG_CONTENT_PARAM,
1746 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1747 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1748 check_param("signed bare content", msg, CMSG_BARE_CONTENT_PARAM,
1750 check_param("signed content", msg, CMSG_CONTENT_PARAM,
1751 signedContent, sizeof(signedContent));
1752
1754
1755 signer.cAuthAttr = 1;
1756 signer.rgAuthAttr = &attr;
1758 NULL, NULL);
1759 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1760
1762 check_param("signed with auth attrs bare content", msg,
1765
1767
1768 signer.cAuthAttr = 0;
1769 signInfo.rgCertEncoded = &encodedCert;
1770 signInfo.cCertEncoded = 1;
1772 NULL, NULL);
1773 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1774
1775 check_param("signed with cert empty bare content", msg,
1778 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1779 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1780 check_param("signed with cert bare content", msg, CMSG_BARE_CONTENT_PARAM,
1782
1784
1785 signInfo.cCertEncoded = 0;
1786 signInfo.rgCrlEncoded = &encodedCrl;
1787 signInfo.cCrlEncoded = 1;
1789 NULL, NULL);
1790 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1791
1792 check_param("signed with crl empty bare content", msg,
1795 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1796 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1797 check_param("signed with crl bare content", msg, CMSG_BARE_CONTENT_PARAM,
1799
1801
1802 signInfo.cCertEncoded = 1;
1804 NULL, NULL);
1805 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1806
1807 check_param("signed with cert and crl empty bare content", msg,
1810 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1811 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1812 check_param("signed with cert and crl bare content", msg,
1815
1817
1818 /* Test with a cert with a (bogus) public key */
1819 signInfo.cCrlEncoded = 0;
1820 encodedCert.cbData = sizeof(v1CertWithPubKey);
1821 encodedCert.pbData = v1CertWithPubKey;
1823 NULL, NULL);
1824 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1825 check_param("signedWithCertWithPubKeyBareContent", msg,
1829
1830 encodedCert.cbData = sizeof(v1CertWithValidPubKey);
1831 encodedCert.pbData = v1CertWithValidPubKey;
1833 NULL, NULL);
1834 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1835 check_param("signedWithCertWithValidPubKeyEmptyContent", msg,
1838 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1839 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
1840 check_param("signedWithCertWithValidPubKeyContent", msg,
1844
1847 pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL, PROV_RSA_FULL,
1849}
1850
1852{
1853 BOOL ret;
1854 HCRYPTMSG msg;
1855 DWORD size, value = 0;
1856 CMSG_SIGNED_ENCODE_INFO signInfo = { sizeof(signInfo), 0 };
1857 CMSG_SIGNER_ENCODE_INFO signer = { sizeof(signer), 0 };
1858 CERT_INFO certInfo = { 0 };
1859
1861 NULL, NULL);
1862 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1863
1864 /* Content and bare content are always gettable */
1865 size = 0;
1867 ok(ret || broken(!ret /* Win9x */), "CryptMsgGetParam failed: %08x\n",
1868 GetLastError());
1869 if (!ret)
1870 {
1871 skip("message parameters are broken, skipping tests\n");
1872 return;
1873 }
1874 size = 0;
1876 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
1877 /* For "signed" messages, so is the version. */
1878 size = 0;
1880 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
1881 size = sizeof(value);
1883 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
1884 ok(value == CMSG_SIGNED_DATA_V1, "Expected version 1, got %d\n", value);
1885 /* But for this message, with no signers, the hash and signer aren't
1886 * available.
1887 */
1888 size = 0;
1889 SetLastError(0xdeadbeef);
1892 "Expected CRYPT_E_INVALID_INDEX, got %x\n", GetLastError());
1893 SetLastError(0xdeadbeef);
1896 "Expected CRYPT_E_INVALID_INDEX, got %x\n", GetLastError());
1897 /* As usual, the type isn't available. */
1900 "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
1901
1903
1904 certInfo.SerialNumber.cbData = sizeof(serialNum);
1905 certInfo.SerialNumber.pbData = serialNum;
1906 certInfo.Issuer.cbData = sizeof(encodedCommonName);
1907 certInfo.Issuer.pbData = encodedCommonName;
1908 signer.pCertInfo = &certInfo;
1910 signInfo.cSigners = 1;
1911 signInfo.rgSigners = &signer;
1912
1913 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1915 if (!ret && GetLastError() == NTE_EXISTS) {
1916 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1917 PROV_RSA_FULL, 0);
1918 }
1919 ok(ret, "CryptAcquireContext failed: 0x%x\n", GetLastError());
1920
1921 if (!ret) {
1922 skip("No context for tests\n");
1923 return;
1924 }
1925
1927 NULL, NULL);
1928 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1929
1930 /* This message, with one signer, has the hash and signer for index 0
1931 * available, but not for other indexes.
1932 */
1933 size = 0;
1935 ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
1937 ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
1938 size = 0;
1939 SetLastError(0xdeadbeef);
1942 "Expected CRYPT_E_INVALID_INDEX, got %x\n", GetLastError());
1943 SetLastError(0xdeadbeef);
1946 "Expected CRYPT_E_INVALID_INDEX, got %x\n", GetLastError());
1947 /* As usual, the type isn't available. */
1950 "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
1951
1953
1954 /* Opening the message using the CMS fields.. */
1955 certInfo.SerialNumber.cbData = 0;
1956 certInfo.Issuer.cbData = 0;
1957 signer.SignerId.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
1958 U(signer.SignerId).IssuerSerialNumber.Issuer.cbData =
1959 sizeof(encodedCommonName);
1960 U(signer.SignerId).IssuerSerialNumber.Issuer.pbData = encodedCommonName;
1961 U(signer.SignerId).IssuerSerialNumber.SerialNumber.cbData =
1962 sizeof(serialNum);
1963 U(signer.SignerId).IssuerSerialNumber.SerialNumber.pbData = serialNum;
1964 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1966 if (!ret && GetLastError() == NTE_EXISTS)
1967 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1968 PROV_RSA_FULL, 0);
1969 ok(ret, "CryptAcquireContextA failed: %x\n", GetLastError());
1972 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1973 /* still results in the version being 1 when the issuer and serial number
1974 * are used and no additional CMS fields are used.
1975 */
1976 size = sizeof(value);
1979 "CryptMsgGetParam failed: %08x\n", GetLastError());
1980 if (ret)
1981 ok(value == CMSG_SIGNED_DATA_V1, "expected version 1, got %d\n", value);
1982 /* Apparently the encoded signer can be retrieved.. */
1984 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
1985 /* but the signer info, CMS signer info, and cert ID can't be. */
1986 SetLastError(0xdeadbeef);
1989 "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
1990 SetLastError(0xdeadbeef);
1993 "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
1994 SetLastError(0xdeadbeef);
1997 "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
1999
2000 /* Using the KeyId field of the SignerId results in the version becoming
2001 * the CMS version.
2002 */
2003 signer.SignerId.dwIdChoice = CERT_ID_KEY_IDENTIFIER;
2004 U(signer.SignerId).KeyId.cbData = sizeof(serialNum);
2005 U(signer.SignerId).KeyId.pbData = serialNum;
2006 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
2008 if (!ret && GetLastError() == NTE_EXISTS)
2009 ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
2010 PROV_RSA_FULL, 0);
2011 ok(ret, "CryptAcquireContextA failed: %x\n", GetLastError());
2014 ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
2015 size = sizeof(value);
2017 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2018 if (ret)
2019 ok(value == CMSG_SIGNED_DATA_V3, "expected version 3, got %d\n", value);
2020 /* Even for a CMS message, the signer can be retrieved.. */
2022 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2023 /* but the signer info, CMS signer info, and cert ID can't be. */
2024 SetLastError(0xdeadbeef);
2027 "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
2028 SetLastError(0xdeadbeef);
2031 "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
2032 SetLastError(0xdeadbeef);
2035 "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
2037
2039 pCryptAcquireContextA(&signer.hCryptProv, cspNameA, MS_DEF_PROV_A,
2041}
2042
2043static void test_signed_msg(void)
2044{
2049}
2050
2052
2054{
2055 HCRYPTMSG msg;
2056 BOOL ret;
2057 CMSG_ENVELOPED_ENCODE_INFO envelopedInfo = { 0 };
2059
2060 SetLastError(0xdeadbeef);
2062 &envelopedInfo, NULL, NULL);
2064 "expected E_INVALIDARG, got %08x\n", GetLastError());
2065
2066 envelopedInfo.cbSize = sizeof(envelopedInfo);
2067 SetLastError(0xdeadbeef);
2069 &envelopedInfo, NULL, NULL);
2070 ok(!msg &&
2072 GetLastError() == E_INVALIDARG), /* Win9x */
2073 "expected CRYPT_E_UNKNOWN_ALGO or E_INVALIDARG, got %08x\n", GetLastError());
2074
2076 SetLastError(0xdeadbeef);
2078 &envelopedInfo, NULL, NULL);
2079 ok(msg != NULL ||
2080 broken(!msg), /* Win9x */
2081 "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2083
2084 envelopedInfo.cRecipients = 1;
2085 if (!old_crypt32)
2086 {
2087 SetLastError(0xdeadbeef);
2089 &envelopedInfo, NULL, NULL);
2091 "expected E_INVALIDARG, got %08x\n", GetLastError());
2092 }
2093
2096 if (context)
2097 {
2098 envelopedInfo.rgpRecipientCert = (PCERT_INFO *)&context->pCertInfo;
2099 SetLastError(0xdeadbeef);
2101 &envelopedInfo, NULL, NULL);
2102 ok(msg != NULL, "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2104 SetLastError(0xdeadbeef);
2105 ret = pCryptAcquireContextA(&envelopedInfo.hCryptProv, NULL, NULL,
2107 ok(ret, "CryptAcquireContextA failed: %08x\n", GetLastError());
2108 SetLastError(0xdeadbeef);
2110 &envelopedInfo, NULL, NULL);
2111 ok(msg != NULL, "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2113 CryptReleaseContext(envelopedInfo.hCryptProv, 0);
2115 }
2116 else
2117 win_skip("failed to create certificate context, skipping tests\n");
2118}
2119
2121{
2122 HCRYPTMSG msg;
2123 BOOL ret;
2124 CMSG_ENVELOPED_ENCODE_INFO envelopedInfo = { sizeof(envelopedInfo), 0,
2125 { oid_rsa_rc4, { 0, NULL } }, NULL };
2126 CMSG_STREAM_INFO streamInfo = { 0, nop_stream_output, NULL };
2127
2128 SetLastError(0xdeadbeef);
2130 &envelopedInfo, NULL, NULL);
2131 ok(msg != NULL ||
2132 broken(!msg), /* Win9x */
2133 "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2134 if (msg)
2135 {
2136 SetLastError(0xdeadbeef);
2139 "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2140 SetLastError(0xdeadbeef);
2141 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2142 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2143 SetLastError(0xdeadbeef);
2144 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2146 "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2148 }
2149 SetLastError(0xdeadbeef);
2151 &envelopedInfo, NULL, NULL);
2152 ok(msg != NULL ||
2153 broken(!msg), /* Win9x */
2154 "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2155 if (msg)
2156 {
2157 SetLastError(0xdeadbeef);
2158 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
2160 "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2161 SetLastError(0xdeadbeef);
2162 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
2163 ok(ret ||
2164 broken(!ret && GetLastError() == NTE_PERM), /* some NT4 */
2165 "CryptMsgUpdate failed: %08x\n", GetLastError());
2166 SetLastError(0xdeadbeef);
2167 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2169 "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2171 }
2172 SetLastError(0xdeadbeef);
2174 CMSG_ENVELOPED, &envelopedInfo, NULL, NULL);
2175 ok(msg != NULL ||
2176 broken(!msg), /* Win9x */
2177 "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2178 if (msg)
2179 {
2180 SetLastError(0xdeadbeef);
2183 "expected E_INVALIDARG, got %08x\n", GetLastError());
2184 SetLastError(0xdeadbeef);
2185 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2186 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2188 }
2189 SetLastError(0xdeadbeef);
2191 CMSG_ENVELOPED, &envelopedInfo, NULL, NULL);
2192 ok(msg != NULL ||
2193 broken(!msg), /* Win9x */
2194 "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2195 if (msg)
2196 {
2197 SetLastError(0xdeadbeef);
2198 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
2200 "expected E_INVALIDARG, got %08x\n", GetLastError());
2201 SetLastError(0xdeadbeef);
2202 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
2203 ok(ret ||
2204 broken(!ret && GetLastError() == NTE_PERM), /* some NT4 */
2205 "CryptMsgUpdate failed: %08x\n", GetLastError());
2207 }
2208 SetLastError(0xdeadbeef);
2210 &envelopedInfo, NULL, &streamInfo);
2211 ok(msg != NULL ||
2212 broken(!msg), /* Win9x */
2213 "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2214 if (msg)
2215 {
2216 SetLastError(0xdeadbeef);
2218 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2219 SetLastError(0xdeadbeef);
2220 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2221 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2223 }
2224 SetLastError(0xdeadbeef);
2226 &envelopedInfo, NULL, &streamInfo);
2227 ok(msg != NULL ||
2228 broken(!msg), /* Win9x */
2229 "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2230 if (msg)
2231 {
2232 SetLastError(0xdeadbeef);
2233 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
2234 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2235 SetLastError(0xdeadbeef);
2236 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
2237 ok(ret ||
2238 broken(!ret && GetLastError() == NTE_PERM), /* some NT4 */
2239 "CryptMsgUpdate failed: %08x\n", GetLastError());
2241 }
2242}
2243
22450x30,0x22,0x02,0x01,0x00,0x31,0x00,0x30,0x1b,0x06,0x09,0x2a,0x86,0x48,0x86,
22460xf7,0x0d,0x01,0x07,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
22470x03,0x04,0x05,0x00,0x80,0x00 };
2248static const BYTE envelopedEmptyContent[] = {
22490x30,0x31,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x03,0xa0,0x24,
22500x30,0x22,0x02,0x01,0x00,0x31,0x00,0x30,0x1b,0x06,0x09,0x2a,0x86,0x48,0x86,
22510xf7,0x0d,0x01,0x07,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
22520x03,0x04,0x05,0x00,0x80,0x00 };
2253
2255{
2256 HCRYPTMSG msg;
2257 CMSG_ENVELOPED_ENCODE_INFO envelopedInfo = { sizeof(envelopedInfo), 0,
2258 { oid_rsa_rc4, { 0, NULL } }, NULL };
2259
2260 SetLastError(0xdeadbeef);
2262 &envelopedInfo, NULL, NULL);
2263 ok(msg != NULL ||
2264 broken(!msg), /* Win9x */
2265 "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2266 if (msg)
2267 {
2268 check_param("enveloped empty bare content", msg,
2271 check_param("enveloped empty content", msg, CMSG_CONTENT_PARAM,
2274 }
2275}
2276
2277static void test_enveloped_msg(void)
2278{
2282}
2283
2284static CRYPT_DATA_BLOB b4 = { 0, NULL };
2285static const struct update_accum a4 = { 1, &b4 };
2286
2287static const BYTE bogusOIDContent[] = {
22880x30,0x0f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x07,0xa0,0x02,
22890x04,0x00 };
2290static const BYTE bogusHashContent[] = {
22910x30,0x47,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x3a,
22920x30,0x38,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
22930x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
22940x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x04,0x10,0x00,0xd6,0xc0,
22950x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f };
22970x30,0x81,0xdb,0x02,0x01,0x00,0x31,0x81,0xba,0x30,0x81,0xb7,0x02,0x01,0x00,
22980x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,
22990x4e,0x02,0x10,0x63,0x75,0x75,0x7a,0x53,0x36,0xa9,0xba,0x41,0xa5,0xcc,0x01,
23000x7f,0x76,0x4c,0xd9,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
23010x01,0x01,0x05,0x00,0x04,0x81,0x80,0x87,0x46,0x26,0x56,0xe3,0xf3,0xa5,0x5b,
23020xd4,0x2c,0x03,0xcc,0x52,0x7e,0xf7,0x55,0xf1,0x34,0x9f,0x63,0xf6,0x04,0x9f,
23030xc5,0x13,0xf1,0xc9,0x57,0x0a,0xbc,0xa9,0x33,0xd2,0xf2,0x93,0xb6,0x5c,0x94,
23040xc3,0x49,0xd6,0xd6,0x6d,0xc4,0x91,0x38,0x80,0xdd,0x0d,0x82,0xef,0xe5,0x72,
23050x55,0x40,0x0a,0xdd,0x35,0xfe,0xdc,0x87,0x47,0x92,0xb1,0xbd,0x05,0xc9,0x18,
23060x0e,0xde,0x4b,0x00,0x70,0x40,0x31,0x1f,0x5d,0x6c,0x8f,0x3a,0xfb,0x9a,0xc3,
23070xb3,0x06,0xe7,0x68,0x3f,0x20,0x14,0x1c,0xf9,0x28,0x4b,0x0f,0x01,0x01,0xb6,
23080xfe,0x07,0xe5,0xd8,0xf0,0x7c,0x17,0xbc,0xec,0xfb,0xd7,0x73,0x8a,0x71,0x49,
23090x79,0x62,0xe4,0xbf,0xb5,0xe3,0x56,0xa6,0xb4,0x49,0x1e,0xdc,0xaf,0xd7,0x0e,
23100x30,0x19,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0x30,0x0c,
23110x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x04,0x05,0x00 };
2312
2313static void test_decode_msg_update(void)
2314{
2315 HCRYPTMSG msg;
2316 BOOL ret;
2317 CMSG_STREAM_INFO streamInfo = { 0 };
2318 DWORD i;
2319 struct update_accum accum = { 0, NULL };
2320
2322 /* Update with a full message in a final update */
2324 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2325 /* Can't update after a final update */
2326 SetLastError(0xdeadbeef);
2329 "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
2331
2333 /* Can't send a non-final update without streaming */
2334 SetLastError(0xdeadbeef);
2336 FALSE);
2338 "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
2339 /* A subsequent final update succeeds */
2341 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2343
2344 if (!old_crypt32)
2345 {
2346 msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, &streamInfo);
2347 /* Updating a message that has a NULL stream callback fails */
2348 SetLastError(0xdeadbeef);
2349 /* Crashes on some Win9x */
2351 FALSE);
2352 todo_wine
2354 GetLastError() == STATUS_ILLEGAL_INSTRUCTION /* WinME */),
2355 "Expected STATUS_ACCESS_VIOLATION or STATUS_ILLEGAL_INSTRUCTION, got %x\n",
2356 GetLastError());
2357 /* Changing the callback pointer after the fact yields the same error (so
2358 * the message must copy the stream info, not just store a pointer to it)
2359 */
2361 SetLastError(0xdeadbeef);
2363 FALSE);
2364 todo_wine
2366 GetLastError() == STATUS_ILLEGAL_INSTRUCTION /* WinME */),
2367 "Expected STATUS_ACCESS_VIOLATION or STATUS_ILLEGAL_INSTRUCTION, got %x\n",
2368 GetLastError());
2370 }
2371
2372 /* Empty non-final updates are allowed when streaming.. */
2373 msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, &streamInfo);
2375 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2376 /* but final updates aren't when not enough data has been received. */
2377 SetLastError(0xdeadbeef);
2378 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2379 todo_wine
2381 "Expected CRYPT_E_STREAM_INSUFFICIENT_DATA, got %x\n", GetLastError());
2383
2384 /* Updating the message byte by byte is legal */
2386 streamInfo.pvArg = &accum;
2387 msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, &streamInfo);
2388 for (i = 0, ret = TRUE; ret && i < sizeof(dataEmptyContent); i++)
2390 ok(ret, "CryptMsgUpdate failed on byte %d: %x\n", i, GetLastError());
2391 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2392 ok(ret, "CryptMsgUpdate failed on byte %d: %x\n", i, GetLastError());
2394 todo_wine
2395 check_updates("byte-by-byte empty content", &a4, &accum);
2396 free_updates(&accum);
2397
2398 /* Decoding bogus content fails in non-streaming mode.. */
2400 SetLastError(0xdeadbeef);
2401 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
2403 GetLastError() == OSS_PDU_MISMATCH /* Win9x */),
2404 "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %x\n",
2405 GetLastError());
2407 /* and as the final update in streaming mode.. */
2409 msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, &streamInfo);
2410 SetLastError(0xdeadbeef);
2411 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
2413 GetLastError() == OSS_PDU_MISMATCH /* Win9x */),
2414 "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %x\n",
2415 GetLastError());
2417 /* and even as a non-final update in streaming mode. */
2419 msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, &streamInfo);
2420 SetLastError(0xdeadbeef);
2421 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
2422 todo_wine
2424 GetLastError() == OSS_PDU_MISMATCH /* Win9x */),
2425 "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %x\n",
2426 GetLastError());
2428
2429 /* An empty message can be opened with undetermined type.. */
2432 TRUE);
2433 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2435 /* but decoding it as an explicitly typed message fails. */
2437 NULL);
2438 SetLastError(0xdeadbeef);
2440 TRUE);
2442 GetLastError() == OSS_PDU_MISMATCH /* Win9x */),
2443 "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %x\n",
2444 GetLastError());
2446 /* On the other hand, decoding the bare content of an empty message fails
2447 * with unspecified type..
2448 */
2450 SetLastError(0xdeadbeef);
2452 sizeof(dataEmptyBareContent), TRUE);
2454 GetLastError() == OSS_PDU_MISMATCH /* Win9x */),
2455 "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %x\n",
2456 GetLastError());
2458 /* but succeeds with explicit type. */
2460 NULL);
2462 sizeof(dataEmptyBareContent), TRUE);
2463 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2465
2466 /* Decoding valid content with an unsupported OID fails */
2468 SetLastError(0xdeadbeef);
2471 "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
2473
2474 /* Similarly, opening an empty hash with unspecified type succeeds.. */
2476 SetLastError(0xdeadbeef);
2478 ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
2479 "CryptMsgUpdate failed: %08x\n", GetLastError());
2481 /* while with specified type it fails. */
2483 NULL);
2484 SetLastError(0xdeadbeef);
2487 GetLastError() == OSS_PDU_MISMATCH /* some Win9x */ ||
2488 GetLastError() == OSS_DATA_ERROR /* some Win9x */),
2489 "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH or OSS_DATA_ERROR, got %x\n",
2490 GetLastError());
2492 /* On the other hand, decoding the bare content of an empty hash message
2493 * fails with unspecified type..
2494 */
2496 SetLastError(0xdeadbeef);
2498 sizeof(hashEmptyBareContent), TRUE);
2500 GetLastError() == OSS_PDU_MISMATCH /* some Win9x */ ||
2501 GetLastError() == OSS_DATA_ERROR /* some Win9x */),
2502 "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH or OSS_DATA_ERROR, got %x\n",
2503 GetLastError());
2505 /* but succeeds with explicit type. */
2507 NULL);
2509 sizeof(hashEmptyBareContent), TRUE);
2510 ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* win9x */),
2511 "CryptMsgUpdate failed: %x\n", GetLastError());
2513
2514 /* And again, opening a (non-empty) hash message with unspecified type
2515 * succeeds..
2516 */
2518 SetLastError(0xdeadbeef);
2520 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2522 /* while with specified type it fails.. */
2524 NULL);
2525 SetLastError(0xdeadbeef);
2528 GetLastError() == OSS_PDU_MISMATCH /* some Win9x */ ||
2529 GetLastError() == OSS_DATA_ERROR /* some Win9x */),
2530 "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH or OSS_DATA_ERROR, got %x\n",
2531 GetLastError());
2533 /* and decoding the bare content of a non-empty hash message fails with
2534 * unspecified type..
2535 */
2537 SetLastError(0xdeadbeef);
2540 GetLastError() == OSS_PDU_MISMATCH /* some Win9x */ ||
2541 GetLastError() == OSS_DATA_ERROR /* some Win9x */),
2542 "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH or OSS_DATA_ERROR, got %x\n",
2543 GetLastError());
2545 /* but succeeds with explicit type. */
2547 NULL);
2549 ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2551
2552 /* Opening a (non-empty) hash message with unspecified type and a bogus
2553 * hash value succeeds..
2554 */
2556 SetLastError(0xdeadbeef);
2558 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2560
2563 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2566 SetLastError(0xdeadbeef);
2570 GetLastError() == OSS_DATA_ERROR /* Win9x */),
2571 "Expected CRYPT_E_ASN1_BADTAG or OSS_DATA_ERROR, got %08x\n",
2572 GetLastError());
2575 NULL);
2578 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2580
2582 NULL, NULL);
2583 /* The first update succeeds.. */
2585 sizeof(detachedSignedContent), TRUE);
2586 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2587 /* as does a second (probably to update the detached portion).. */
2589 sizeof(detachedSignedContent), TRUE);
2590 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2591 /* while a third fails. */
2593 sizeof(detachedSignedContent), TRUE);
2595 "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2597
2600 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2601 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2602 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2604 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2605 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2606 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2607
2610 "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2612
2614 NULL);
2615 SetLastError(0xdeadbeef);
2618 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2620
2622 NULL);
2623 SetLastError(0xdeadbeef);
2625 sizeof(envelopedEmptyContent), TRUE);
2626 ok(!ret &&
2628 GetLastError() == OSS_DATA_ERROR), /* Win9x */
2629 "expected CRYPT_E_ASN1_BADTAG, got %08x\n", GetLastError());
2631
2633 SetLastError(0xdeadbeef);
2636 ok(!ret &&
2638 GetLastError() == OSS_DATA_ERROR), /* Win9x */
2639 "expected CRYPT_E_ASN1_BADTAG, got %08x\n", GetLastError());
2641
2643 SetLastError(0xdeadbeef);
2645 sizeof(envelopedEmptyContent), TRUE);
2646 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2648
2650 NULL);
2651 SetLastError(0xdeadbeef);
2654 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2656}
2657
2658static const BYTE hashParam[] = { 0x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,0xa1,
2659 0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f };
2660
2663{
2664 ok(got->dwVersion == expected->dwVersion, "Expected version %d, got %d\n",
2665 expected->dwVersion, got->dwVersion);
2666 ok(got->Issuer.cbData == expected->Issuer.cbData,
2667 "Expected issuer size %d, got %d\n", expected->Issuer.cbData,
2668 got->Issuer.cbData);
2669 ok(!memcmp(got->Issuer.pbData, expected->Issuer.pbData, got->Issuer.cbData),
2670 "Unexpected issuer\n");
2671 ok(got->SerialNumber.cbData == expected->SerialNumber.cbData,
2672 "Expected serial number size %d, got %d\n", expected->SerialNumber.cbData,
2673 got->SerialNumber.cbData);
2674 ok(!memcmp(got->SerialNumber.pbData, expected->SerialNumber.pbData,
2675 got->SerialNumber.cbData), "Unexpected serial number\n");
2676 /* FIXME: check more things */
2677}
2678
2681{
2682 ok(got->dwVersion == expected->dwVersion, "Expected version %d, got %d\n",
2683 expected->dwVersion, got->dwVersion);
2684 ok(got->SignerId.dwIdChoice == expected->SignerId.dwIdChoice,
2685 "Expected id choice %d, got %d\n", expected->SignerId.dwIdChoice,
2686 got->SignerId.dwIdChoice);
2687 if (got->SignerId.dwIdChoice == expected->SignerId.dwIdChoice)
2688 {
2690 {
2691 ok(U(got->SignerId).IssuerSerialNumber.Issuer.cbData ==
2692 U(expected->SignerId).IssuerSerialNumber.Issuer.cbData,
2693 "Expected issuer size %d, got %d\n",
2694 U(expected->SignerId).IssuerSerialNumber.Issuer.cbData,
2695 U(got->SignerId).IssuerSerialNumber.Issuer.cbData);
2696 ok(!memcmp(U(got->SignerId).IssuerSerialNumber.Issuer.pbData,
2697 U(expected->SignerId).IssuerSerialNumber.Issuer.pbData,
2698 U(got->SignerId).IssuerSerialNumber.Issuer.cbData),
2699 "Unexpected issuer\n");
2700 ok(U(got->SignerId).IssuerSerialNumber.SerialNumber.cbData ==
2701 U(expected->SignerId).IssuerSerialNumber.SerialNumber.cbData,
2702 "Expected serial number size %d, got %d\n",
2703 U(expected->SignerId).IssuerSerialNumber.SerialNumber.cbData,
2704 U(got->SignerId).IssuerSerialNumber.SerialNumber.cbData);
2705 ok(!memcmp(U(got->SignerId).IssuerSerialNumber.SerialNumber.pbData,
2706 U(expected->SignerId).IssuerSerialNumber.SerialNumber.pbData,
2707 U(got->SignerId).IssuerSerialNumber.SerialNumber.cbData),
2708 "Unexpected serial number\n");
2709 }
2710 else
2711 {
2712 ok(U(got->SignerId).KeyId.cbData == U(expected->SignerId).KeyId.cbData,
2713 "expected key id size %d, got %d\n",
2714 U(expected->SignerId).KeyId.cbData, U(got->SignerId).KeyId.cbData);
2715 ok(!memcmp(U(expected->SignerId).KeyId.pbData,
2716 U(got->SignerId).KeyId.pbData, U(got->SignerId).KeyId.cbData),
2717 "unexpected key id\n");
2718 }
2719 }
2720 /* FIXME: check more things */
2721}
2722
27240x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,
27250x2f };
2726static BYTE keyIdIssuer[] = {
27270x30,0x13,0x31,0x11,0x30,0x0f,0x06,0x0a,0x2b,0x06,0x01,0x04,0x01,0x82,0x37,
27280x0a,0x07,0x01,0x04,0x01,0x01 };
2729static const BYTE publicPrivateKeyPair[] = {
27300x07,0x02,0x00,0x00,0x00,0xa4,0x00,0x00,0x52,0x53,0x41,0x32,0x00,0x04,0x00,
27310x00,0x01,0x00,0x01,0x00,0x21,0x65,0x5d,0x97,0x19,0x3f,0xd0,0xd0,0x76,0x5b,
27320xb1,0x10,0x4e,0xcc,0x14,0xb5,0x92,0x0f,0x60,0xad,0xb6,0x74,0x8d,0x94,0x50,
27330xfd,0x14,0x5e,0xbc,0xf1,0x93,0xbf,0x24,0x21,0x64,0x9d,0xc7,0x77,0x04,0x54,
27340xd1,0xbd,0x3e,0xd8,0x3b,0x2a,0x8b,0x95,0x70,0xdf,0x19,0x20,0xed,0x76,0x39,
27350xfa,0x64,0x04,0xc6,0xf7,0x33,0x7b,0xaa,0x94,0x67,0x74,0xbc,0x6b,0xd5,0xa7,
27360x69,0x99,0x99,0x47,0x88,0xc0,0x7e,0x36,0xf1,0xc5,0x7d,0xa8,0xd8,0x07,0x48,
27370xe6,0x05,0x4f,0xf4,0x1f,0x37,0xd7,0xc7,0xa7,0x00,0x20,0xb3,0xe5,0x40,0x17,
27380x86,0x43,0x77,0xe0,0x32,0x39,0x11,0x9c,0xd9,0xd8,0x53,0x9b,0x45,0x42,0x54,
27390x65,0xca,0x15,0xbe,0xb2,0x44,0xf1,0xd0,0xf3,0xb6,0x4a,0x19,0xc8,0x3d,0x33,
27400x63,0x93,0x4f,0x7c,0x67,0xc6,0x58,0x6d,0xf6,0xb7,0x20,0xd8,0x30,0xcc,0x52,
27410xaa,0x68,0x66,0xf6,0x86,0xf8,0xe0,0x3a,0x73,0x0e,0x9d,0xc5,0x03,0x60,0x9e,
27420x08,0xe9,0x5e,0xd4,0x5e,0xcc,0xbb,0xc1,0x48,0xad,0x9d,0xbb,0xfb,0x26,0x61,
27430xa8,0x0e,0x9c,0xba,0xf1,0xd0,0x0b,0x5f,0x87,0xd4,0xb5,0xd2,0xdf,0x41,0xcb,
27440x7a,0xec,0xb5,0x87,0x59,0x6a,0x9d,0xb3,0x6c,0x06,0xee,0x1f,0xc5,0xae,0x02,
27450xa8,0x7f,0x33,0x6e,0x30,0x50,0x6d,0x65,0xd0,0x1f,0x00,0x47,0x43,0x25,0x90,
27460x4a,0xa8,0x74,0x8c,0x23,0x8b,0x15,0x8a,0x74,0xd2,0x03,0xa6,0x1c,0xc1,0x7e,
27470xbb,0xb1,0xa6,0x80,0x05,0x2b,0x62,0xfb,0x89,0xe5,0xba,0xc6,0xcc,0x12,0xce,
27480xa8,0xe9,0xc4,0xb5,0x9d,0xd8,0x11,0xdd,0x95,0x90,0x71,0xb0,0xfe,0xaa,0x14,
27490xce,0xd5,0xd0,0x5a,0x88,0x47,0xda,0x31,0xda,0x26,0x11,0x66,0xd1,0xd5,0xc5,
27500x1b,0x08,0xbe,0xc6,0xf3,0x15,0xbf,0x80,0x78,0xcf,0x55,0xe0,0x61,0xee,0xf5,
27510x71,0x1e,0x2f,0x0e,0xb3,0x67,0xf7,0xa1,0x86,0x04,0xcf,0x4b,0xc1,0x2f,0x94,
27520x73,0xd1,0x5d,0x0c,0xee,0x10,0x58,0xbb,0x74,0x0c,0x61,0x02,0x15,0x69,0x68,
27530xe0,0x21,0x3e,0xa6,0x27,0x22,0x8c,0xc8,0x61,0xbc,0xba,0xa9,0x4b,0x2e,0x71,
27540x77,0x74,0xdc,0x63,0x05,0x32,0x7a,0x93,0x4f,0xbf,0xc7,0xa5,0x3a,0xe3,0x25,
27550x4d,0x67,0xcf,0x78,0x1b,0x85,0x22,0x6c,0xfe,0x5c,0x34,0x0e,0x27,0x12,0xbc,
27560xd5,0x33,0x1a,0x75,0x8a,0x9c,0x40,0x39,0xe8,0xa0,0xc9,0xae,0xf8,0xaf,0x9a,
27570xc6,0x62,0x47,0xf3,0x5b,0xdf,0x5e,0xcd,0xc6,0xc0,0x5c,0xd7,0x0e,0x04,0x64,
27580x3d,0xdd,0x57,0xef,0xf6,0xcd,0xdf,0xd2,0x7e,0x17,0x6c,0x0a,0x47,0x5e,0x77,
27590x4b,0x02,0x49,0x78,0xc0,0xf7,0x09,0x6e,0xdf,0x96,0x04,0x51,0x74,0x3d,0x68,
27600x99,0x43,0x8e,0x03,0x16,0x46,0xa4,0x04,0x84,0x01,0x6e,0xd4,0xca,0x5c,0xab,
27610xb0,0xd3,0x82,0xf1,0xb9,0xba,0x51,0x99,0x03,0xe9,0x7f,0xdf,0x30,0x3b,0xf9,
27620x18,0xbb,0x80,0x7f,0xf0,0x89,0xbb,0x6d,0x98,0x95,0xb7,0xfd,0xd8,0xdf,0xed,
27630xf3,0x16,0x6f,0x96,0x4f,0xfd,0x54,0x66,0x6d,0x90,0xba,0xf5,0xcc,0xce,0x01,
27640x34,0x34,0x51,0x07,0x66,0x20,0xfb,0x4a,0x3c,0x7e,0x19,0xf8,0x8e,0x35,0x0e,
27650x07,0x48,0x74,0x38,0xd2,0x18,0xaa,0x2e,0x90,0x5e,0x0e,0xcc,0x50,0x6e,0x71,
27660x6f,0x54,0xdb,0xbf,0x7b,0xb4,0xf4,0x79,0x6a,0x21,0xa3,0x6d,0xdf,0x61,0xc0,
27670x8f,0xb3,0xb6,0xe1,0x8a,0x65,0x21,0x6e,0xf6,0x5b,0x80,0xf0,0xfb,0x28,0x87,
27680x13,0x06,0xd6,0xbc,0x28,0x5c,0xda,0xc5,0x13,0x13,0x44,0x8d,0xf4,0xa8,0x7b,
27690x5c,0x2a,0x7f,0x11,0x16,0x4e,0x52,0x41,0xe9,0xe7,0x8e };
2770static const BYTE envelopedMessage[] = {
27710x30,0x81,0xf2,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x03,0xa0,
27720x81,0xe4,0x30,0x81,0xe1,0x02,0x01,0x00,0x31,0x81,0xba,0x30,0x81,0xb7,0x02,
27730x01,0x00,0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,
27740x13,0x01,0x4e,0x02,0x10,0x63,0x75,0x75,0x7a,0x53,0x36,0xa9,0xba,0x41,0xa5,
27750xcc,0x01,0x7f,0x76,0x4c,0xd9,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,
27760x0d,0x01,0x01,0x01,0x05,0x00,0x04,0x81,0x80,0xc2,0x0d,0x59,0x87,0xb3,0x65,
27770xd2,0x64,0xcd,0xba,0xe3,0xaf,0x1e,0xa1,0xd3,0xdd,0xb3,0x53,0xfc,0x2f,0xae,
27780xdc,0x6d,0x2a,0x81,0x84,0x38,0x6f,0xdf,0x81,0xb1,0x65,0xba,0xac,0x59,0xb1,
27790x19,0x12,0x3f,0xde,0x12,0xce,0x77,0x42,0x71,0x67,0xa9,0x78,0x38,0x95,0x51,
27800xbb,0x66,0x78,0xbf,0xaf,0x0a,0x98,0x4b,0xba,0xa5,0xf0,0x8b,0x9f,0xef,0xcf,
27810x40,0x05,0xa1,0xd6,0x10,0xae,0xbf,0xb9,0xbd,0x4d,0x22,0x39,0x33,0x63,0x2b,
27820x0b,0xd3,0x0c,0xb5,0x4b,0xe8,0xfe,0x15,0xa8,0xa5,0x2c,0x86,0x33,0x80,0x6e,
27830x4c,0x7a,0x99,0x3c,0x6b,0x4b,0x60,0xfd,0x8e,0xb2,0xf3,0x82,0x2f,0x3e,0x1e,
27840xba,0xb9,0x78,0x24,0x32,0xab,0xa4,0x10,0x1a,0x38,0x94,0x10,0x8d,0xf8,0x70,
27850x3e,0x4e,0x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,
27860x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x04,0x05,0x00,0x80,
27870x04,0x5f,0x80,0xf2,0x17 };
2788static const BYTE envelopedBareMessage[] = {
27890x30,0x81,0xe1,0x02,0x01,0x00,0x31,0x81,0xba,0x30,0x81,0xb7,0x02,0x01,0x00,
27900x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,
27910x4e,0x02,0x10,0x63,0x75,0x75,0x7a,0x53,0x36,0xa9,0xba,0x41,0xa5,0xcc,0x01,
27920x7f,0x76,0x4c,0xd9,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
27930x01,0x01,0x05,0x00,0x04,0x81,0x80,0x69,0x79,0x12,0x6b,0xa1,0x2f,0xe9,0x0d,
27940x34,0x79,0x77,0xe9,0x15,0xf2,0xff,0x0c,0x9a,0xf2,0x87,0xbd,0x12,0xc4,0x2d,
27950x9e,0x81,0xc7,0x3c,0x74,0x05,0xdc,0x13,0xaf,0xe9,0xa2,0xba,0x72,0xe9,0xa5,
27960x2b,0x81,0x39,0xd3,0x62,0xaa,0x78,0xc3,0x90,0x4f,0x06,0xf0,0xdb,0x18,0x5e,
27970xe1,0x2e,0x19,0xa3,0xc2,0xac,0x1e,0xf1,0xbf,0xe6,0x03,0x00,0x96,0xfa,0xd2,
27980x66,0x73,0xd0,0x45,0x55,0x57,0x71,0xff,0x3a,0x0c,0xad,0xce,0xde,0x68,0xd4,
27990x45,0x20,0xc8,0x44,0x4d,0x5d,0xa2,0x98,0x79,0xb1,0x81,0x0f,0x8a,0xfc,0x70,
28000xa5,0x18,0xd2,0x30,0x65,0x22,0x84,0x02,0x24,0x48,0xf7,0xa4,0xe0,0xa5,0x6c,
28010xa8,0xa4,0xd0,0x86,0x4b,0x6e,0x9b,0x18,0xab,0x78,0xfa,0x76,0x12,0xce,0x55,
28020x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0x30,0x0c,
28030x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x04,0x05,0x00,0x80,0x04,0x2c,
28040x2d,0xa3,0x6e };
28060x30,0x82,0x02,0x69,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x03,
28070xa0,0x82,0x02,0x5a,0x30,0x82,0x02,0x56,0x02,0x01,0x00,0x31,0x82,0x02,0x2e,
28080x30,0x81,0xb7,0x02,0x01,0x00,0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,
28090x03,0x55,0x04,0x03,0x13,0x01,0x4e,0x02,0x10,0x63,0x75,0x75,0x7a,0x53,0x36,
28100xa9,0xba,0x41,0xa5,0xcc,0x01,0x7f,0x76,0x4c,0xd9,0x30,0x0d,0x06,0x09,0x2a,
28110x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x04,0x81,0x80,0xa4,0x2e,
28120xe5,0x56,0x60,0xc5,0x64,0x07,0x29,0xaf,0x5c,0x38,0x3d,0x4b,0xec,0xbd,0xba,
28130x97,0x60,0x17,0xed,0xd7,0x21,0x7b,0x19,0x94,0x95,0xf1,0xb2,0x84,0x06,0x1f,
28140xc5,0x83,0xb3,0x5d,0xc8,0x2c,0x1c,0x0f,0xf7,0xfd,0x58,0x8b,0x0f,0x25,0xb5,
28150x9f,0x7f,0x43,0x8f,0x5f,0x81,0x16,0x4a,0x62,0xfb,0x47,0xb5,0x36,0x72,0x21,
28160x29,0xd4,0x9e,0x27,0x35,0xf4,0xd0,0xd4,0xc0,0xa3,0x7a,0x47,0xbe,0xc9,0xae,
28170x08,0x17,0x6a,0xb5,0x63,0x38,0xa1,0xdc,0xf5,0xc1,0x8d,0x97,0x56,0xb4,0xc0,
28180x2d,0x2b,0xec,0x3d,0xbd,0xce,0xd1,0x52,0x3e,0x29,0x34,0xe2,0x9a,0x00,0x96,
28190x4c,0x85,0xaf,0x0f,0xfb,0x10,0x1d,0xf8,0x08,0x27,0x10,0x04,0x04,0xbf,0xae,
28200x36,0xd0,0x6a,0x49,0xe7,0x43,0x30,0x81,0xb7,0x02,0x01,0x00,0x30,0x20,0x30,
28210x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x4e,0x02,0x10,
28220xc2,0x8f,0xc4,0x5e,0x8d,0x3b,0x01,0x8c,0x4b,0x23,0xcb,0x93,0x77,0xab,0xb6,
28230xe1,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,
28240x00,0x04,0x81,0x80,0x4b,0x22,0x8a,0xfa,0xa6,0xb6,0x01,0xe9,0xb5,0x54,0xcf,
28250xa7,0x81,0x54,0xf9,0x08,0x42,0x8a,0x75,0x19,0x9c,0xc9,0x27,0x68,0x08,0xf9,
28260x53,0xa7,0x60,0xf8,0xdd,0xba,0xfb,0x4f,0x63,0x8a,0x15,0x6a,0x5b,0xf6,0xe3,
28270x4e,0x29,0xa9,0xc8,0x1d,0x63,0x92,0x8f,0x95,0x91,0x95,0x71,0xb5,0x5d,0x02,
28280xe5,0xa0,0x07,0x67,0x36,0xe5,0x2d,0x7b,0xcd,0xe1,0xf2,0xa4,0xc6,0x24,0x70,
28290xac,0xd7,0xaf,0x63,0xb2,0x04,0x02,0x8d,0xae,0x2f,0xdc,0x7e,0x6c,0x84,0xd3,
28300xe3,0x66,0x54,0x3b,0x05,0xd8,0x77,0x40,0xe4,0x6b,0xbd,0xa9,0x8d,0x4d,0x74,
28310x15,0xfd,0x74,0xf7,0xd3,0xc0,0xc9,0xf1,0x20,0x0e,0x08,0x13,0xcc,0xb0,0x94,
28320x53,0x01,0xd4,0x5f,0x95,0x32,0xeb,0xe8,0x73,0x9f,0x6a,0xd1,0x30,0x81,0xb7,
28330x02,0x01,0x00,0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,
28340x03,0x13,0x01,0x58,0x02,0x10,0x1c,0xf2,0x1f,0xec,0x6b,0xdc,0x36,0xbf,0x4a,
28350xd7,0xe1,0x6c,0x84,0x85,0xcd,0x2e,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,
28360xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x04,0x81,0x80,0x47,0x21,0xf9,0xe7,0x98,
28370x7f,0xe7,0x49,0x3f,0x16,0xb8,0x4c,0x8b,0x7d,0x5d,0x56,0xa7,0x31,0xfd,0xa5,
28380xcd,0x43,0x70,0x58,0xf1,0x33,0xfb,0xe6,0xc8,0xbb,0x6f,0x0a,0x89,0xa4,0xb9,
28390x3e,0x3a,0xc5,0x85,0x46,0x54,0x73,0x37,0xa3,0xbd,0x36,0xc3,0xce,0x40,0xf3,
28400xd7,0x92,0x54,0x8e,0x60,0x1f,0xa2,0xa7,0x03,0xc2,0x49,0xa9,0x02,0x28,0xc8,
28410xa5,0xa7,0x42,0xcd,0x29,0x85,0x34,0xa7,0xa9,0xe8,0x8c,0x3d,0xb3,0xd0,0xac,
28420x7d,0x31,0x5d,0xb4,0xcb,0x7e,0xad,0x62,0xfd,0x04,0x7b,0xa1,0x93,0xb5,0xbc,
28430x08,0x4f,0x36,0xd7,0x5a,0x95,0xbc,0xff,0x47,0x0f,0x84,0x21,0x24,0xdf,0xc5,
28440xfe,0xc8,0xe5,0x0b,0xc4,0xc4,0x5c,0x1a,0x50,0x31,0x91,0xce,0xf6,0x11,0xf1,
28450x0e,0x28,0xce,0x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,
28460x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x04,0x05,0x00,
28470x80,0x04,0x4e,0x99,0x9d,0x4c };
2848static const BYTE serialNumber[] = {
28490x2e,0xcd,0x85,0x84,0x6c,0xe1,0xd7,0x4a,0xbf,0x36,0xdc,0x6b,0xec,0x1f,0xf2,
28500x1c };
2851static const BYTE issuer[] = {
28520x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x58 };
2853
2855{
2856 HCRYPTMSG msg;
2857 HCRYPTPROV hCryptProv;
2858 HCRYPTKEY key = 0;
2859 BOOL ret;
2860 DWORD size = 0, value, req_size;
2861 LPBYTE buf;
2862 CMSG_CTRL_DECRYPT_PARA decryptPara = { sizeof(decryptPara), 0 };
2863
2865 SetLastError(0xdeadbeef);
2868 "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
2870 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2871 check_param("data content", msg, CMSG_CONTENT_PARAM, msgData,
2872 sizeof(msgData));
2874
2877 if (ret)
2878 {
2879 /* Crashes on some Win9x */
2880 check_param("empty hash content", msg, CMSG_CONTENT_PARAM, NULL, 0);
2881 check_param("empty hash hash data", msg, CMSG_HASH_DATA_PARAM, NULL, 0);
2882 check_param("empty hash computed hash", msg, CMSG_COMPUTED_HASH_PARAM,
2884 }
2888 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2889 check_param("hash content", msg, CMSG_CONTENT_PARAM, msgData,
2890 sizeof(msgData));
2891 check_param("hash hash data", msg, CMSG_HASH_DATA_PARAM, hashParam,
2892 sizeof(hashParam));
2893 check_param("hash computed hash", msg, CMSG_COMPUTED_HASH_PARAM,
2894 hashParam, sizeof(hashParam));
2895 /* Curiously, on NT-like systems, getting the hash of index 1 succeeds,
2896 * even though there's only one hash.
2897 */
2899 ok(ret || GetLastError() == OSS_DATA_ERROR /* Win9x */,
2900 "CryptMsgGetParam failed: %08x\n", GetLastError());
2901 if (ret)
2903 else
2904 buf = NULL;
2905 if (buf)
2906 {
2908 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2909 ok(size == sizeof(hashParam), "Unexpected size %d\n", size);
2910 ok(!memcmp(buf, hashParam, size), "Unexpected value\n");
2912 }
2914 (const BYTE *)szOID_RSA_data, strlen(szOID_RSA_data) + 1);
2916 check_param("hash version", msg, CMSG_VERSION_PARAM, (const BYTE *)&value,
2917 sizeof(value));
2919
2922 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2923 check_param("signed content", msg, CMSG_CONTENT_PARAM, msgData,
2924 sizeof(msgData));
2926 (const BYTE *)szOID_RSA_data, strlen(szOID_RSA_data) + 1);
2927 size = sizeof(value);
2928 value = 2112;
2930 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2931 ok(value == 1, "Expected 1 signer, got %d\n", value);
2932 size = 0;
2934 ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
2935 "CryptMsgGetParam failed: %08x\n", GetLastError());
2936 if (ret)
2938 else
2939 buf = NULL;
2940 if (buf)
2941 {
2942 CMSG_SIGNER_INFO signer = { 0 };
2943
2944 signer.dwVersion = 1;
2945 signer.Issuer.cbData = sizeof(encodedCommonName);
2947 signer.SerialNumber.cbData = sizeof(serialNum);
2948 signer.SerialNumber.pbData = serialNum;
2950 req_size = size;
2951 size += 10;
2953 ok(size == req_size, "size = %u, expected %u\n", size, req_size);
2956 }
2957 /* Getting the CMS signer info of a PKCS7 message is possible. */
2958 size = 0;
2960 ok(ret || broken(GetLastError() == CRYPT_E_INVALID_MSG_TYPE /* Win9x */),
2961 "CryptMsgGetParam failed: %08x\n", GetLastError());
2962 if (ret)
2964 else
2965 buf = NULL;
2966 if (buf)
2967 {
2968 CMSG_CMS_SIGNER_INFO signer = { 0 };
2969
2970 signer.dwVersion = 1;
2972 U(signer.SignerId).IssuerSerialNumber.Issuer.cbData =
2973 sizeof(encodedCommonName);
2974 U(signer.SignerId).IssuerSerialNumber.Issuer.pbData = encodedCommonName;
2975 U(signer.SignerId).IssuerSerialNumber.SerialNumber.cbData =
2976 sizeof(serialNum);
2977 U(signer.SignerId).IssuerSerialNumber.SerialNumber.pbData = serialNum;
2982 }
2983 /* index is ignored when getting signer count */
2984 size = sizeof(value);
2986 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2987 ok(value == 1, "Expected 1 signer, got %d\n", value);
2989 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2990 ok(value == 0, "Expected 0 certs, got %d\n", value);
2992 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2993 ok(value == 0, "Expected 0 CRLs, got %d\n", value);
2996 NULL);
2999 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3001 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3002 ok(value == 1, "Expected 1 cert, got %d\n", value);
3003 check_param("cert", msg, CMSG_CERT_PARAM, cert, sizeof(cert));
3005 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3006 ok(value == 1, "Expected 1 CRL, got %d\n", value);
3007 check_param("crl", msg, CMSG_CRL_PARAM, crl, sizeof(crl));
3008 check_param("signed with cert and CRL computed hash", msg,
3012
3015 sizeof(signedKeyIdEmptyContent), TRUE);
3016 if (!ret && GetLastError() == OSS_DATA_ERROR)
3017 {
3019 win_skip("Subsequent tests crash on some Win9x\n");
3020 return;
3021 }
3022 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3023 size = sizeof(value);
3025 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3026 ok(value == 1, "Expected 1 signer, got %d\n", value);
3027 /* Getting the regular (non-CMS) signer info from a CMS message is also
3028 * possible..
3029 */
3030 size = 0;
3032 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3033 if (ret)
3035 else
3036 buf = NULL;
3037 if (buf)
3038 {
3039 CMSG_SIGNER_INFO signer;
3040 BYTE zero = 0;
3041
3042 /* and here's the little oddity: for a CMS message using the key id
3043 * variant of a SignerId, retrieving the CMSG_SIGNER_INFO param yields
3044 * a signer with a zero (not empty) serial number, and whose issuer is
3045 * an RDN with OID szOID_KEYID_RDN, value type CERT_RDN_OCTET_STRING,
3046 * and value of the key id.
3047 */
3049 signer.Issuer.cbData = sizeof(keyIdIssuer);
3050 signer.Issuer.pbData = keyIdIssuer;
3051 signer.SerialNumber.cbData = 1;
3052 signer.SerialNumber.pbData = &zero;
3056 }
3057 size = 0;
3059 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3060 if (ret)
3062 else
3063 buf = NULL;
3064 if (buf)
3065 {
3066 CMSG_CMS_SIGNER_INFO signer = { 0 };
3067
3070 U(signer.SignerId).KeyId.cbData = sizeof(serialNum);
3071 U(signer.SignerId).KeyId.pbData = serialNum;
3076 }
3078
3080 NULL);
3083 check_param("enveloped empty bare content", msg, CMSG_CONTENT_PARAM, NULL,
3084 0);
3086
3089 TRUE);
3090 check_param("enveloped empty content", msg, CMSG_CONTENT_PARAM, NULL, 0);
3092
3093 pCryptAcquireContextA(&hCryptProv, NULL, MS_ENHANCED_PROV_A, PROV_RSA_FULL,
3095 SetLastError(0xdeadbeef);
3097 sizeof(publicPrivateKeyPair), 0, 0, &key);
3098 ok(ret ||
3099 broken(!ret && GetLastError() == NTE_PERM), /* WinME and some NT4 */
3100 "CryptImportKey failed: %08x\n", GetLastError());
3101
3104 check_param("enveloped message before decrypting", msg, CMSG_CONTENT_PARAM,
3105 envelopedMessage + sizeof(envelopedMessage) - 4, 4);
3106 if (key)
3107 {
3108 decryptPara.hCryptProv = hCryptProv;
3109 SetLastError(0xdeadbeef);
3110 ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3111 ok(ret, "CryptMsgControl failed: %08x\n", GetLastError());
3112 decryptPara.hCryptProv = 0;
3113 SetLastError(0xdeadbeef);
3114 ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3116 "expected CRYPT_E_ALREADY_DECRYPTED, got %08x\n", GetLastError());
3117 check_param("enveloped message", msg, CMSG_CONTENT_PARAM, msgData,
3118 sizeof(msgData));
3119 }
3120 else
3121 win_skip("failed to import a key, skipping tests\n");
3123
3125 NULL);
3127 TRUE);
3128 check_param("enveloped bare message before decrypting", msg,
3130 sizeof(envelopedBareMessage) - 4, 4);
3131 if (key)
3132 {
3133 decryptPara.hCryptProv = hCryptProv;
3134 SetLastError(0xdeadbeef);
3135 ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3136 ok(ret, "CryptMsgControl failed: %08x\n", GetLastError());
3137 check_param("enveloped bare message", msg, CMSG_CONTENT_PARAM, msgData,
3138 sizeof(msgData));
3139 }
3140 else
3141 win_skip("failed to import a key, skipping tests\n");
3143
3144 if (key)
3146 CryptReleaseContext(hCryptProv, 0);
3147
3151 value = 3;
3152 check_param("recipient count", msg, CMSG_RECIPIENT_COUNT_PARAM,
3153 (const BYTE *)&value, sizeof(value));
3154 size = 0;
3155 SetLastError(0xdeadbeef);
3158 "expected CRYPT_E_INVALID_INDEX, got %08x\n", GetLastError());
3159 size = 0;
3160 SetLastError(0xdeadbeef);
3162 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3163 ok(size >= 142, "unexpected size: %u\n", size);
3164 if (ret)
3166 else
3167 buf = NULL;
3168 if (buf)
3169 {
3170 CERT_INFO *certInfo = (CERT_INFO *)buf;
3171
3172 SetLastError(0xdeadbeef);
3174 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3175 ok(certInfo->SerialNumber.cbData == sizeof(serialNumber),
3176 "unexpected serial number size: %u\n", certInfo->SerialNumber.cbData);
3178 sizeof(serialNumber)), "unexpected serial number\n");
3179 ok(certInfo->Issuer.cbData == sizeof(issuer),
3180 "unexpected issuer size: %u\n", certInfo->Issuer.cbData);
3181 ok(!memcmp(certInfo->Issuer.pbData, issuer, sizeof(issuer)),
3182 "unexpected issuer\n");
3184 }
3186}
3187
3188static void test_decode_msg(void)
3189{
3192}
3193
3194static BYTE aKey[] = { 0,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf };
3195/* aKey encoded as a X509_PUBLIC_KEY_INFO */
31970x30,0x1f,0x30,0x0a,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x05,0x00,0x03,
31980x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,
31990x0d,0x0e,0x0f };
3200/* a weird modulus encoded as RSA_CSP_PUBLICKEYBLOB */
3201static BYTE mod_encoded[] = {
3202 0x30,0x10,0x02,0x09,0x00,0x80,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x02,0x03,
3203 0x01,0x00,0x01 };
3204
3205static void test_msg_control(void)
3206{
3207 static char oid_rsa_rsa[] = szOID_RSA_RSA;
3208 BOOL ret;
3209 HCRYPTMSG msg;
3210 DWORD i;
3211 CERT_INFO certInfo = { 0 };
3212 CMSG_HASHED_ENCODE_INFO hashInfo = { 0 };
3213 CMSG_SIGNED_ENCODE_INFO signInfo = { sizeof(signInfo), 0 };
3214 CMSG_CTRL_DECRYPT_PARA decryptPara = { sizeof(decryptPara), 0 };
3215
3216 /* Crashes
3217 ret = CryptMsgControl(NULL, 0, 0, NULL);
3218 */
3219
3220 /* Data encode messages don't allow any sort of control.. */
3222 NULL);
3223 /* either with no prior update.. */
3224 for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3225 {
3226 SetLastError(0xdeadbeef);
3227 ret = CryptMsgControl(msg, 0, i, NULL);
3229 "Expected E_INVALIDARG, got %08x\n", GetLastError());
3230 }
3231 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
3232 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3233 /* or after an update. */
3234 for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3235 {
3236 SetLastError(0xdeadbeef);
3237 ret = CryptMsgControl(msg, 0, i, NULL);
3239 "Expected E_INVALIDARG, got %08x\n", GetLastError());
3240 }
3242
3243 /* Hash encode messages don't allow any sort of control.. */
3244 hashInfo.cbSize = sizeof(hashInfo);
3247 NULL, NULL);
3248 /* either with no prior update.. */
3249 for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3250 {
3251 SetLastError(0xdeadbeef);
3252 ret = CryptMsgControl(msg, 0, i, NULL);
3254 "Expected E_INVALIDARG, got %08x\n", GetLastError());
3255 }
3256 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
3257 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3258 /* or after an update. */
3259 for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3260 {
3261 SetLastError(0xdeadbeef);
3262 ret = CryptMsgControl(msg, 0, i, NULL);
3264 "Expected E_INVALIDARG, got %08x\n", GetLastError());
3265 }
3267
3268 /* Signed encode messages likewise don't allow any sort of control.. */
3269 signInfo.cbSize = sizeof(signInfo);
3271 NULL, NULL);
3272 /* either before an update.. */
3273 for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3274 {
3275 SetLastError(0xdeadbeef);
3276 ret = CryptMsgControl(msg, 0, i, NULL);
3278 "Expected E_INVALIDARG, got %08x\n", GetLastError());
3279 }
3280 ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
3281 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3282 /* or after an update. */
3283 for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3284 {
3285 SetLastError(0xdeadbeef);
3286 ret = CryptMsgControl(msg, 0, i, NULL);
3288 "Expected E_INVALIDARG, got %08x\n", GetLastError());
3289 }
3291
3292 /* Decode messages behave a bit differently. */
3294 /* Bad control type */
3295 SetLastError(0xdeadbeef);
3296 ret = CryptMsgControl(msg, 0, 0, NULL);
3298 "Expected CRYPT_E_CONTROL_TYPE, got %08x\n", GetLastError());
3299 SetLastError(0xdeadbeef);
3300 ret = CryptMsgControl(msg, 1, 0, NULL);
3302 "Expected CRYPT_E_CONTROL_TYPE, got %08x\n", GetLastError());
3303 /* Can't verify the hash of an indeterminate-type message */
3304 SetLastError(0xdeadbeef);
3307 "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3308 /* Crashes
3309 ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, NULL);
3310 */
3311 /* Can't decrypt an indeterminate-type message */
3312 ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3314 "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3316
3317 if (!old_crypt32)
3318 {
3320 NULL);
3321 /* Can't verify the hash of an empty message */
3322 SetLastError(0xdeadbeef);
3323 /* Crashes on some Win9x */
3325 todo_wine
3327 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
3328 /* Crashes
3329 ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, NULL);
3330 */
3331 /* Can't verify the signature of a hash message */
3334 "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3336 TRUE);
3337 /* Oddly enough, this fails, crashes on some Win9x */
3339 ok(!ret, "Expected failure\n");
3341 }
3343 NULL);
3346 ok(ret, "CryptMsgControl failed: %08x\n", GetLastError());
3347 /* Can't decrypt an indeterminate-type message */
3348 SetLastError(0xdeadbeef);
3349 ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3351 "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3353
3355 NULL, NULL);
3356 /* Can't verify the hash of a detached message before it's been updated. */
3357 SetLastError(0xdeadbeef);
3360 "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3362 TRUE);
3363 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3364 /* Still can't verify the hash of a detached message with the content
3365 * of the detached hash given..
3366 */
3367 SetLastError(0xdeadbeef);
3370 "Expected CRYPT_E_HASH_VALUE, got %08x\n", GetLastError());
3371 /* and giving the content of the message after attempting to verify the
3372 * hash fails.
3373 */
3374 SetLastError(0xdeadbeef);
3375 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
3376 todo_wine
3377 ok(!ret &&
3379 GetLastError() == NTE_BAD_ALGID || /* Win9x */
3380 GetLastError() == CRYPT_E_MSG_ERROR), /* Vista */
3381 "Expected NTE_BAD_HASH_STATE or NTE_BAD_ALGID or CRYPT_E_MSG_ERROR, "
3382 "got %08x\n", GetLastError());
3384
3385 /* Finally, verifying the hash of a detached message in the correct order:
3386 * 1. Update with the detached hash message
3387 * 2. Update with the content of the message
3388 * 3. Verifying the hash of the message
3389 * succeeds.
3390 */
3392 NULL, NULL);
3394 TRUE);
3395 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3396 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
3397 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3398 SetLastError(0xdeadbeef);
3400 ok(ret, "CryptMsgControl failed: %08x\n", GetLastError());
3402
3404 NULL);
3405 /* Can't verify the hash of a signed message */
3406 SetLastError(0xdeadbeef);
3409 "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3410 /* Can't decrypt a signed message */
3411 SetLastError(0xdeadbeef);
3412 ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3414 "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3415 /* Crash
3416 ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, NULL);
3417 ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3418 */
3421 /* With an empty cert info, the signer can't be found in the message (and
3422 * the signature can't be verified.
3423 */
3424 SetLastError(0xdeadbeef);
3427 GetLastError() == OSS_DATA_ERROR /* Win9x */),
3428 "Expected CRYPT_E_SIGNER_NOT_FOUND or OSS_DATA_ERROR, got %08x\n",
3429 GetLastError());
3430 /* The cert info is expected to have an issuer, serial number, and public
3431 * key info set.
3432 */
3433 certInfo.SerialNumber.cbData = sizeof(serialNum);
3434 certInfo.SerialNumber.pbData = serialNum;
3435 certInfo.Issuer.cbData = sizeof(encodedCommonName);
3436 certInfo.Issuer.pbData = encodedCommonName;
3437 SetLastError(0xdeadbeef);
3439 ok(!ret && (GetLastError() == CRYPT_E_ASN1_EOD ||
3440 GetLastError() == OSS_DATA_ERROR /* Win9x */),
3441 "Expected CRYPT_E_ASN1_EOD or OSS_DATA_ERROR, got %08x\n", GetLastError());
3443 /* This cert has a public key, but it's not in a usable form */
3445 NULL);
3448 if (ret)
3449 {
3450 /* Crashes on some Win9x */
3451 /* Again, cert info needs to have a public key set */
3452 SetLastError(0xdeadbeef);
3454 ok(!ret &&
3456 GetLastError() == TRUST_E_NOSIGNATURE /* Vista */),
3457 "Expected CRYPT_E_ASN1_EOD or TRUST_E_NOSIGNATURE, got %08x\n", GetLastError());
3458 /* The public key is supposed to be in encoded form.. */
3459 certInfo.SubjectPublicKeyInfo.Algorithm.pszObjId = oid_rsa_rsa;
3460 certInfo.SubjectPublicKeyInfo.PublicKey.cbData = sizeof(aKey);
3462 SetLastError(0xdeadbeef);
3464 ok(!ret &&
3466 GetLastError() == TRUST_E_NOSIGNATURE /* Vista */),
3467 "Expected CRYPT_E_ASN1_BADTAG or TRUST_E_NOSIGNATURE, got %08x\n", GetLastError());
3468 /* but not as a X509_PUBLIC_KEY_INFO.. */
3472 SetLastError(0xdeadbeef);
3474 ok(!ret &&
3476 GetLastError() == TRUST_E_NOSIGNATURE /* Vista */),
3477 "Expected CRYPT_E_ASN1_BADTAG or TRUST_E_NOSIGNATURE, got %08x\n", GetLastError());
3478 /* This decodes successfully, but it doesn't match any key in the message */
3481 SetLastError(0xdeadbeef);
3483 /* In Wine's rsaenh, this fails to decode because the key length is too
3484 * small. Not sure if that's a bug in rsaenh, so leaving todo_wine for
3485 * now.
3486 */
3487 todo_wine
3488 ok(!ret &&
3490 GetLastError() == TRUST_E_NOSIGNATURE /* Vista */),
3491 "Expected NTE_BAD_SIGNATURE or TRUST_E_NOSIGNATURE, got %08x\n", GetLastError());
3492 }
3494 /* A message with no data doesn't have a valid signature */
3498 if (ret)
3499 {
3500 certInfo.SubjectPublicKeyInfo.Algorithm.pszObjId = oid_rsa_rsa;
3501 certInfo.SubjectPublicKeyInfo.PublicKey.cbData = sizeof(pubKey);
3503 SetLastError(0xdeadbeef);
3504 /* Crashes on some Win9x */
3506 ok(!ret &&
3508 GetLastError() == TRUST_E_NOSIGNATURE /* Vista */),
3509 "Expected NTE_BAD_SIGNATURE or TRUST_E_NOSIGNATURE, got %08x\n", GetLastError());
3510 }
3512 /* Finally, this succeeds */
3517 ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3518 "CryptMsgControl failed: %08x\n", GetLastError());
3520
3521 /* Test verifying signature of a detached signed message */
3523 NULL, NULL);
3525 sizeof(detachedSignedContent), TRUE);
3526 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3527 /* Can't verify the sig without having updated the data */
3528 SetLastError(0xdeadbeef);
3531 GetLastError() == OSS_DATA_ERROR /* Win9x */),
3532 "expected NTE_BAD_SIGNATURE or OSS_DATA_ERROR, got %08x\n",
3533 GetLastError());
3534 /* Now that the signature's been checked, can't do the final update */
3535 SetLastError(0xdeadbeef);
3536 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
3537 todo_wine
3538 ok((!ret &&
3540 GetLastError() == NTE_BAD_ALGID || /* Win9x */
3541 GetLastError() == CRYPT_E_MSG_ERROR)) || /* Vista */
3542 broken(ret), /* Win9x */
3543 "expected NTE_BAD_HASH_STATE or NTE_BAD_ALGID or CRYPT_E_MSG_ERROR, "
3544 "got %08x\n", GetLastError());
3546 /* Updating with the detached portion of the message and the data of the
3547 * the message allows the sig to be verified.
3548 */
3550 NULL, NULL);
3552 sizeof(detachedSignedContent), TRUE);
3553 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3554 ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
3555 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3557 ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3558 "CryptMsgControl failed: %08x\n", GetLastError());
3560
3562 NULL);
3563 decryptPara.cbSize = 0;
3564 SetLastError(0xdeadbeef);
3565 ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3567 "expected E_INVALIDARG, got %08x\n", GetLastError());
3568 decryptPara.cbSize = sizeof(decryptPara);
3569 if (!old_crypt32)
3570 {
3571 SetLastError(0xdeadbeef);
3572 ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3574 "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3575 }
3576 SetLastError(0xdeadbeef);
3579 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3580 SetLastError(0xdeadbeef);
3581 ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3583 "expected CRYPT_E_INVALID_INDEX, got %08x\n", GetLastError());
3585
3587 NULL);
3588 SetLastError(0xdeadbeef);
3590 sizeof(envelopedBareMessage), TRUE);
3591 ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3592 SetLastError(0xdeadbeef);
3593 ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3595 "expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
3597}
3598
3599/* win9x has much less parameter checks and will crash on many tests
3600 * this code is from test_signed_msg_update()
3601 */
3602static BOOL detect_nt(void)
3603{
3604 BOOL ret;
3605 CMSG_SIGNER_ENCODE_INFO signer = { sizeof(signer), 0 };
3606 CERT_INFO certInfo = { 0 };
3607
3608 if (!pCryptAcquireContextW)
3609 return FALSE;
3610
3611 certInfo.SerialNumber.cbData = sizeof(serialNum);
3612 certInfo.SerialNumber.pbData = serialNum;
3613 certInfo.Issuer.cbData = sizeof(encodedCommonName);
3614 certInfo.Issuer.pbData = encodedCommonName;
3615 signer.pCertInfo = &certInfo;
3617
3618 ret = pCryptAcquireContextW(&signer.hCryptProv, cspNameW, NULL,
3620 if (!ret && GetLastError() == NTE_EXISTS) {
3621 ret = pCryptAcquireContextW(&signer.hCryptProv, cspNameW, NULL,
3622 PROV_RSA_FULL, 0);
3623 }
3624
3625 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) return FALSE;
3626
3627 /* cleanup */
3629 pCryptAcquireContextW(&signer.hCryptProv, cspNameW, NULL, PROV_RSA_FULL,
3631
3632 return TRUE;
3633}
3634
3636{
3637 BOOL ret;
3638 HCRYPTMSG msg;
3639 PCCERT_CONTEXT signer;
3640 DWORD signerIndex;
3641 HCERTSTORE store;
3642
3643 /* Crash */
3644 if (0)
3645 {
3647 CryptMsgGetAndVerifySigner(NULL, 0, NULL, 0, NULL, &signerIndex);
3648 }
3649
3651 /* An empty message has no signer */
3652 SetLastError(0xdeadbeef);
3655 "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3656 /* The signer is cleared on error */
3657 signer = (PCCERT_CONTEXT)0xdeadbeef;
3658 SetLastError(0xdeadbeef);
3659 ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, &signer, NULL);
3661 "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3662 ok(!signer, "expected signer to be NULL\n");
3663 /* The signer index is also cleared on error */
3664 signerIndex = 0xdeadbeef;
3665 SetLastError(0xdeadbeef);
3666 ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, NULL, &signerIndex);
3668 "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3669 ok(!signerIndex, "expected 0, got %d\n", signerIndex);
3670 /* An unsigned message (msgData isn't a signed message at all)
3671 * likewise has no signer.
3672 */
3674 SetLastError(0xdeadbeef);
3677 "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3679
3681 /* A "signed" message created with no signer cert likewise has no signer */
3683 if (ret)
3684 {
3685 /* Crashes on most Win9x */
3688 "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3689 }
3691
3693 /* A signed message succeeds, .. */
3697 ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3698 "CryptMsgGetAndVerifySigner failed: 0x%08x\n", GetLastError());
3699 /* the signer index can be retrieved, .. */
3700 signerIndex = 0xdeadbeef;
3701 ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, NULL, &signerIndex);
3702 ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3703 "CryptMsgGetAndVerifySigner failed: 0x%08x\n", GetLastError());
3704 if (ret)
3705 ok(signerIndex == 0, "expected 0, got %d\n", signerIndex);
3706 /* as can the signer cert. */
3707 signer = (PCCERT_CONTEXT)0xdeadbeef;
3708 ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, &signer, NULL);
3709 ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3710 "CryptMsgGetAndVerifySigner failed: 0x%08x\n", GetLastError());
3711 if (ret)
3712 ok(signer != NULL && signer != (PCCERT_CONTEXT)0xdeadbeef,
3713 "expected a valid signer\n");
3714 if (signer && signer != (PCCERT_CONTEXT)0xdeadbeef)
3716 /* Specifying CMSG_USE_SIGNER_INDEX_FLAG and an invalid signer index fails
3717 */
3718 signerIndex = 0xdeadbeef;
3719 SetLastError(0xdeadbeef);
3721 NULL, &signerIndex);
3723 "expected CRYPT_E_INVALID_INDEX, got 0x%08x\n", GetLastError());
3724 /* Specifying CMSG_TRUSTED_SIGNER_FLAG and no cert stores causes the
3725 * message signer not to be found.
3726 */
3727 SetLastError(0xdeadbeef);
3729 NULL, NULL);
3731 broken(GetLastError() == OSS_DATA_ERROR /* Win9x */)),
3732 "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3733 /* Specifying CMSG_TRUSTED_SIGNER_FLAG and an empty cert store also causes
3734 * the message signer not to be found.
3735 */
3738 SetLastError(0xdeadbeef);
3740 NULL, NULL);
3742 broken(GetLastError() == OSS_DATA_ERROR /* Win9x */)),
3743 "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3747 ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win98 */),
3748 "CertAddEncodedCertificateToStore failed: 0x%08x\n", GetLastError());
3749 /* Specifying CMSG_TRUSTED_SIGNER_FLAG with a cert store that contains
3750 * the signer succeeds.
3751 */
3752 SetLastError(0xdeadbeef);
3754 NULL, NULL);
3755 ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3756 "CryptMsgGetAndVerifySigner failed: 0x%08x\n", GetLastError());
3757 CertCloseStore(store, 0);
3759}
3760
3762{
3764 have_nt = detect_nt();
3765 if (!have_nt)
3766 win_skip("Win9x crashes on some parameter checks\n");
3767
3768 /* I_CertUpdateStore can be used for verification if crypt32 is new enough */
3769 if (!GetProcAddress(GetModuleHandleA("crypt32.dll"), "I_CertUpdateStore"))
3770 {
3771 win_skip("Some tests will crash on older crypt32 implementations\n");
3772 old_crypt32 = TRUE;
3773 }
3774
3775 /* Basic parameter checking tests */
3781
3782 /* Message-type specific tests */
3783 test_data_msg();
3784 test_hash_msg();
3788
3790}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define ok(value,...)
Definition: atltest.h:57
#define skip(...)
Definition: atltest.h:64
#define broken(x)
Definition: atltest.h:178
#define START_TEST(x)
Definition: atltest.h:75
#define msg(x)
Definition: auth_time.c:54
#define ARRAY_SIZE(A)
Definition: main.h:20
#define U(x)
Definition: wordpad.c:45
#define STATUS_ILLEGAL_INSTRUCTION
Definition: d3dkmdt.h:41
#define E_INVALIDARG
Definition: ddrawi.h:101
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
BOOL WINAPI CryptDestroyKey(HCRYPTKEY hKey)
Definition: crypt.c:930
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags)
Definition: crypt.c:648
BOOL WINAPI CryptAcquireContextA(HCRYPTPROV *phProv, LPCSTR pszContainer, LPCSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
Definition: crypt.c:569
BOOL WINAPI CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR pszContainer, LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
Definition: crypt.c:358
BOOL WINAPI CryptImportKey(HCRYPTPROV hProv, const BYTE *pbData, DWORD dwDataLen, HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey)
Definition: crypt.c:1850
BOOL WINAPI CertFreeCertificateContext(PCCERT_CONTEXT pCertContext)
Definition: cert.c:371
PCCERT_CONTEXT WINAPI CertCreateCertificateContext(DWORD dwCertEncodingType, const BYTE *pbCertEncoded, DWORD cbCertEncoded)
Definition: cert.c:316
BOOL WINAPI CertAddEncodedCertificateToStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, const BYTE *pbCertEncoded, DWORD cbCertEncoded, DWORD dwAddDisposition, PCCERT_CONTEXT *ppCertContext)
Definition: cert.c:58
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
LPVOID WINAPI CryptMemRealloc(LPVOID pv, ULONG cbSize)
Definition: main.c:136
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
HCRYPTMSG WINAPI CryptMsgOpenToEncode(DWORD dwMsgEncodingType, DWORD dwFlags, DWORD dwMsgType, const void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo)
Definition: msg.c:2034
BOOL WINAPI CryptMsgGetAndVerifySigner(HCRYPTMSG hCryptMsg, DWORD cSignerStore, HCERTSTORE *rghSignerStore, DWORD dwFlags, PCCERT_CONTEXT *ppSigner, DWORD *pdwSignerIndex)
Definition: msg.c:3669
HCRYPTMSG WINAPI CryptMsgOpenToDecode(DWORD dwMsgEncodingType, DWORD dwFlags, DWORD dwMsgType, HCRYPTPROV_LEGACY hCryptProv, PCERT_INFO pRecipientInfo, PCMSG_STREAM_INFO pStreamInfo)
Definition: msg.c:3552
BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:3626
BOOL WINAPI CryptMsgUpdate(HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
Definition: msg.c:3616
BOOL WINAPI CryptMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags, DWORD dwCtrlType, const void *pvCtrlPara)
Definition: msg.c:3636
BOOL WINAPI CryptMsgClose(HCRYPTMSG hCryptMsg)
Definition: msg.c:3597
static WCHAR issuer[MAX_STRING_RESOURCE_LEN]
Definition: object.c:1905
HCERTSTORE WINAPI CertOpenStore(LPCSTR lpszStoreProvider, DWORD dwMsgAndCertEncodingType, HCRYPTPROV_LEGACY hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:815
BOOL WINAPI CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
Definition: store.c:1127
#define GetProcessHeap()
Definition: compat.h:736
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define SetLastError(x)
Definition: compat.h:752
#define GetProcAddress(x, y)
Definition: compat.h:753
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLsizeiptr size
Definition: glext.h:5919
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLdouble GLdouble u2
Definition: glext.h:8308
GLfloat param
Definition: glext.h:5796
GLdouble u1
Definition: glext.h:8308
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static const char commonName[]
Definition: encode.c:673
static BYTE serialNum[]
Definition: msg.c:1072
static const BYTE bogusOIDContent[]
Definition: msg.c:2287
static BYTE u3[]
Definition: msg.c:580
static void test_signed_msg_encoding(void)
Definition: msg.c:1652
static const BYTE dataBareContent[]
Definition: msg.c:531
static void check_updates(LPCSTR header, const struct update_accum *expected, const struct update_accum *got)
Definition: msg.c:602
static BYTE pubKey[]
Definition: msg.c:1214
static const BYTE signedWithCertAndCrlComputedHash[]
Definition: msg.c:2723
static void compare_cms_signer_info(const CMSG_CMS_SIGNER_INFO *got, const CMSG_CMS_SIGNER_INFO *expected)
Definition: msg.c:2679
static void test_msg_open_to_decode(void)
Definition: msg.c:101
static void test_signed_msg(void)
Definition: msg.c:2043
static BYTE v1CertWithPubKey[]
Definition: msg.c:1447
static BOOL WINAPI accumulating_stream_output(const void *pvArg, BYTE *pb, DWORD cb, BOOL final)
Definition: msg.c:542
static BYTE v1CertWithValidPubKey[]
Definition: msg.c:1585
static const BYTE detachedSignedBareContent[]
Definition: msg.c:1349
static void test_signed_msg_update(void)
Definition: msg.c:1221
static void test_signed_msg_get_param(void)
Definition: msg.c:1851
static void test_data_msg_get_param(void)
Definition: msg.c:480
static const BYTE envelopedBareMessage[]
Definition: msg.c:2788
static void check_param(LPCSTR test, HCRYPTMSG msg, DWORD param, const BYTE *expected, DWORD expectedSize)
Definition: msg.c:288
static const BYTE signedEncodedSigner[]
Definition: msg.c:1409
static const BYTE publicPrivateKeyPair[]
Definition: msg.c:2729
static void test_decode_msg_update(void)
Definition: msg.c:2313
static const BYTE envelopedMessageWith3Recps[]
Definition: msg.c:2805
static const BYTE envelopedEmptyContent[]
Definition: msg.c:2248
static void test_hash_msg_update(void)
Definition: msg.c:755
static BYTE u1[]
Definition: msg.c:570
static BYTE encodedCommonName[]
Definition: msg.c:1073
static BYTE mod_encoded[]
Definition: msg.c:3201
static void test_msg_get_and_verify_signer(void)
Definition: msg.c:3635
static const struct update_accum a1
Definition: msg.c:578
static const BYTE envelopedEmptyBareContent[]
Definition: msg.c:2244
#define GET_PROC(dll, func)
static const BYTE signedWithCrlBareContent[]
Definition: msg.c:1509
static const BYTE hashEmptyBareContent[]
Definition: msg.c:926
static const BYTE hashContent[]
Definition: msg.c:938
static CRYPT_DATA_BLOB b4
Definition: msg.c:2284
static void init_function_pointers(void)
Definition: msg.c:41
static const struct update_accum a2
Definition: msg.c:586
static void test_enveloped_msg_encoding(void)
Definition: msg.c:2254
static char oid_rsa_rc4[]
Definition: msg.c:2051
static const BYTE signedWithCertWithPubKeyBareContent[]
Definition: msg.c:1568
static const BYTE signedWithCertAndCrlBareContent[]
Definition: msg.c:1544
static const BYTE dataEmptyContent[]
Definition: msg.c:528
static const BYTE privKey[]
Definition: msg.c:1189
static void test_data_msg_open(void)
Definition: msg.c:315
static BYTE cert[]
Definition: msg.c:1437
static void test_enveloped_msg(void)
Definition: msg.c:2277
static BYTE u5[]
Definition: msg.c:590
static BYTE u4[]
Definition: msg.c:588
static CRYPT_DATA_BLOB b3[]
Definition: msg.c:592
static BOOL old_crypt32
Definition: msg.c:33
static const BYTE signedWithCertBareContent[]
Definition: msg.c:1474
static void test_data_msg_encoding(void)
Definition: msg.c:636
static const BYTE signedWithCertWithValidPubKeyEmptyContent[]
Definition: msg.c:1600
static const WCHAR cspNameW[]
Definition: msg.c:1070
static void test_hash_msg_get_param(void)
Definition: msg.c:820
static const BYTE signedContent[]
Definition: msg.c:1386
static const BYTE hashBareContent[]
Definition: msg.c:933
static BYTE u2[]
Definition: msg.c:572
static void test_signed_msg_open(void)
Definition: msg.c:1076
static const BYTE bogusHashContent[]
Definition: msg.c:2290
static const BYTE hashParam[]
Definition: msg.c:2658
static void test_hash_msg_encoding(void)
Definition: msg.c:966
static const BYTE detachedHashContent[]
Definition: msg.c:959
static const BYTE signedKeyIdEmptyContent[]
Definition: msg.c:1403
static void test_msg_close(void)
Definition: msg.c:270
static const BYTE dataContent[]
Definition: msg.c:532
static void test_data_msg_update(void)
Definition: msg.c:368
static CRYPT_DATA_BLOB b2[]
Definition: msg.c:582
static void test_hash_msg_open(void)
Definition: msg.c:723
static void test_data_msg(void)
Definition: msg.c:715
static const BYTE signedWithCrlEmptyBareContent[]
Definition: msg.c:1499
static const BYTE envelopedBareContentWithoutData[]
Definition: msg.c:2296
static const BYTE signedHash[]
Definition: msg.c:1400
static const BYTE signedWithCertAndCrlEmptyBareContent[]
Definition: msg.c:1525
static BYTE aKey[]
Definition: msg.c:3194
static LPCWSTR
Definition: msg.c:39
static void free_updates(struct update_accum *accum)
Definition: msg.c:625
static void compare_signer_info(const CMSG_SIGNER_INFO *got, const CMSG_SIGNER_INFO *expected)
Definition: msg.c:2661
static BYTE encodedPubKey[]
Definition: msg.c:3196
static void test_msg_control(void)
Definition: msg.c:3205
static const BYTE serialNumber[]
Definition: msg.c:2848
static CRYPT_DATA_BLOB b1[]
Definition: msg.c:573
static BOOL detect_nt(void)
Definition: msg.c:3602
static void test_enveloped_msg_update(void)
Definition: msg.c:2120
static const BYTE detachedHashBareContent[]
Definition: msg.c:954
static const struct update_accum a3
Definition: msg.c:600
static const BYTE detachedHashNonFinalBareContent[]
Definition: msg.c:945
static void test_msg_open_to_encode(void)
Definition: msg.c:56
static const BYTE dataEmptyBareContent[]
Definition: msg.c:366
static const BYTE detachedSignedContent[]
Definition: msg.c:1361
static BYTE crl[]
Definition: msg.c:1495
static const BYTE hashEmptyContent[]
Definition: msg.c:929
static const BYTE detachedHashNonFinalContent[]
Definition: msg.c:949
static const BYTE signedEmptyBareContent[]
Definition: msg.c:1334
static void test_decode_msg(void)
Definition: msg.c:3188
static void test_hash_msg(void)
Definition: msg.c:1060
static LPCSTR
Definition: msg.c:37
static const BYTE envelopedMessage[]
Definition: msg.c:2770
static const struct update_accum a4
Definition: msg.c:2285
static void test_enveloped_msg_open(void)
Definition: msg.c:2053
static const BYTE msgData[]
Definition: msg.c:358
static const BYTE signedWithCertWithValidPubKeyContent[]
Definition: msg.c:1623
static const CHAR cspNameA[]
Definition: msg.c:1068
static void test_decode_msg_get_param(void)
Definition: msg.c:2854
static void test_msg_get_param(void)
Definition: msg.c:164
static const BYTE signedBareContent[]
Definition: msg.c:1374
static const BYTE emptyHashParam[]
Definition: msg.c:816
static const BYTE signedWithCertEmptyBareContent[]
Definition: msg.c:1459
static BYTE keyIdIssuer[]
Definition: msg.c:2726
static const BYTE signedWithAuthAttrsBareContent[]
Definition: msg.c:1418
static BOOL WINAPI nop_stream_output(const void *pvArg, BYTE *pb, DWORD cb, BOOL final)
Definition: msg.c:360
static const BYTE signedEmptyContent[]
Definition: msg.c:1341
static char oid_rsa_md5[]
Definition: msg.c:34
static BOOL have_nt
Definition: msg.c:32
static BYTE u6[]
Definition: msg.c:591
BOOL expected
Definition: store.c:2063
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
#define todo_wine
Definition: custom.c:89
#define min(a, b)
Definition: monoChain.cc:55
#define BOOL
Definition: nt_native.h:43
#define DWORD
Definition: nt_native.h:44
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define test
Definition: rosglue.h:37
#define win_skip
Definition: test.h:163
int zero
Definition: sehframes.cpp:29
DWORD dwIdChoice
Definition: wincrypt.h:3665
CERT_NAME_BLOB Issuer
Definition: wincrypt.h:244
CERT_PUBLIC_KEY_INFO SubjectPublicKeyInfo
Definition: wincrypt.h:248
CRYPT_INTEGER_BLOB SerialNumber
Definition: wincrypt.h:242
CRYPT_BIT_BLOB PublicKey
Definition: wincrypt.h:226
CRYPT_ALGORITHM_IDENTIFIER Algorithm
Definition: wincrypt.h:225
CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm
Definition: wincrypt.h:3964
HCRYPTPROV_LEGACY hCryptProv
Definition: wincrypt.h:3819
PCERT_INFO * rgpRecipientCert
Definition: wincrypt.h:3823
CRYPT_ALGORITHM_IDENTIFIER ContentEncryptionAlgorithm
Definition: wincrypt.h:3820
CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm
Definition: wincrypt.h:3849
PCMSG_SIGNER_ENCODE_INFO rgSigners
Definition: wincrypt.h:3731
PCERT_BLOB rgCertEncoded
Definition: wincrypt.h:3733
CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm
Definition: wincrypt.h:3714
PCRYPT_ATTRIBUTE rgAuthAttr
Definition: wincrypt.h:3717
CERT_NAME_BLOB Issuer
Definition: wincrypt.h:770
CRYPT_INTEGER_BLOB SerialNumber
Definition: wincrypt.h:771
CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm
Definition: wincrypt.h:772
PFN_CMSG_STREAM_OUTPUT pfnStreamOutput
Definition: wincrypt.h:3653
BYTE * pbData
Definition: wincrypt.h:103
BYTE * pbData
Definition: wincrypt.h:197
Definition: cookie.c:202
Definition: image.c:134
Definition: http.c:7252
Definition: copy.c:22
DWORD cUpdates
Definition: msg.c:538
CRYPT_DATA_BLOB * updates
Definition: msg.c:539
unsigned char * LPBYTE
Definition: typedefs.h:53
Definition: pdh_main.c:94
int ret
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define CMSG_VERSION_PARAM
Definition: wincrypt.h:3950
#define MS_DEF_PROV_A
Definition: wincrypt.h:1860
#define CERT_ID_ISSUER_SERIAL_NUMBER
Definition: wincrypt.h:3673
#define CRYPT_NEWKEYSET
Definition: wincrypt.h:2070
#define PROV_RSA_FULL
Definition: wincrypt.h:2039
#define CRYPT_VERIFYCONTEXT
Definition: wincrypt.h:2069
#define CMSG_DATA
Definition: wincrypt.h:3679
#define CMSG_HASHED
Definition: wincrypt.h:3683
#define CMSG_BARE_CONTENT_FLAG
Definition: wincrypt.h:3860
#define CMSG_CTRL_VERIFY_HASH
Definition: wincrypt.h:3871
#define CMSG_COMPUTED_HASH_PARAM
Definition: wincrypt.h:3945
#define CMSG_BARE_CONTENT_PARAM
Definition: wincrypt.h:3927
ULONG_PTR HCRYPTPROV
Definition: wincrypt.h:46
#define CMSG_TYPE_PARAM
Definition: wincrypt.h:3925
#define CMSG_CRYPT_RELEASE_CONTEXT_FLAG
Definition: wincrypt.h:3867
#define CMSG_SIGNED_AND_ENVELOPED
Definition: wincrypt.h:3682
#define CMSG_SIGNER_CERT_ID_PARAM
Definition: wincrypt.h:3958
#define CERT_ID_KEY_IDENTIFIER
Definition: wincrypt.h:3674
#define CMSG_SIGNED_DATA_V3
Definition: wincrypt.h:3974
#define CERT_STORE_CREATE_NEW_FLAG
Definition: wincrypt.h:2464
#define CMSG_SIGNED_DATA_V1
Definition: wincrypt.h:3973
#define CRYPT_DELETEKEYSET
Definition: wincrypt.h:2071
#define CMSG_ENCODED_SIGNER
Definition: wincrypt.h:3948
#define CMSG_CMS_SIGNER_INFO_PARAM
Definition: wincrypt.h:3959
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
#define CMSG_INNER_CONTENT_TYPE_PARAM
Definition: wincrypt.h:3928
#define CERT_STORE_PROV_MEMORY
Definition: wincrypt.h:2251
#define CMSG_ENVELOPED
Definition: wincrypt.h:3681
#define CMSG_CTRL_DECRYPT
Definition: wincrypt.h:3870
#define CMSG_RECIPIENT_INFO_PARAM
Definition: wincrypt.h:3942
#define CMSG_SIGNER_INFO_PARAM
Definition: wincrypt.h:3930
#define CMSG_DETACHED_FLAG
Definition: wincrypt.h:3862
#define szOID_RSA_MD5
Definition: wincrypt.h:3053
#define szOID_RSA_RC4
Definition: wincrypt.h:3055
const CERT_CONTEXT * PCCERT_CONTEXT
Definition: wincrypt.h:485
#define CMSG_ENCRYPTED
Definition: wincrypt.h:3684
#define CMSG_USE_SIGNER_INDEX_FLAG
Definition: wincrypt.h:4122
#define CMSG_SIGNED
Definition: wincrypt.h:3680
#define CMSG_HASHED_DATA_V0
Definition: wincrypt.h:3983
#define CERT_STORE_ADD_ALWAYS
Definition: wincrypt.h:2485
#define CMSG_CTRL_ADD_CMS_SIGNER_INFO
Definition: wincrypt.h:3886
#define CMSG_CRL_PARAM
Definition: wincrypt.h:3938
#define MS_ENHANCED_PROV_A
Definition: wincrypt.h:1874
#define szOID_RSA_RSA
Definition: wincrypt.h:3015
#define szOID_COMMON_NAME
Definition: wincrypt.h:3134
#define CMSG_SIGNER_COUNT_PARAM
Definition: wincrypt.h:3929
#define PKCS_7_ASN_ENCODING
Definition: wincrypt.h:2299
#define szOID_RSA_data
Definition: wincrypt.h:3028
#define CMSG_HASH_DATA_PARAM
Definition: wincrypt.h:3944
#define CMSG_TRUSTED_SIGNER_FLAG
Definition: wincrypt.h:4120
ULONG_PTR HCRYPTKEY
Definition: wincrypt.h:49
#define CMSG_CERT_COUNT_PARAM
Definition: wincrypt.h:3935
#define CMSG_RECIPIENT_COUNT_PARAM
Definition: wincrypt.h:3940
#define CMSG_CONTENT_PARAM
Definition: wincrypt.h:3926
#define CMSG_CRL_COUNT_PARAM
Definition: wincrypt.h:3937
#define CMSG_CERT_PARAM
Definition: wincrypt.h:3936
#define CMSG_CTRL_VERIFY_SIGNATURE
Definition: wincrypt.h:3869
#define WINAPI
Definition: msvc.h:6
#define OSS_LIMITED
Definition: winerror.h:3047
#define CRYPT_E_NO_TRUSTED_SIGNER
Definition: winerror.h:3035
#define CRYPT_E_MSG_ERROR
Definition: winerror.h:2985
#define NTE_BAD_ALGID
Definition: winerror.h:2876
#define CRYPT_E_HASH_VALUE
Definition: winerror.h:2991
#define CRYPT_E_INVALID_INDEX
Definition: winerror.h:2992
#define NTE_NO_KEY
Definition: winerror.h:2881
#define CRYPT_E_STREAM_INSUFFICIENT_DATA
Definition: winerror.h:3001
#define TRUST_E_NOSIGNATURE
Definition: winerror.h:3116
#define NTE_BAD_HASH_STATE
Definition: winerror.h:2880
#define OSS_PDU_MISMATCH
Definition: winerror.h:3046
#define NTE_PERM
Definition: winerror.h:2884
#define NTE_BAD_SIGNATURE
Definition: winerror.h:2874
#define CRYPT_E_UNKNOWN_ALGO
Definition: winerror.h:2986
#define CRYPT_E_SIGNER_NOT_FOUND
Definition: winerror.h:2998
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
#define NTE_EXISTS
Definition: winerror.h:2883
#define NTE_BAD_KEYSET
Definition: winerror.h:2890
#define CRYPT_E_CONTROL_TYPE
Definition: winerror.h:2996
#define CRYPT_E_ASN1_EOD
Definition: winerror.h:3086
#define OSS_DATA_ERROR
Definition: winerror.h:3042
#define CRYPT_E_ASN1_BADTAG
Definition: winerror.h:3095
#define CRYPT_E_ALREADY_DECRYPTED
Definition: winerror.h:2993
const char * LPCSTR
Definition: xmlstorage.h:183
__wchar_t WCHAR
Definition: xmlstorage.h:180
char CHAR
Definition: xmlstorage.h:175
unsigned char BYTE
Definition: xxhash.c:193