2 * Unit test suite for crypt32.dll's CryptEncodeObjectEx/CryptDecodeObjectEx
4 * Copyright 2005 Juan Lang
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.
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.
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
27 #include "wine/test.h"
30 static BOOL (WINAPI
*pCryptDecodeObjectEx
)(DWORD
,LPCSTR
,const BYTE
*,DWORD
,DWORD
,PCRYPT_DECODE_PARA
,void*,DWORD
*);
31 static BOOL (WINAPI
*pCryptEncodeObjectEx
)(DWORD
,LPCSTR
,const void*,DWORD
,PCRYPT_ENCODE_PARA
,void*,DWORD
*);
39 static const BYTE bin1
[] = {0x02,0x01,0x01};
40 static const BYTE bin2
[] = {0x02,0x01,0x7f};
41 static const BYTE bin3
[] = {0x02,0x02,0x00,0x80};
42 static const BYTE bin4
[] = {0x02,0x02,0x01,0x00};
43 static const BYTE bin5
[] = {0x02,0x01,0x80};
44 static const BYTE bin6
[] = {0x02,0x02,0xff,0x7f};
45 static const BYTE bin7
[] = {0x02,0x04,0xba,0xdd,0xf0,0x0d};
47 static const struct encodedInt ints
[] = {
64 static const BYTE bin8
[] = {0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0};
65 static const BYTE bin9
[] = {0x02,0x0a,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0xff,0xff,0};
66 static const BYTE bin10
[] = {0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0};
68 static const BYTE bin11
[] = {0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0xff,0xff,0xff,0};
69 static const BYTE bin12
[] = {0x02,0x09,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0};
70 static const BYTE bin13
[] = {0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0xff,0};
72 static const struct encodedBigInt bigInts
[] = {
73 { bin8
, bin9
, bin10
},
74 { bin11
, bin12
, bin13
},
77 static const BYTE bin14
[] = {0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0};
78 static const BYTE bin15
[] = {0x02,0x0a,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0xff,0xff,0};
79 static const BYTE bin16
[] = {0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0xff,0xff,0xff,0};
80 static const BYTE bin17
[] = {0x02,0x0c,0x00,0xff,0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0};
82 /* Decoded is the same as original, so don't bother storing a separate copy */
83 static const struct encodedBigInt bigUInts
[] = {
84 { bin14
, bin15
, NULL
},
85 { bin16
, bin17
, NULL
},
88 static void test_encodeInt(DWORD dwEncoding
)
93 CRYPT_INTEGER_BLOB blob
;
96 /* CryptEncodeObjectEx with NULL bufSize crashes..
97 ret = pCryptEncodeObjectEx(3, X509_INTEGER, &ints[0].val, 0, NULL, NULL,
100 /* check bogus encoding */
101 ret
= pCryptEncodeObjectEx(0, X509_INTEGER
, &ints
[0].val
, 0, NULL
, NULL
,
103 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
104 "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
107 /* check with NULL integer buffer. Windows XP incorrectly returns an
108 * NTSTATUS (crashes on win9x).
110 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_INTEGER
, NULL
, 0, NULL
, NULL
,
112 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
113 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
115 for (i
= 0; i
< sizeof(ints
) / sizeof(ints
[0]); i
++)
117 /* encode as normal integer */
118 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_INTEGER
, &ints
[i
].val
, 0,
119 NULL
, NULL
, &bufSize
);
120 ok(ret
, "Expected success, got %d\n", GetLastError());
121 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_INTEGER
, &ints
[i
].val
,
122 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
123 ok(ret
, "CryptEncodeObjectEx failed: %d\n", GetLastError());
126 ok(buf
[0] == 2, "Got unexpected type %d for integer (expected 2)\n",
128 ok(buf
[1] == ints
[i
].encoded
[1], "Got length %d, expected %d\n",
129 buf
[1], ints
[i
].encoded
[1]);
130 ok(!memcmp(buf
+ 1, ints
[i
].encoded
+ 1, ints
[i
].encoded
[1] + 1),
131 "Encoded value of 0x%08x didn't match expected\n", ints
[i
].val
);
134 /* encode as multibyte integer */
135 blob
.cbData
= sizeof(ints
[i
].val
);
136 blob
.pbData
= (BYTE
*)&ints
[i
].val
;
137 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_MULTI_BYTE_INTEGER
, &blob
,
138 0, NULL
, NULL
, &bufSize
);
139 ok(ret
, "Expected success, got %d\n", GetLastError());
140 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_MULTI_BYTE_INTEGER
, &blob
,
141 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
142 ok(ret
, "CryptEncodeObjectEx failed: %d\n", GetLastError());
145 ok(buf
[0] == 2, "Got unexpected type %d for integer (expected 2)\n",
147 ok(buf
[1] == ints
[i
].encoded
[1], "Got length %d, expected %d\n",
148 buf
[1], ints
[i
].encoded
[1]);
149 ok(!memcmp(buf
+ 1, ints
[i
].encoded
+ 1, ints
[i
].encoded
[1] + 1),
150 "Encoded value of 0x%08x didn't match expected\n", ints
[i
].val
);
154 /* encode a couple bigger ints, just to show it's little-endian and leading
155 * sign bytes are dropped
157 for (i
= 0; i
< sizeof(bigInts
) / sizeof(bigInts
[0]); i
++)
159 blob
.cbData
= strlen((const char*)bigInts
[i
].val
);
160 blob
.pbData
= (BYTE
*)bigInts
[i
].val
;
161 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_MULTI_BYTE_INTEGER
, &blob
,
162 0, NULL
, NULL
, &bufSize
);
163 ok(ret
, "Expected success, got %d\n", GetLastError());
164 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_MULTI_BYTE_INTEGER
, &blob
,
165 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
166 ok(ret
, "CryptEncodeObjectEx failed: %d\n", GetLastError());
169 ok(buf
[0] == 2, "Got unexpected type %d for integer (expected 2)\n",
171 ok(buf
[1] == bigInts
[i
].encoded
[1], "Got length %d, expected %d\n",
172 buf
[1], bigInts
[i
].encoded
[1]);
173 ok(!memcmp(buf
+ 1, bigInts
[i
].encoded
+ 1,
174 bigInts
[i
].encoded
[1] + 1),
175 "Encoded value didn't match expected\n");
179 /* and, encode some uints */
180 for (i
= 0; i
< sizeof(bigUInts
) / sizeof(bigUInts
[0]); i
++)
182 blob
.cbData
= strlen((const char*)bigUInts
[i
].val
);
183 blob
.pbData
= (BYTE
*)bigUInts
[i
].val
;
184 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_MULTI_BYTE_UINT
, &blob
,
185 0, NULL
, NULL
, &bufSize
);
186 ok(ret
, "Expected success, got %d\n", GetLastError());
187 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_MULTI_BYTE_UINT
, &blob
,
188 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
189 ok(ret
, "CryptEncodeObjectEx failed: %d\n", GetLastError());
192 ok(buf
[0] == 2, "Got unexpected type %d for integer (expected 2)\n",
194 ok(buf
[1] == bigUInts
[i
].encoded
[1], "Got length %d, expected %d\n",
195 buf
[1], bigUInts
[i
].encoded
[1]);
196 ok(!memcmp(buf
+ 1, bigUInts
[i
].encoded
+ 1,
197 bigUInts
[i
].encoded
[1] + 1),
198 "Encoded value didn't match expected\n");
204 static void test_decodeInt(DWORD dwEncoding
)
206 static const BYTE bigInt
[] = { 2, 5, 0xff, 0xfe, 0xff, 0xfe, 0xff };
207 static const BYTE testStr
[] = { 0x16, 4, 't', 'e', 's', 't' };
208 static const BYTE longForm
[] = { 2, 0x81, 0x01, 0x01 };
209 static const BYTE bigBogus
[] = { 0x02, 0x84, 0x01, 0xff, 0xff, 0xf9 };
210 static const BYTE extraBytes
[] = { 2, 1, 1, 0, 0, 0, 0 };
216 /* CryptDecodeObjectEx with NULL bufSize crashes..
217 ret = pCryptDecodeObjectEx(3, X509_INTEGER, &ints[0].encoded,
218 ints[0].encoded[1] + 2, 0, NULL, NULL, NULL);
220 /* check bogus encoding */
221 ret
= pCryptDecodeObjectEx(3, X509_INTEGER
, (BYTE
*)&ints
[0].encoded
,
222 ints
[0].encoded
[1] + 2, 0, NULL
, NULL
, &bufSize
);
223 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
224 "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
225 /* check with NULL integer buffer */
226 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_INTEGER
, NULL
, 0, 0, NULL
, NULL
,
228 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_EOD
||
229 GetLastError() == OSS_BAD_ARG
/* Win9x */),
230 "Expected CRYPT_E_ASN1_EOD or OSS_BAD_ARG, got %08x\n", GetLastError());
231 /* check with a valid, but too large, integer */
232 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_INTEGER
, bigInt
, bigInt
[1] + 2,
233 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
234 ok((!ret
&& GetLastError() == CRYPT_E_ASN1_LARGE
) ||
235 broken(ret
) /* Win9x */,
236 "Expected CRYPT_E_ASN1_LARGE, got %d\n", GetLastError());
237 /* check with a DER-encoded string */
238 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_INTEGER
, testStr
, testStr
[1] + 2,
239 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
240 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_BADTAG
||
241 GetLastError() == OSS_PDU_MISMATCH
/* Win9x */ ),
242 "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %08x\n",
244 for (i
= 0; i
< sizeof(ints
) / sizeof(ints
[0]); i
++)
246 /* When the output buffer is NULL, this always succeeds */
247 SetLastError(0xdeadbeef);
248 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_INTEGER
,
249 ints
[i
].encoded
, ints
[i
].encoded
[1] + 2, 0, NULL
, NULL
,
251 ok(ret
&& GetLastError() == NOERROR
,
252 "Expected success and NOERROR, got %d\n", GetLastError());
253 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_INTEGER
,
254 ints
[i
].encoded
, ints
[i
].encoded
[1] + 2,
255 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
256 ok(ret
, "CryptDecodeObjectEx failed: %d\n", GetLastError());
257 ok(bufSize
== sizeof(int), "Wrong size %d\n", bufSize
);
258 ok(buf
!= NULL
, "Expected allocated buffer\n");
261 ok(!memcmp(buf
, &ints
[i
].val
, bufSize
), "Expected %d, got %d\n",
262 ints
[i
].val
, *(int *)buf
);
266 for (i
= 0; i
< sizeof(bigInts
) / sizeof(bigInts
[0]); i
++)
268 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_MULTI_BYTE_INTEGER
,
269 bigInts
[i
].encoded
, bigInts
[i
].encoded
[1] + 2, 0, NULL
, NULL
,
271 ok(ret
&& GetLastError() == NOERROR
,
272 "Expected success and NOERROR, got %d\n", GetLastError());
273 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_MULTI_BYTE_INTEGER
,
274 bigInts
[i
].encoded
, bigInts
[i
].encoded
[1] + 2,
275 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
276 ok(ret
, "CryptDecodeObjectEx failed: %d\n", GetLastError());
277 ok(bufSize
>= sizeof(CRYPT_INTEGER_BLOB
), "Wrong size %d\n", bufSize
);
278 ok(buf
!= NULL
, "Expected allocated buffer\n");
281 CRYPT_INTEGER_BLOB
*blob
= (CRYPT_INTEGER_BLOB
*)buf
;
283 ok(blob
->cbData
== strlen((const char*)bigInts
[i
].decoded
),
284 "Expected len %d, got %d\n", lstrlenA((const char*)bigInts
[i
].decoded
),
286 ok(!memcmp(blob
->pbData
, bigInts
[i
].decoded
, blob
->cbData
),
287 "Unexpected value\n");
291 for (i
= 0; i
< sizeof(bigUInts
) / sizeof(bigUInts
[0]); i
++)
293 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_MULTI_BYTE_UINT
,
294 bigUInts
[i
].encoded
, bigUInts
[i
].encoded
[1] + 2, 0, NULL
, NULL
,
296 ok(ret
&& GetLastError() == NOERROR
,
297 "Expected success and NOERROR, got %d\n", GetLastError());
298 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_MULTI_BYTE_UINT
,
299 bigUInts
[i
].encoded
, bigUInts
[i
].encoded
[1] + 2,
300 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
301 ok(ret
, "CryptDecodeObjectEx failed: %d\n", GetLastError());
302 ok(bufSize
>= sizeof(CRYPT_INTEGER_BLOB
), "Wrong size %d\n", bufSize
);
303 ok(buf
!= NULL
, "Expected allocated buffer\n");
306 CRYPT_INTEGER_BLOB
*blob
= (CRYPT_INTEGER_BLOB
*)buf
;
308 ok(blob
->cbData
== strlen((const char*)bigUInts
[i
].val
),
309 "Expected len %d, got %d\n", lstrlenA((const char*)bigUInts
[i
].val
),
311 ok(!memcmp(blob
->pbData
, bigUInts
[i
].val
, blob
->cbData
),
312 "Unexpected value\n");
316 /* Decode the value 1 with long-form length */
317 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_MULTI_BYTE_INTEGER
, longForm
,
318 sizeof(longForm
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
319 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
322 ok(*(int *)buf
== 1, "Expected 1, got %d\n", *(int *)buf
);
325 /* check with extra bytes at the end */
326 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_INTEGER
, extraBytes
,
327 sizeof(extraBytes
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
328 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
331 ok(*(int *)buf
== 1, "Expected 1, got %d\n", *(int *)buf
);
334 /* Try to decode some bogus large items */
335 /* The buffer size is smaller than the encoded length, so this should fail
336 * with CRYPT_E_ASN1_EOD if it's being decoded.
337 * Under XP it fails with CRYPT_E_ASN1_LARGE, which means there's a limit
338 * on the size decoded, but in ME it fails with CRYPT_E_ASN1_EOD or crashes.
339 * So this test unfortunately isn't useful.
340 ret = pCryptDecodeObjectEx(dwEncoding, X509_MULTI_BYTE_INTEGER, tooBig,
341 0x7fffffff, CRYPT_DECODE_ALLOC_FLAG, NULL, &buf, &bufSize);
342 ok(!ret && GetLastError() == CRYPT_E_ASN1_LARGE,
343 "Expected CRYPT_E_ASN1_LARGE, got %08x\n", GetLastError());
345 /* This will try to decode the buffer and overflow it, check that it's
350 /* a large buffer isn't guaranteed to crash, it depends on memory allocation order */
351 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_MULTI_BYTE_INTEGER
, bigBogus
,
352 0x01ffffff, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
353 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
354 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
358 static const BYTE bin18
[] = {0x0a,0x01,0x01};
359 static const BYTE bin19
[] = {0x0a,0x05,0x00,0xff,0xff,0xff,0x80};
361 /* These are always encoded unsigned, and aren't constrained to be any
364 static const struct encodedInt enums
[] = {
369 /* X509_CRL_REASON_CODE is also an enumerated type, but it's #defined to
372 static const LPCSTR enumeratedTypes
[] = { X509_ENUMERATED
,
373 szOID_CRL_REASON_CODE
};
375 static void test_encodeEnumerated(DWORD dwEncoding
)
379 for (i
= 0; i
< sizeof(enumeratedTypes
) / sizeof(enumeratedTypes
[0]); i
++)
381 for (j
= 0; j
< sizeof(enums
) / sizeof(enums
[0]); j
++)
387 ret
= pCryptEncodeObjectEx(dwEncoding
, enumeratedTypes
[i
],
388 &enums
[j
].val
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
,
390 ok(ret
, "CryptEncodeObjectEx failed: %d\n", GetLastError());
394 "Got unexpected type %d for enumerated (expected 0xa)\n",
396 ok(buf
[1] == enums
[j
].encoded
[1],
397 "Got length %d, expected %d\n", buf
[1], enums
[j
].encoded
[1]);
398 ok(!memcmp(buf
+ 1, enums
[j
].encoded
+ 1,
399 enums
[j
].encoded
[1] + 1),
400 "Encoded value of 0x%08x didn't match expected\n",
408 static void test_decodeEnumerated(DWORD dwEncoding
)
412 for (i
= 0; i
< sizeof(enumeratedTypes
) / sizeof(enumeratedTypes
[0]); i
++)
414 for (j
= 0; j
< sizeof(enums
) / sizeof(enums
[0]); j
++)
417 DWORD bufSize
= sizeof(int);
420 ret
= pCryptDecodeObjectEx(dwEncoding
, enumeratedTypes
[i
],
421 enums
[j
].encoded
, enums
[j
].encoded
[1] + 2, 0, NULL
,
423 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
424 ok(bufSize
== sizeof(int),
425 "Got unexpected size %d for enumerated\n", bufSize
);
426 ok(val
== enums
[j
].val
, "Unexpected value %d, expected %d\n",
432 struct encodedFiletime
435 const BYTE
*encodedTime
;
438 static void testTimeEncoding(DWORD dwEncoding
, LPCSTR structType
,
439 const struct encodedFiletime
*time
)
446 ret
= SystemTimeToFileTime(&time
->sysTime
, &ft
);
447 ok(ret
, "SystemTimeToFileTime failed: %d\n", GetLastError());
448 ret
= pCryptEncodeObjectEx(dwEncoding
, structType
, &ft
,
449 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
450 /* years other than 1950-2050 are not allowed for encodings other than
451 * X509_CHOICE_OF_TIME.
453 if (structType
== X509_CHOICE_OF_TIME
||
454 (time
->sysTime
.wYear
>= 1950 && time
->sysTime
.wYear
<= 2050))
456 ok(ret
, "CryptEncodeObjectEx failed: %d (0x%08x)\n", GetLastError(),
458 ok(buf
!= NULL
, "Expected an allocated buffer\n");
461 ok(buf
[0] == time
->encodedTime
[0],
462 "Expected type 0x%02x, got 0x%02x\n", time
->encodedTime
[0],
464 ok(buf
[1] == time
->encodedTime
[1], "Expected %d bytes, got %d\n",
465 time
->encodedTime
[1], bufSize
);
466 ok(!memcmp(time
->encodedTime
+ 2, buf
+ 2, time
->encodedTime
[1]),
467 "Got unexpected value for time encoding\n");
472 ok((!ret
&& GetLastError() == CRYPT_E_BAD_ENCODE
) ||
473 broken(GetLastError() == ERROR_SUCCESS
),
474 "Expected CRYPT_E_BAD_ENCODE, got 0x%08x\n", GetLastError());
477 static const char *printSystemTime(const SYSTEMTIME
*st
)
481 sprintf(buf
, "%02d-%02d-%04d %02d:%02d:%02d.%03d", st
->wMonth
, st
->wDay
,
482 st
->wYear
, st
->wHour
, st
->wMinute
, st
->wSecond
, st
->wMilliseconds
);
486 static const char *printFileTime(const FILETIME
*ft
)
491 FileTimeToSystemTime(ft
, &st
);
492 sprintf(buf
, "%02d-%02d-%04d %02d:%02d:%02d.%03d", st
.wMonth
, st
.wDay
,
493 st
.wYear
, st
.wHour
, st
.wMinute
, st
.wSecond
, st
.wMilliseconds
);
497 static void compareTime(const SYSTEMTIME
*expected
, const FILETIME
*got
)
501 FileTimeToSystemTime(got
, &st
);
502 ok((expected
->wYear
== st
.wYear
&&
503 expected
->wMonth
== st
.wMonth
&&
504 expected
->wDay
== st
.wDay
&&
505 expected
->wHour
== st
.wHour
&&
506 expected
->wMinute
== st
.wMinute
&&
507 expected
->wSecond
== st
.wSecond
&&
508 abs(expected
->wMilliseconds
- st
.wMilliseconds
) <= 1) ||
509 /* Some Windows systems only seem to be accurate in their time decoding to
510 * within about an hour.
512 broken(expected
->wYear
== st
.wYear
&&
513 expected
->wMonth
== st
.wMonth
&&
514 expected
->wDay
== st
.wDay
&&
515 abs(expected
->wHour
- st
.wHour
) <= 1),
516 "Got unexpected value for time decoding:\nexpected %s, got %s\n",
517 printSystemTime(expected
), printFileTime(got
));
520 static void testTimeDecoding(DWORD dwEncoding
, LPCSTR structType
,
521 const struct encodedFiletime
*time
)
524 DWORD size
= sizeof(ft
);
527 ret
= pCryptDecodeObjectEx(dwEncoding
, structType
, time
->encodedTime
,
528 time
->encodedTime
[1] + 2, 0, NULL
, &ft
, &size
);
529 /* years other than 1950-2050 are not allowed for encodings other than
530 * X509_CHOICE_OF_TIME.
532 if (structType
== X509_CHOICE_OF_TIME
||
533 (time
->sysTime
.wYear
>= 1950 && time
->sysTime
.wYear
<= 2050))
535 ok(ret
|| broken(GetLastError() == OSS_DATA_ERROR
),
536 "CryptDecodeObjectEx failed: %d (0x%08x)\n", GetLastError(),
539 compareTime(&time
->sysTime
, &ft
);
542 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_BADTAG
||
543 GetLastError() == OSS_PDU_MISMATCH
/* Win9x */ ),
544 "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %08x\n",
548 static const BYTE bin20
[] = {
549 0x17,0x0d,'0','5','0','6','0','6','1','6','1','0','0','0','Z'};
550 static const BYTE bin21
[] = {
551 0x18,0x0f,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','Z'};
552 static const BYTE bin22
[] = {
553 0x18,0x0f,'2','1','4','5','0','6','0','6','1','6','1','0','0','0','Z'};
555 static const struct encodedFiletime times
[] = {
556 { { 2005, 6, 1, 6, 16, 10, 0, 0 }, bin20
},
557 { { 1945, 6, 1, 6, 16, 10, 0, 0 }, bin21
},
558 { { 2145, 6, 1, 6, 16, 10, 0, 0 }, bin22
},
561 static void test_encodeFiletime(DWORD dwEncoding
)
565 for (i
= 0; i
< sizeof(times
) / sizeof(times
[0]); i
++)
567 testTimeEncoding(dwEncoding
, X509_CHOICE_OF_TIME
, ×
[i
]);
568 testTimeEncoding(dwEncoding
, PKCS_UTC_TIME
, ×
[i
]);
569 testTimeEncoding(dwEncoding
, szOID_RSA_signingTime
, ×
[i
]);
573 static const BYTE bin23
[] = {
574 0x18,0x13,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','.','0','0','0','Z'};
575 static const BYTE bin24
[] = {
576 0x18,0x13,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','.','9','9','9','Z'};
577 static const BYTE bin25
[] = {
578 0x18,0x13,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','+','0','1','0','0'};
579 static const BYTE bin26
[] = {
580 0x18,0x13,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','-','0','1','0','0'};
581 static const BYTE bin27
[] = {
582 0x18,0x13,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','-','0','1','1','5'};
583 static const BYTE bin28
[] = {
584 0x18,0x0a,'2','1','4','5','0','6','0','6','1','6'};
585 static const BYTE bin29
[] = {
586 0x17,0x0a,'4','5','0','6','0','6','1','6','1','0'};
587 static const BYTE bin30
[] = {
588 0x17,0x0b,'4','5','0','6','0','6','1','6','1','0','Z'};
589 static const BYTE bin31
[] = {
590 0x17,0x0d,'4','5','0','6','0','6','1','6','1','0','+','0','1'};
591 static const BYTE bin32
[] = {
592 0x17,0x0d,'4','5','0','6','0','6','1','6','1','0','-','0','1'};
593 static const BYTE bin33
[] = {
594 0x17,0x0f,'4','5','0','6','0','6','1','6','1','0','+','0','1','0','0'};
595 static const BYTE bin34
[] = {
596 0x17,0x0f,'4','5','0','6','0','6','1','6','1','0','-','0','1','0','0'};
597 static const BYTE bin35
[] = {
598 0x17,0x08, '4','5','0','6','0','6','1','6'};
599 static const BYTE bin36
[] = {
600 0x18,0x0f, 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','Z'};
601 static const BYTE bin37
[] = {
602 0x18,0x04, '2','1','4','5'};
603 static const BYTE bin38
[] = {
604 0x18,0x08, '2','1','4','5','0','6','0','6'};
606 static void test_decodeFiletime(DWORD dwEncoding
)
608 static const struct encodedFiletime otherTimes
[] = {
609 { { 1945, 6, 1, 6, 16, 10, 0, 0 }, bin23
},
610 { { 1945, 6, 1, 6, 16, 10, 0, 999 }, bin24
},
611 { { 1945, 6, 1, 6, 17, 10, 0, 0 }, bin25
},
612 { { 1945, 6, 1, 6, 15, 10, 0, 0 }, bin26
},
613 { { 1945, 6, 1, 6, 14, 55, 0, 0 }, bin27
},
614 { { 2145, 6, 1, 6, 16, 0, 0, 0 }, bin28
},
615 { { 2045, 6, 1, 6, 16, 10, 0, 0 }, bin29
},
616 { { 2045, 6, 1, 6, 16, 10, 0, 0 }, bin30
},
617 { { 2045, 6, 1, 6, 17, 10, 0, 0 }, bin31
},
618 { { 2045, 6, 1, 6, 15, 10, 0, 0 }, bin32
},
619 { { 2045, 6, 1, 6, 17, 10, 0, 0 }, bin33
},
620 { { 2045, 6, 1, 6, 15, 10, 0, 0 }, bin34
},
622 /* An oddball case that succeeds in Windows, but doesn't seem correct
623 { { 2145, 6, 1, 2, 11, 31, 0, 0 }, "\x18" "\x13" "21450606161000-9999" },
625 static const unsigned char *bogusTimes
[] = {
626 /* oddly, this succeeds on Windows, with year 2765
627 "\x18" "\x0f" "21r50606161000Z",
635 FILETIME ft1
= { 0 }, ft2
= { 0 };
638 /* Check bogus length with non-NULL buffer */
639 ret
= SystemTimeToFileTime(×
[0].sysTime
, &ft1
);
640 ok(ret
, "SystemTimeToFileTime failed: %d\n", GetLastError());
642 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CHOICE_OF_TIME
,
643 times
[0].encodedTime
, times
[0].encodedTime
[1] + 2, 0, NULL
, &ft2
, &size
);
644 ok(!ret
&& GetLastError() == ERROR_MORE_DATA
,
645 "Expected ERROR_MORE_DATA, got %d\n", GetLastError());
647 for (i
= 0; i
< sizeof(times
) / sizeof(times
[0]); i
++)
649 testTimeDecoding(dwEncoding
, X509_CHOICE_OF_TIME
, ×
[i
]);
650 testTimeDecoding(dwEncoding
, PKCS_UTC_TIME
, ×
[i
]);
651 testTimeDecoding(dwEncoding
, szOID_RSA_signingTime
, ×
[i
]);
653 for (i
= 0; i
< sizeof(otherTimes
) / sizeof(otherTimes
[0]); i
++)
655 testTimeDecoding(dwEncoding
, X509_CHOICE_OF_TIME
, &otherTimes
[i
]);
656 testTimeDecoding(dwEncoding
, PKCS_UTC_TIME
, &otherTimes
[i
]);
657 testTimeDecoding(dwEncoding
, szOID_RSA_signingTime
, &otherTimes
[i
]);
659 for (i
= 0; i
< sizeof(bogusTimes
) / sizeof(bogusTimes
[0]); i
++)
662 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CHOICE_OF_TIME
,
663 bogusTimes
[i
], bogusTimes
[i
][1] + 2, 0, NULL
, &ft1
, &size
);
664 ok((!ret
&& (GetLastError() == CRYPT_E_ASN1_CORRUPT
||
665 GetLastError() == OSS_DATA_ERROR
/* Win9x */)) ||
666 broken(ret
), /* Win9x and NT4 for bin38 */
667 "Expected CRYPT_E_ASN1_CORRUPT or OSS_DATA_ERROR, got %08x\n",
672 static const char commonName
[] = "Juan Lang";
673 static const char surName
[] = "Lang";
675 static const BYTE emptySequence
[] = { 0x30, 0 };
676 static const BYTE emptyRDNs
[] = { 0x30, 0x02, 0x31, 0 };
677 static const BYTE twoRDNs
[] = {
678 0x30,0x23,0x31,0x21,0x30,0x0c,0x06,0x03,0x55,0x04,0x04,
679 0x13,0x05,0x4c,0x61,0x6e,0x67,0x00,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
680 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0};
681 static const BYTE encodedTwoRDNs
[] = {
682 0x30,0x2e,0x31,0x2c,0x30,0x2a,0x06,0x03,0x55,0x04,0x03,0x30,0x23,0x31,0x21,
683 0x30,0x0c,0x06,0x03,0x55,0x04,0x04,0x13,0x05,0x4c,0x61,0x6e,0x67,0x00,0x30,
684 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
688 static const BYTE us
[] = { 0x55, 0x53 };
689 static const BYTE minnesota
[] = { 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
691 static const BYTE minneapolis
[] = { 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x61, 0x70,
692 0x6f, 0x6c, 0x69, 0x73 };
693 static const BYTE codeweavers
[] = { 0x43, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x61,
694 0x76, 0x65, 0x72, 0x73 };
695 static const BYTE wine
[] = { 0x57, 0x69, 0x6e, 0x65, 0x20, 0x44, 0x65, 0x76,
696 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74 };
697 static const BYTE localhostAttr
[] = { 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x68, 0x6f,
699 static const BYTE aric
[] = { 0x61, 0x72, 0x69, 0x63, 0x40, 0x63, 0x6f, 0x64,
700 0x65, 0x77, 0x65, 0x61, 0x76, 0x65, 0x72, 0x73, 0x2e, 0x63, 0x6f, 0x6d };
702 #define RDNA(arr) oid_ ## arr, CERT_RDN_PRINTABLE_STRING, { sizeof(arr), (LPBYTE)arr }
703 #define RDNIA5(arr) oid_ ## arr, CERT_RDN_IA5_STRING, { sizeof(arr), (LPBYTE)arr }
705 static CHAR oid_us
[] = "2.5.4.6",
706 oid_minnesota
[] = "2.5.4.8",
707 oid_minneapolis
[] = "2.5.4.7",
708 oid_codeweavers
[] = "2.5.4.10",
709 oid_wine
[] = "2.5.4.11",
710 oid_localhostAttr
[] = "2.5.4.3",
711 oid_aric
[] = "1.2.840.113549.1.9.1";
712 static CERT_RDN_ATTR rdnAttrs
[] = { { RDNA(us
) },
714 { RDNA(minneapolis
) },
715 { RDNA(codeweavers
) },
717 { RDNA(localhostAttr
) },
719 static CERT_RDN_ATTR decodedRdnAttrs
[] = { { RDNA(us
) },
720 { RDNA(localhostAttr
) },
722 { RDNA(minneapolis
) },
723 { RDNA(codeweavers
) },
730 static const BYTE encodedRDNAttrs
[] = {
731 0x30,0x81,0x96,0x31,0x81,0x93,0x30,0x09,0x06,0x03,0x55,0x04,0x06,0x13,0x02,0x55,
732 0x53,0x30,0x10,0x06,0x03,0x55,0x04,0x03,0x13,0x09,0x6c,0x6f,0x63,0x61,0x6c,0x68,
733 0x6f,0x73,0x74,0x30,0x10,0x06,0x03,0x55,0x04,0x08,0x13,0x09,0x4d,0x69,0x6e,0x6e,
734 0x65,0x73,0x6f,0x74,0x61,0x30,0x12,0x06,0x03,0x55,0x04,0x07,0x13,0x0b,0x4d,0x69,
735 0x6e,0x6e,0x65,0x61,0x70,0x6f,0x6c,0x69,0x73,0x30,0x12,0x06,0x03,0x55,0x04,0x0a,
736 0x13,0x0b,0x43,0x6f,0x64,0x65,0x57,0x65,0x61,0x76,0x65,0x72,0x73,0x30,0x17,0x06,
737 0x03,0x55,0x04,0x0b,0x13,0x10,0x57,0x69,0x6e,0x65,0x20,0x44,0x65,0x76,0x65,0x6c,
738 0x6f,0x70,0x6d,0x65,0x6e,0x74,0x30,0x21,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,
739 0x01,0x09,0x01,0x16,0x14,0x61,0x72,0x69,0x63,0x40,0x63,0x6f,0x64,0x65,0x77,0x65,
740 0x61,0x76,0x65,0x72,0x73,0x2e,0x63,0x6f,0x6d
743 static void test_encodeName(DWORD dwEncoding
)
745 CERT_RDN_ATTR attrs
[2];
748 static CHAR oid_common_name
[] = szOID_COMMON_NAME
,
749 oid_sur_name
[] = szOID_SUR_NAME
;
756 /* Test with NULL pvStructInfo (crashes on win9x) */
757 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME
, NULL
,
758 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
759 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
760 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
762 /* Test with empty CERT_NAME_INFO */
765 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME
, &info
,
766 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
767 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
770 ok(!memcmp(buf
, emptySequence
, sizeof(emptySequence
)),
771 "Got unexpected encoding for empty name\n");
776 /* Test with bogus CERT_RDN (crashes on win9x) */
778 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME
, &info
,
779 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
780 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
781 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
783 /* Test with empty CERT_RDN */
785 rdn
.rgRDNAttr
= NULL
;
788 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME
, &info
,
789 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
790 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
793 ok(!memcmp(buf
, emptyRDNs
, sizeof(emptyRDNs
)),
794 "Got unexpected encoding for empty RDN array\n");
799 /* Test with bogus attr array (crashes on win9x) */
801 rdn
.rgRDNAttr
= NULL
;
802 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME
, &info
,
803 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
804 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
805 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
807 /* oddly, a bogus OID is accepted by Windows XP; not testing.
808 attrs[0].pszObjId = "bogus";
809 attrs[0].dwValueType = CERT_RDN_PRINTABLE_STRING;
810 attrs[0].Value.cbData = sizeof(commonName);
811 attrs[0].Value.pbData = commonName;
813 rdn.rgRDNAttr = attrs;
814 ret = pCryptEncodeObjectEx(dwEncoding, X509_NAME, &info,
815 CRYPT_ENCODE_ALLOC_FLAG, NULL, &buf, &size);
816 ok(!ret, "Expected failure, got success\n");
818 /* Check with two CERT_RDN_ATTRs. Note DER encoding forces the order of
819 * the encoded attributes to be swapped.
821 attrs
[0].pszObjId
= oid_common_name
;
822 attrs
[0].dwValueType
= CERT_RDN_PRINTABLE_STRING
;
823 attrs
[0].Value
.cbData
= sizeof(commonName
);
824 attrs
[0].Value
.pbData
= (BYTE
*)commonName
;
825 attrs
[1].pszObjId
= oid_sur_name
;
826 attrs
[1].dwValueType
= CERT_RDN_PRINTABLE_STRING
;
827 attrs
[1].Value
.cbData
= sizeof(surName
);
828 attrs
[1].Value
.pbData
= (BYTE
*)surName
;
830 rdn
.rgRDNAttr
= attrs
;
831 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME
, &info
,
832 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
833 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
836 ok(!memcmp(buf
, twoRDNs
, sizeof(twoRDNs
)),
837 "Got unexpected encoding for two RDN array\n");
840 /* A name can be "encoded" with previously encoded RDN attrs. */
841 attrs
[0].dwValueType
= CERT_RDN_ENCODED_BLOB
;
842 attrs
[0].Value
.pbData
= (LPBYTE
)twoRDNs
;
843 attrs
[0].Value
.cbData
= sizeof(twoRDNs
);
845 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME
, &info
,
846 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
847 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
850 ok(size
== sizeof(encodedTwoRDNs
), "Unexpected size %d\n", size
);
851 ok(!memcmp(buf
, encodedTwoRDNs
, size
),
852 "Unexpected value for re-endoded two RDN array\n");
855 /* CERT_RDN_ANY_TYPE is too vague for X509_NAMEs, check the return */
857 attrs
[0].dwValueType
= CERT_RDN_ANY_TYPE
;
858 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME
, &info
,
859 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
860 ok(!ret
&& GetLastError() == E_INVALIDARG
,
861 "Expected E_INVALIDARG, got %08x\n", GetLastError());
862 /* Test a more complex name */
863 rdn
.cRDNAttr
= sizeof(rdnAttrs
) / sizeof(rdnAttrs
[0]);
864 rdn
.rgRDNAttr
= rdnAttrs
;
869 ret
= pCryptEncodeObjectEx(X509_ASN_ENCODING
, X509_NAME
, &info
,
870 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
871 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
874 ok(size
== sizeof(encodedRDNAttrs
), "Wrong size %d\n", size
);
875 ok(!memcmp(buf
, encodedRDNAttrs
, size
), "Unexpected value\n");
880 static WCHAR commonNameW
[] = { 'J','u','a','n',' ','L','a','n','g',0 };
881 static WCHAR surNameW
[] = { 'L','a','n','g',0 };
883 static const BYTE twoRDNsNoNull
[] = {
884 0x30,0x21,0x31,0x1f,0x30,0x0b,0x06,0x03,0x55,0x04,0x04,0x13,0x04,0x4c,0x61,
885 0x6e,0x67,0x30,0x10,0x06,0x03,0x55,0x04,0x03,0x13,0x09,0x4a,0x75,0x61,0x6e,
886 0x20,0x4c,0x61,0x6e,0x67 };
887 static const BYTE anyType
[] = {
888 0x30,0x2f,0x31,0x2d,0x30,0x2b,0x06,0x03,0x55,0x04,0x03,0x1e,0x24,0x23,0x30,
889 0x21,0x31,0x0c,0x30,0x03,0x06,0x04,0x55,0x13,0x04,0x4c,0x05,0x6e,0x61,0x00,
890 0x67,0x11,0x30,0x03,0x06,0x04,0x55,0x13,0x03,0x4a,0x0a,0x61,0x75,0x20,0x6e,
891 0x61,0x4c,0x67,0x6e };
893 static void test_encodeUnicodeName(DWORD dwEncoding
)
895 CERT_RDN_ATTR attrs
[2];
898 static CHAR oid_common_name
[] = szOID_COMMON_NAME
,
899 oid_sur_name
[] = szOID_SUR_NAME
;
906 /* Test with NULL pvStructInfo (crashes on win9x) */
907 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME
, NULL
,
908 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
909 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
910 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
912 /* Test with empty CERT_NAME_INFO */
915 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME
, &info
,
916 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
917 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
920 ok(!memcmp(buf
, emptySequence
, sizeof(emptySequence
)),
921 "Got unexpected encoding for empty name\n");
924 /* Check with one CERT_RDN_ATTR, that has an invalid character for the
925 * encoding (the NULL).
927 attrs
[0].pszObjId
= oid_common_name
;
928 attrs
[0].dwValueType
= CERT_RDN_PRINTABLE_STRING
;
929 attrs
[0].Value
.cbData
= sizeof(commonNameW
);
930 attrs
[0].Value
.pbData
= (BYTE
*)commonNameW
;
932 rdn
.rgRDNAttr
= attrs
;
935 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME
, &info
,
936 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
937 ok(!ret
&& GetLastError() == CRYPT_E_INVALID_PRINTABLE_STRING
,
938 "Expected CRYPT_E_INVALID_PRINTABLE_STRING, got %08x\n", GetLastError());
939 ok(size
== 9, "Unexpected error index %08x\n", size
);
940 /* Check with two NULL-terminated CERT_RDN_ATTRs. Note DER encoding
941 * forces the order of the encoded attributes to be swapped.
943 attrs
[0].pszObjId
= oid_common_name
;
944 attrs
[0].dwValueType
= CERT_RDN_PRINTABLE_STRING
;
945 attrs
[0].Value
.cbData
= 0;
946 attrs
[0].Value
.pbData
= (BYTE
*)commonNameW
;
947 attrs
[1].pszObjId
= oid_sur_name
;
948 attrs
[1].dwValueType
= CERT_RDN_PRINTABLE_STRING
;
949 attrs
[1].Value
.cbData
= 0;
950 attrs
[1].Value
.pbData
= (BYTE
*)surNameW
;
952 rdn
.rgRDNAttr
= attrs
;
955 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME
, &info
,
956 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
957 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
960 ok(!memcmp(buf
, twoRDNsNoNull
, sizeof(twoRDNsNoNull
)),
961 "Got unexpected encoding for two RDN array\n");
964 /* A name can be "encoded" with previously encoded RDN attrs. */
965 attrs
[0].dwValueType
= CERT_RDN_ENCODED_BLOB
;
966 attrs
[0].Value
.pbData
= (LPBYTE
)twoRDNs
;
967 attrs
[0].Value
.cbData
= sizeof(twoRDNs
);
969 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME
, &info
,
970 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
971 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
974 ok(size
== sizeof(encodedTwoRDNs
), "Unexpected size %d\n", size
);
975 ok(!memcmp(buf
, encodedTwoRDNs
, size
),
976 "Unexpected value for re-endoded two RDN array\n");
979 /* Unicode names infer the type for CERT_RDN_ANY_TYPE */
981 attrs
[0].dwValueType
= CERT_RDN_ANY_TYPE
;
982 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME
, &info
,
983 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
984 todo_wine
ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
987 ok(size
== sizeof(anyType
), "Unexpected size %d\n", size
);
988 ok(!memcmp(buf
, anyType
, size
), "Unexpected value\n");
993 static void compareNameValues(const CERT_NAME_VALUE
*expected
,
994 const CERT_NAME_VALUE
*got
)
996 if (expected
->dwValueType
== CERT_RDN_UTF8_STRING
&&
997 got
->dwValueType
== CERT_RDN_ENCODED_BLOB
)
999 win_skip("Can't handle CERT_RDN_UTF8_STRING\n");
1003 ok(got
->dwValueType
== expected
->dwValueType
,
1004 "Expected string type %d, got %d\n", expected
->dwValueType
,
1006 ok(got
->Value
.cbData
== expected
->Value
.cbData
,
1007 "String type %d: unexpected data size, got %d, expected %d\n",
1008 expected
->dwValueType
, got
->Value
.cbData
, expected
->Value
.cbData
);
1009 if (got
->Value
.cbData
&& got
->Value
.pbData
)
1010 ok(!memcmp(got
->Value
.pbData
, expected
->Value
.pbData
,
1011 min(got
->Value
.cbData
, expected
->Value
.cbData
)),
1012 "String type %d: unexpected value\n", expected
->dwValueType
);
1015 static void compareRDNAttrs(const CERT_RDN_ATTR
*expected
,
1016 const CERT_RDN_ATTR
*got
)
1018 if (expected
->pszObjId
&& strlen(expected
->pszObjId
))
1020 ok(got
->pszObjId
!= NULL
, "Expected OID %s, got NULL\n",
1021 expected
->pszObjId
);
1024 ok(!strcmp(got
->pszObjId
, expected
->pszObjId
),
1025 "Got unexpected OID %s, expected %s\n", got
->pszObjId
,
1026 expected
->pszObjId
);
1029 compareNameValues((const CERT_NAME_VALUE
*)&expected
->dwValueType
,
1030 (const CERT_NAME_VALUE
*)&got
->dwValueType
);
1033 static void compareRDNs(const CERT_RDN
*expected
, const CERT_RDN
*got
)
1035 ok(got
->cRDNAttr
== expected
->cRDNAttr
,
1036 "Expected %d RDN attrs, got %d\n", expected
->cRDNAttr
, got
->cRDNAttr
);
1041 for (i
= 0; i
< got
->cRDNAttr
; i
++)
1042 compareRDNAttrs(&expected
->rgRDNAttr
[i
], &got
->rgRDNAttr
[i
]);
1046 static void compareNames(const CERT_NAME_INFO
*expected
,
1047 const CERT_NAME_INFO
*got
)
1049 ok(got
->cRDN
== expected
->cRDN
, "Expected %d RDNs, got %d\n",
1050 expected
->cRDN
, got
->cRDN
);
1055 for (i
= 0; i
< got
->cRDN
; i
++)
1056 compareRDNs(&expected
->rgRDN
[i
], &got
->rgRDN
[i
]);
1060 static const BYTE emptyIndefiniteSequence
[] = { 0x30,0x80,0x00,0x00 };
1061 static const BYTE twoRDNsExtraBytes
[] = {
1062 0x30,0x23,0x31,0x21,0x30,0x0c,0x06,0x03,0x55,0x04,0x04,
1063 0x13,0x05,0x4c,0x61,0x6e,0x67,0x00,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
1064 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0,0,0,0,0,0};
1066 static void test_decodeName(DWORD dwEncoding
)
1072 CERT_NAME_INFO info
= { 1, &rdn
};
1074 /* test empty name */
1076 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_NAME
, emptySequence
,
1077 emptySequence
[1] + 2,
1078 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_SHARE_OID_STRING_FLAG
, NULL
,
1080 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1081 /* Interestingly, in Windows, if cRDN is 0, rgRGN may not be NULL. My
1082 * decoder works the same way, so only test the count.
1086 ok(bufSize
== sizeof(CERT_NAME_INFO
), "Wrong bufSize %d\n", bufSize
);
1087 ok(((CERT_NAME_INFO
*)buf
)->cRDN
== 0,
1088 "Expected 0 RDNs in empty info, got %d\n",
1089 ((CERT_NAME_INFO
*)buf
)->cRDN
);
1092 /* test empty name with indefinite-length encoding */
1093 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_NAME
, emptyIndefiniteSequence
,
1094 sizeof(emptyIndefiniteSequence
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
1096 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1099 ok(bufSize
== sizeof(CERT_NAME_INFO
), "Wrong bufSize %d\n", bufSize
);
1100 ok(((CERT_NAME_INFO
*)buf
)->cRDN
== 0,
1101 "Expected 0 RDNs in empty info, got %d\n",
1102 ((CERT_NAME_INFO
*)buf
)->cRDN
);
1105 /* test empty RDN */
1107 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_NAME
, emptyRDNs
,
1109 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_SHARE_OID_STRING_FLAG
, NULL
,
1111 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1114 CERT_NAME_INFO
*info
= (CERT_NAME_INFO
*)buf
;
1116 ok(bufSize
== sizeof(CERT_NAME_INFO
) + sizeof(CERT_RDN
) &&
1117 info
->cRDN
== 1 && info
->rgRDN
&& info
->rgRDN
[0].cRDNAttr
== 0,
1118 "Got unexpected value for empty RDN\n");
1121 /* test two RDN attrs */
1123 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_NAME
, twoRDNs
,
1125 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_SHARE_OID_STRING_FLAG
, NULL
,
1127 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1130 static CHAR oid_sur_name
[] = szOID_SUR_NAME
,
1131 oid_common_name
[] = szOID_COMMON_NAME
;
1133 CERT_RDN_ATTR attrs
[] = {
1134 { oid_sur_name
, CERT_RDN_PRINTABLE_STRING
, { sizeof(surName
),
1135 (BYTE
*)surName
} },
1136 { oid_common_name
, CERT_RDN_PRINTABLE_STRING
, { sizeof(commonName
),
1137 (BYTE
*)commonName
} },
1140 rdn
.cRDNAttr
= sizeof(attrs
) / sizeof(attrs
[0]);
1141 rdn
.rgRDNAttr
= attrs
;
1142 compareNames(&info
, (CERT_NAME_INFO
*)buf
);
1145 /* test that two RDN attrs with extra bytes succeeds */
1147 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_NAME
, twoRDNsExtraBytes
,
1148 sizeof(twoRDNsExtraBytes
), 0, NULL
, NULL
, &bufSize
);
1149 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1150 /* And, a slightly more complicated name */
1153 ret
= pCryptDecodeObjectEx(X509_ASN_ENCODING
, X509_NAME
, encodedRDNAttrs
,
1154 sizeof(encodedRDNAttrs
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
1155 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1158 rdn
.cRDNAttr
= sizeof(decodedRdnAttrs
) / sizeof(decodedRdnAttrs
[0]);
1159 rdn
.rgRDNAttr
= decodedRdnAttrs
;
1160 compareNames(&info
, (CERT_NAME_INFO
*)buf
);
1165 static void test_decodeUnicodeName(DWORD dwEncoding
)
1171 CERT_NAME_INFO info
= { 1, &rdn
};
1173 /* test empty name */
1175 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_UNICODE_NAME
, emptySequence
,
1176 emptySequence
[1] + 2,
1177 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_SHARE_OID_STRING_FLAG
, NULL
,
1179 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1182 ok(bufSize
== sizeof(CERT_NAME_INFO
),
1183 "Got wrong bufSize %d\n", bufSize
);
1184 ok(((CERT_NAME_INFO
*)buf
)->cRDN
== 0,
1185 "Expected 0 RDNs in empty info, got %d\n",
1186 ((CERT_NAME_INFO
*)buf
)->cRDN
);
1189 /* test empty RDN */
1191 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_UNICODE_NAME
, emptyRDNs
,
1193 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_SHARE_OID_STRING_FLAG
, NULL
,
1195 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1198 CERT_NAME_INFO
*info
= (CERT_NAME_INFO
*)buf
;
1200 ok(bufSize
== sizeof(CERT_NAME_INFO
) + sizeof(CERT_RDN
) &&
1201 info
->cRDN
== 1 && info
->rgRDN
&& info
->rgRDN
[0].cRDNAttr
== 0,
1202 "Got unexpected value for empty RDN\n");
1205 /* test two RDN attrs */
1207 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_UNICODE_NAME
, twoRDNsNoNull
,
1208 sizeof(twoRDNsNoNull
),
1209 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_SHARE_OID_STRING_FLAG
, NULL
,
1211 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1214 static CHAR oid_sur_name
[] = szOID_SUR_NAME
,
1215 oid_common_name
[] = szOID_COMMON_NAME
;
1217 CERT_RDN_ATTR attrs
[] = {
1218 { oid_sur_name
, CERT_RDN_PRINTABLE_STRING
,
1219 { lstrlenW(surNameW
) * sizeof(WCHAR
), (BYTE
*)surNameW
} },
1220 { oid_common_name
, CERT_RDN_PRINTABLE_STRING
,
1221 { lstrlenW(commonNameW
) * sizeof(WCHAR
), (BYTE
*)commonNameW
} },
1224 rdn
.cRDNAttr
= sizeof(attrs
) / sizeof(attrs
[0]);
1225 rdn
.rgRDNAttr
= attrs
;
1226 compareNames(&info
, (CERT_NAME_INFO
*)buf
);
1231 struct EncodedNameValue
1233 CERT_NAME_VALUE value
;
1234 const BYTE
*encoded
;
1238 static const char bogusIA5
[] = "\x80";
1239 static const char bogusPrintable
[] = "~";
1240 static const char bogusNumeric
[] = "A";
1241 static const BYTE bin42
[] = { 0x16,0x02,0x80,0x00 };
1242 static const BYTE bin43
[] = { 0x13,0x02,0x7e,0x00 };
1243 static const BYTE bin44
[] = { 0x12,0x02,0x41,0x00 };
1244 static BYTE octetCommonNameValue
[] = {
1245 0x04,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1246 static BYTE numericCommonNameValue
[] = {
1247 0x12,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1248 static BYTE printableCommonNameValue
[] = {
1249 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1250 static BYTE t61CommonNameValue
[] = {
1251 0x14,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1252 static BYTE videotexCommonNameValue
[] = {
1253 0x15,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1254 static BYTE ia5CommonNameValue
[] = {
1255 0x16,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1256 static BYTE graphicCommonNameValue
[] = {
1257 0x19,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1258 static BYTE visibleCommonNameValue
[] = {
1259 0x1a,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1260 static BYTE generalCommonNameValue
[] = {
1261 0x1b,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1262 static BYTE bmpCommonNameValue
[] = {
1263 0x1e,0x14,0x00,0x4a,0x00,0x75,0x00,0x61,0x00,0x6e,0x00,0x20,0x00,0x4c,0x00,
1264 0x61,0x00,0x6e,0x00,0x67,0x00,0x00 };
1265 static BYTE utf8CommonNameValue
[] = {
1266 0x0c,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1268 static struct EncodedNameValue nameValues
[] = {
1269 { { CERT_RDN_OCTET_STRING
, { sizeof(commonName
), (BYTE
*)commonName
} },
1270 octetCommonNameValue
, sizeof(octetCommonNameValue
) },
1271 { { CERT_RDN_NUMERIC_STRING
, { sizeof(commonName
), (BYTE
*)commonName
} },
1272 numericCommonNameValue
, sizeof(numericCommonNameValue
) },
1273 { { CERT_RDN_PRINTABLE_STRING
, { sizeof(commonName
), (BYTE
*)commonName
} },
1274 printableCommonNameValue
, sizeof(printableCommonNameValue
) },
1275 { { CERT_RDN_T61_STRING
, { sizeof(commonName
), (BYTE
*)commonName
} },
1276 t61CommonNameValue
, sizeof(t61CommonNameValue
) },
1277 { { CERT_RDN_VIDEOTEX_STRING
, { sizeof(commonName
), (BYTE
*)commonName
} },
1278 videotexCommonNameValue
, sizeof(videotexCommonNameValue
) },
1279 { { CERT_RDN_IA5_STRING
, { sizeof(commonName
), (BYTE
*)commonName
} },
1280 ia5CommonNameValue
, sizeof(ia5CommonNameValue
) },
1281 { { CERT_RDN_GRAPHIC_STRING
, { sizeof(commonName
), (BYTE
*)commonName
} },
1282 graphicCommonNameValue
, sizeof(graphicCommonNameValue
) },
1283 { { CERT_RDN_VISIBLE_STRING
, { sizeof(commonName
), (BYTE
*)commonName
} },
1284 visibleCommonNameValue
, sizeof(visibleCommonNameValue
) },
1285 { { CERT_RDN_GENERAL_STRING
, { sizeof(commonName
), (BYTE
*)commonName
} },
1286 generalCommonNameValue
, sizeof(generalCommonNameValue
) },
1287 { { CERT_RDN_BMP_STRING
, { sizeof(commonNameW
), (BYTE
*)commonNameW
} },
1288 bmpCommonNameValue
, sizeof(bmpCommonNameValue
) },
1289 { { CERT_RDN_UTF8_STRING
, { sizeof(commonNameW
), (BYTE
*)commonNameW
} },
1290 utf8CommonNameValue
, sizeof(utf8CommonNameValue
) },
1291 /* The following tests succeed under Windows, but really should fail,
1292 * they contain characters that are illegal for the encoding. I'm
1293 * including them to justify my lazy encoding.
1295 { { CERT_RDN_IA5_STRING
, { sizeof(bogusIA5
), (BYTE
*)bogusIA5
} }, bin42
,
1297 { { CERT_RDN_PRINTABLE_STRING
, { sizeof(bogusPrintable
),
1298 (BYTE
*)bogusPrintable
} }, bin43
, sizeof(bin43
) },
1299 { { CERT_RDN_NUMERIC_STRING
, { sizeof(bogusNumeric
), (BYTE
*)bogusNumeric
} },
1300 bin44
, sizeof(bin44
) },
1303 static void test_encodeNameValue(DWORD dwEncoding
)
1308 CERT_NAME_VALUE value
= { 0, { 0, NULL
} };
1310 value
.dwValueType
= CERT_RDN_ENCODED_BLOB
;
1311 value
.Value
.pbData
= printableCommonNameValue
;
1312 value
.Value
.cbData
= sizeof(printableCommonNameValue
);
1313 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME_VALUE
, &value
,
1314 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1315 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
1318 ok(size
== sizeof(printableCommonNameValue
), "Unexpected size %d\n",
1320 ok(!memcmp(buf
, printableCommonNameValue
, size
),
1321 "Unexpected encoding\n");
1324 for (i
= 0; i
< sizeof(nameValues
) / sizeof(nameValues
[0]); i
++)
1326 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME_VALUE
,
1327 &nameValues
[i
].value
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1328 ok(ret
|| broken(GetLastError() == OSS_PDU_MISMATCH
) /* NT4/Win9x */,
1329 "Type %d: CryptEncodeObjectEx failed: %08x\n",
1330 nameValues
[i
].value
.dwValueType
, GetLastError());
1333 ok(size
== nameValues
[i
].encodedSize
,
1334 "Expected size %d, got %d\n", nameValues
[i
].encodedSize
, size
);
1335 ok(!memcmp(buf
, nameValues
[i
].encoded
, size
),
1336 "Got unexpected encoding\n");
1342 static void test_decodeNameValue(DWORD dwEncoding
)
1349 for (i
= 0; i
< sizeof(nameValues
) / sizeof(nameValues
[0]); i
++)
1351 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_NAME_VALUE
,
1352 nameValues
[i
].encoded
, nameValues
[i
].encoded
[1] + 2,
1353 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_SHARE_OID_STRING_FLAG
, NULL
,
1355 ok(ret
, "Value type %d: CryptDecodeObjectEx failed: %08x\n",
1356 nameValues
[i
].value
.dwValueType
, GetLastError());
1359 compareNameValues(&nameValues
[i
].value
,
1360 (const CERT_NAME_VALUE
*)buf
);
1366 static const BYTE emptyURL
[] = { 0x30, 0x02, 0x86, 0x00 };
1367 static const BYTE emptyURLExtraBytes
[] = { 0x30, 0x02, 0x86, 0x00, 0, 0, 0 };
1368 static const WCHAR url
[] = { 'h','t','t','p',':','/','/','w','i','n','e',
1369 'h','q','.','o','r','g',0 };
1370 static const BYTE encodedURL
[] = { 0x30, 0x13, 0x86, 0x11, 0x68, 0x74,
1371 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x69, 0x6e, 0x65, 0x68, 0x71, 0x2e,
1373 static const WCHAR nihongoURL
[] = { 'h','t','t','p',':','/','/',0x226f,
1375 static const WCHAR dnsName
[] = { 'w','i','n','e','h','q','.','o','r','g',0 };
1376 static const BYTE encodedDnsName
[] = { 0x30, 0x0c, 0x82, 0x0a, 0x77, 0x69,
1377 0x6e, 0x65, 0x68, 0x71, 0x2e, 0x6f, 0x72, 0x67 };
1378 static const BYTE localhost
[] = { 127, 0, 0, 1 };
1379 static const BYTE encodedIPAddr
[] = { 0x30, 0x06, 0x87, 0x04, 0x7f, 0x00, 0x00,
1381 static const unsigned char encodedCommonName
[] = {
1382 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,'J','u','a','n',' ','L','a','n','g',0};
1383 static const BYTE encodedOidName
[] = { 0x30,0x04,0x88,0x02,0x2a,0x03 };
1384 static const BYTE encodedDirectoryName
[] = {
1385 0x30,0x19,0xa4,0x17,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
1386 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1388 static void test_encodeAltName(DWORD dwEncoding
)
1390 CERT_ALT_NAME_INFO info
= { 0 };
1391 CERT_ALT_NAME_ENTRY entry
= { 0 };
1395 char oid
[] = "1.2.3";
1397 /* Test with empty info */
1398 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, &info
,
1399 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1402 ok(size
== sizeof(emptySequence
), "Wrong size %d\n", size
);
1403 ok(!memcmp(buf
, emptySequence
, size
), "Unexpected value\n");
1406 /* Test with an empty entry */
1408 info
.rgAltEntry
= &entry
;
1409 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, &info
,
1410 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1411 ok(!ret
&& GetLastError() == E_INVALIDARG
,
1412 "Expected E_INVALIDARG, got %08x\n", GetLastError());
1413 /* Test with an empty pointer */
1414 entry
.dwAltNameChoice
= CERT_ALT_NAME_URL
;
1415 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, &info
,
1416 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1419 ok(size
== sizeof(emptyURL
), "Wrong size %d\n", size
);
1420 ok(!memcmp(buf
, emptyURL
, size
), "Unexpected value\n");
1423 /* Test with a real URL */
1424 U(entry
).pwszURL
= (LPWSTR
)url
;
1425 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, &info
,
1426 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1429 ok(size
== sizeof(encodedURL
), "Wrong size %d\n", size
);
1430 ok(!memcmp(buf
, encodedURL
, size
), "Unexpected value\n");
1433 /* Now with the URL containing an invalid IA5 char */
1434 U(entry
).pwszURL
= (LPWSTR
)nihongoURL
;
1435 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, &info
,
1436 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1437 ok(!ret
&& GetLastError() == CRYPT_E_INVALID_IA5_STRING
,
1438 "Expected CRYPT_E_INVALID_IA5_STRING, got %08x\n", GetLastError());
1439 /* The first invalid character is at index 7 */
1440 ok(GET_CERT_ALT_NAME_VALUE_ERR_INDEX(size
) == 7,
1441 "Expected invalid char at index 7, got %d\n",
1442 GET_CERT_ALT_NAME_VALUE_ERR_INDEX(size
));
1443 /* Now with the URL missing a scheme */
1444 U(entry
).pwszURL
= (LPWSTR
)dnsName
;
1445 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, &info
,
1446 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1447 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
1450 /* This succeeds, but it shouldn't, so don't worry about conforming */
1453 /* Now with a DNS name */
1454 entry
.dwAltNameChoice
= CERT_ALT_NAME_DNS_NAME
;
1455 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, &info
,
1456 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1457 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
1460 ok(size
== sizeof(encodedDnsName
), "Wrong size %d\n", size
);
1461 ok(!memcmp(buf
, encodedDnsName
, size
), "Unexpected value\n");
1464 /* Test with an IP address */
1465 entry
.dwAltNameChoice
= CERT_ALT_NAME_IP_ADDRESS
;
1466 U(entry
).IPAddress
.cbData
= sizeof(localhost
);
1467 U(entry
).IPAddress
.pbData
= (LPBYTE
)localhost
;
1468 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, &info
,
1469 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1472 ok(size
== sizeof(encodedIPAddr
), "Wrong size %d\n", size
);
1473 ok(!memcmp(buf
, encodedIPAddr
, size
), "Unexpected value\n");
1477 entry
.dwAltNameChoice
= CERT_ALT_NAME_REGISTERED_ID
;
1478 U(entry
).pszRegisteredID
= oid
;
1479 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, &info
,
1480 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1483 ok(size
== sizeof(encodedOidName
), "Wrong size %d\n", size
);
1484 ok(!memcmp(buf
, encodedOidName
, size
), "Unexpected value\n");
1487 /* Test with directory name */
1488 entry
.dwAltNameChoice
= CERT_ALT_NAME_DIRECTORY_NAME
;
1489 U(entry
).DirectoryName
.cbData
= sizeof(encodedCommonName
);
1490 U(entry
).DirectoryName
.pbData
= (LPBYTE
)encodedCommonName
;
1491 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, &info
,
1492 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1495 ok(size
== sizeof(encodedDirectoryName
), "Wrong size %d\n", size
);
1496 ok(!memcmp(buf
, encodedDirectoryName
, size
), "Unexpected value\n");
1501 static void test_decodeAltName(DWORD dwEncoding
)
1503 static const BYTE unimplementedType
[] = { 0x30, 0x06, 0x85, 0x04, 0x7f,
1505 static const BYTE bogusType
[] = { 0x30, 0x06, 0x89, 0x04, 0x7f, 0x00, 0x00,
1510 CERT_ALT_NAME_INFO
*info
;
1512 /* Test some bogus ones first */
1513 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
,
1514 unimplementedType
, sizeof(unimplementedType
), CRYPT_DECODE_ALLOC_FLAG
,
1515 NULL
, &buf
, &bufSize
);
1516 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_BADTAG
||
1517 GetLastError() == OSS_DATA_ERROR
/* Win9x */),
1518 "Expected CRYPT_E_ASN1_BADTAG or OSS_DATA_ERROR, got %08x\n",
1520 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
,
1521 bogusType
, sizeof(bogusType
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
,
1523 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_CORRUPT
||
1524 GetLastError() == OSS_DATA_ERROR
/* Win9x */),
1525 "Expected CRYPT_E_ASN1_CORRUPT or OSS_DATA_ERROR, got %08x\n",
1527 /* Now expected cases */
1528 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, emptySequence
,
1529 emptySequence
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
1530 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1533 info
= (CERT_ALT_NAME_INFO
*)buf
;
1535 ok(info
->cAltEntry
== 0, "Expected 0 entries, got %d\n",
1539 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, emptyURL
,
1540 emptyURL
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
1541 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1544 info
= (CERT_ALT_NAME_INFO
*)buf
;
1546 ok(info
->cAltEntry
== 1, "Expected 1 entries, got %d\n",
1548 ok(info
->rgAltEntry
[0].dwAltNameChoice
== CERT_ALT_NAME_URL
,
1549 "Expected CERT_ALT_NAME_URL, got %d\n",
1550 info
->rgAltEntry
[0].dwAltNameChoice
);
1551 ok(U(info
->rgAltEntry
[0]).pwszURL
== NULL
|| !*U(info
->rgAltEntry
[0]).pwszURL
,
1552 "Expected empty URL\n");
1555 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
,
1556 emptyURLExtraBytes
, sizeof(emptyURLExtraBytes
), 0, NULL
, NULL
, &bufSize
);
1557 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1558 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, encodedURL
,
1559 encodedURL
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
1560 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1563 info
= (CERT_ALT_NAME_INFO
*)buf
;
1565 ok(info
->cAltEntry
== 1, "Expected 1 entries, got %d\n",
1567 ok(info
->rgAltEntry
[0].dwAltNameChoice
== CERT_ALT_NAME_URL
,
1568 "Expected CERT_ALT_NAME_URL, got %d\n",
1569 info
->rgAltEntry
[0].dwAltNameChoice
);
1570 ok(!lstrcmpW(U(info
->rgAltEntry
[0]).pwszURL
, url
), "Unexpected URL\n");
1573 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, encodedDnsName
,
1574 encodedDnsName
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
1575 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1578 info
= (CERT_ALT_NAME_INFO
*)buf
;
1580 ok(info
->cAltEntry
== 1, "Expected 1 entries, got %d\n",
1582 ok(info
->rgAltEntry
[0].dwAltNameChoice
== CERT_ALT_NAME_DNS_NAME
,
1583 "Expected CERT_ALT_NAME_DNS_NAME, got %d\n",
1584 info
->rgAltEntry
[0].dwAltNameChoice
);
1585 ok(!lstrcmpW(U(info
->rgAltEntry
[0]).pwszDNSName
, dnsName
),
1586 "Unexpected DNS name\n");
1589 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, encodedIPAddr
,
1590 encodedIPAddr
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
1591 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1594 info
= (CERT_ALT_NAME_INFO
*)buf
;
1596 ok(info
->cAltEntry
== 1, "Expected 1 entries, got %d\n",
1598 ok(info
->rgAltEntry
[0].dwAltNameChoice
== CERT_ALT_NAME_IP_ADDRESS
,
1599 "Expected CERT_ALT_NAME_IP_ADDRESS, got %d\n",
1600 info
->rgAltEntry
[0].dwAltNameChoice
);
1601 ok(U(info
->rgAltEntry
[0]).IPAddress
.cbData
== sizeof(localhost
),
1602 "Unexpected IP address length %d\n",
1603 U(info
->rgAltEntry
[0]).IPAddress
.cbData
);
1604 ok(!memcmp(U(info
->rgAltEntry
[0]).IPAddress
.pbData
, localhost
,
1605 sizeof(localhost
)), "Unexpected IP address value\n");
1608 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
, encodedOidName
,
1609 sizeof(encodedOidName
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
1610 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1613 info
= (CERT_ALT_NAME_INFO
*)buf
;
1615 ok(info
->cAltEntry
== 1, "Expected 1 entries, got %d\n",
1617 ok(info
->rgAltEntry
[0].dwAltNameChoice
== CERT_ALT_NAME_REGISTERED_ID
,
1618 "Expected CERT_ALT_NAME_REGISTERED_ID, got %d\n",
1619 info
->rgAltEntry
[0].dwAltNameChoice
);
1620 ok(!strcmp(U(info
->rgAltEntry
[0]).pszRegisteredID
, "1.2.3"),
1621 "Expected OID 1.2.3, got %s\n", U(info
->rgAltEntry
[0]).pszRegisteredID
);
1624 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ALTERNATE_NAME
,
1625 encodedDirectoryName
, sizeof(encodedDirectoryName
),
1626 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
1627 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1630 info
= (CERT_ALT_NAME_INFO
*)buf
;
1632 ok(info
->cAltEntry
== 1, "Expected 1 entries, got %d\n",
1634 ok(info
->rgAltEntry
[0].dwAltNameChoice
== CERT_ALT_NAME_DIRECTORY_NAME
,
1635 "Expected CERT_ALT_NAME_DIRECTORY_NAME, got %d\n",
1636 info
->rgAltEntry
[0].dwAltNameChoice
);
1637 ok(U(info
->rgAltEntry
[0]).DirectoryName
.cbData
==
1638 sizeof(encodedCommonName
), "Unexpected directory name length %d\n",
1639 U(info
->rgAltEntry
[0]).DirectoryName
.cbData
);
1640 ok(!memcmp(U(info
->rgAltEntry
[0]).DirectoryName
.pbData
,
1641 encodedCommonName
, sizeof(encodedCommonName
)),
1642 "Unexpected directory name value\n");
1647 struct UnicodeExpectedError
1655 static const WCHAR oneW
[] = { '1',0 };
1656 static const WCHAR aW
[] = { 'a',0 };
1657 static const WCHAR quoteW
[] = { '"', 0 };
1659 static struct UnicodeExpectedError unicodeErrors
[] = {
1660 { CERT_RDN_ANY_TYPE
, oneW
, 0, CRYPT_E_NOT_CHAR_STRING
},
1661 { CERT_RDN_ENCODED_BLOB
, oneW
, 0, CRYPT_E_NOT_CHAR_STRING
},
1662 { CERT_RDN_OCTET_STRING
, oneW
, 0, CRYPT_E_NOT_CHAR_STRING
},
1663 { CERT_RDN_NUMERIC_STRING
, aW
, 0, CRYPT_E_INVALID_NUMERIC_STRING
},
1664 { CERT_RDN_PRINTABLE_STRING
, quoteW
, 0, CRYPT_E_INVALID_PRINTABLE_STRING
},
1665 { CERT_RDN_IA5_STRING
, nihongoURL
, 7, CRYPT_E_INVALID_IA5_STRING
},
1668 struct UnicodeExpectedResult
1672 CRYPT_DATA_BLOB encoded
;
1675 static BYTE oneNumeric
[] = { 0x12, 0x01, 0x31 };
1676 static BYTE onePrintable
[] = { 0x13, 0x01, 0x31 };
1677 static BYTE oneTeletex
[] = { 0x14, 0x01, 0x31 };
1678 static BYTE oneVideotex
[] = { 0x15, 0x01, 0x31 };
1679 static BYTE oneIA5
[] = { 0x16, 0x01, 0x31 };
1680 static BYTE oneGraphic
[] = { 0x19, 0x01, 0x31 };
1681 static BYTE oneVisible
[] = { 0x1a, 0x01, 0x31 };
1682 static BYTE oneUniversal
[] = { 0x1c, 0x04, 0x00, 0x00, 0x00, 0x31 };
1683 static BYTE oneGeneral
[] = { 0x1b, 0x01, 0x31 };
1684 static BYTE oneBMP
[] = { 0x1e, 0x02, 0x00, 0x31 };
1685 static BYTE oneUTF8
[] = { 0x0c, 0x01, 0x31 };
1686 static BYTE nihongoT61
[] = { 0x14,0x09,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x6f,
1688 static BYTE nihongoGeneral
[] = { 0x1b,0x09,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,
1690 static BYTE nihongoBMP
[] = { 0x1e,0x12,0x00,0x68,0x00,0x74,0x00,0x74,0x00,0x70,
1691 0x00,0x3a,0x00,0x2f,0x00,0x2f,0x22,0x6f,0x57,0x5b };
1692 static BYTE nihongoUTF8
[] = { 0x0c,0x0d,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,
1693 0xe2,0x89,0xaf,0xe5,0x9d,0x9b };
1695 static struct UnicodeExpectedResult unicodeResults
[] = {
1696 { CERT_RDN_NUMERIC_STRING
, oneW
, { sizeof(oneNumeric
), oneNumeric
} },
1697 { CERT_RDN_PRINTABLE_STRING
, oneW
, { sizeof(onePrintable
), onePrintable
} },
1698 { CERT_RDN_TELETEX_STRING
, oneW
, { sizeof(oneTeletex
), oneTeletex
} },
1699 { CERT_RDN_VIDEOTEX_STRING
, oneW
, { sizeof(oneVideotex
), oneVideotex
} },
1700 { CERT_RDN_IA5_STRING
, oneW
, { sizeof(oneIA5
), oneIA5
} },
1701 { CERT_RDN_GRAPHIC_STRING
, oneW
, { sizeof(oneGraphic
), oneGraphic
} },
1702 { CERT_RDN_VISIBLE_STRING
, oneW
, { sizeof(oneVisible
), oneVisible
} },
1703 { CERT_RDN_UNIVERSAL_STRING
, oneW
, { sizeof(oneUniversal
), oneUniversal
} },
1704 { CERT_RDN_GENERAL_STRING
, oneW
, { sizeof(oneGeneral
), oneGeneral
} },
1705 { CERT_RDN_BMP_STRING
, oneW
, { sizeof(oneBMP
), oneBMP
} },
1706 { CERT_RDN_UTF8_STRING
, oneW
, { sizeof(oneUTF8
), oneUTF8
} },
1707 { CERT_RDN_BMP_STRING
, nihongoURL
, { sizeof(nihongoBMP
), nihongoBMP
} },
1708 { CERT_RDN_UTF8_STRING
, nihongoURL
, { sizeof(nihongoUTF8
), nihongoUTF8
} },
1711 static struct UnicodeExpectedResult unicodeWeirdness
[] = {
1712 { CERT_RDN_TELETEX_STRING
, nihongoURL
, { sizeof(nihongoT61
), nihongoT61
} },
1713 { CERT_RDN_GENERAL_STRING
, nihongoURL
, { sizeof(nihongoGeneral
), nihongoGeneral
} },
1716 static void test_encodeUnicodeNameValue(DWORD dwEncoding
)
1721 CERT_NAME_VALUE value
;
1725 /* Crashes on win9x */
1726 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME_VALUE
, NULL
,
1727 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1728 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
1729 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
1731 /* Have to have a string of some sort */
1732 value
.dwValueType
= 0; /* aka CERT_RDN_ANY_TYPE */
1733 value
.Value
.pbData
= NULL
;
1734 value
.Value
.cbData
= 0;
1735 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME_VALUE
, &value
,
1736 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1737 ok(!ret
&& GetLastError() == CRYPT_E_NOT_CHAR_STRING
,
1738 "Expected CRYPT_E_NOT_CHAR_STRING, got %08x\n", GetLastError());
1739 value
.dwValueType
= CERT_RDN_ENCODED_BLOB
;
1740 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME_VALUE
, &value
,
1741 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1742 ok(!ret
&& GetLastError() == CRYPT_E_NOT_CHAR_STRING
,
1743 "Expected CRYPT_E_NOT_CHAR_STRING, got %08x\n", GetLastError());
1744 value
.dwValueType
= CERT_RDN_ANY_TYPE
;
1745 value
.Value
.pbData
= (LPBYTE
)oneW
;
1746 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME_VALUE
, &value
,
1747 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1748 ok(!ret
&& GetLastError() == CRYPT_E_NOT_CHAR_STRING
,
1749 "Expected CRYPT_E_NOT_CHAR_STRING, got %08x\n", GetLastError());
1750 value
.Value
.cbData
= sizeof(oneW
);
1751 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME_VALUE
, &value
,
1752 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1753 ok(!ret
&& GetLastError() == CRYPT_E_NOT_CHAR_STRING
,
1754 "Expected CRYPT_E_NOT_CHAR_STRING, got %08x\n", GetLastError());
1755 /* An encoded string with specified length isn't good enough either */
1756 value
.dwValueType
= CERT_RDN_ENCODED_BLOB
;
1757 value
.Value
.pbData
= oneUniversal
;
1758 value
.Value
.cbData
= sizeof(oneUniversal
);
1759 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME_VALUE
, &value
,
1760 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1761 ok(!ret
&& GetLastError() == CRYPT_E_NOT_CHAR_STRING
,
1762 "Expected CRYPT_E_NOT_CHAR_STRING, got %08x\n", GetLastError());
1763 /* More failure checking */
1764 value
.Value
.cbData
= 0;
1765 for (i
= 0; i
< sizeof(unicodeErrors
) / sizeof(unicodeErrors
[0]); i
++)
1767 value
.Value
.pbData
= (LPBYTE
)unicodeErrors
[i
].str
;
1768 value
.dwValueType
= unicodeErrors
[i
].valueType
;
1769 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME_VALUE
, &value
,
1770 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1771 ok(!ret
&& GetLastError() == unicodeErrors
[i
].error
,
1772 "Value type %d: expected %08x, got %08x\n", value
.dwValueType
,
1773 unicodeErrors
[i
].error
, GetLastError());
1774 ok(size
== unicodeErrors
[i
].errorIndex
,
1775 "Expected error index %d, got %d\n", unicodeErrors
[i
].errorIndex
,
1778 /* cbData can be zero if the string is NULL-terminated */
1779 value
.Value
.cbData
= 0;
1780 for (i
= 0; i
< sizeof(unicodeResults
) / sizeof(unicodeResults
[0]); i
++)
1782 value
.Value
.pbData
= (LPBYTE
)unicodeResults
[i
].str
;
1783 value
.dwValueType
= unicodeResults
[i
].valueType
;
1784 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME_VALUE
, &value
,
1785 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1786 ok(ret
|| broken(GetLastError() == OSS_PDU_MISMATCH
/* Win9x */),
1787 "CryptEncodeObjectEx failed: %08x\n", GetLastError());
1790 ok(size
== unicodeResults
[i
].encoded
.cbData
,
1791 "Value type %d: expected size %d, got %d\n",
1792 value
.dwValueType
, unicodeResults
[i
].encoded
.cbData
, size
);
1793 ok(!memcmp(unicodeResults
[i
].encoded
.pbData
, buf
, size
),
1794 "Value type %d: unexpected value\n", value
.dwValueType
);
1798 /* These "encode," but they do so by truncating each unicode character
1799 * rather than properly encoding it. Kept separate from the proper results,
1800 * because the encoded forms won't decode to their original strings.
1802 for (i
= 0; i
< sizeof(unicodeWeirdness
) / sizeof(unicodeWeirdness
[0]); i
++)
1804 value
.Value
.pbData
= (LPBYTE
)unicodeWeirdness
[i
].str
;
1805 value
.dwValueType
= unicodeWeirdness
[i
].valueType
;
1806 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_UNICODE_NAME_VALUE
, &value
,
1807 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1808 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
1811 ok(size
== unicodeWeirdness
[i
].encoded
.cbData
,
1812 "Value type %d: expected size %d, got %d\n",
1813 value
.dwValueType
, unicodeWeirdness
[i
].encoded
.cbData
, size
);
1814 ok(!memcmp(unicodeWeirdness
[i
].encoded
.pbData
, buf
, size
),
1815 "Value type %d: unexpected value\n", value
.dwValueType
);
1821 static inline int strncmpW( const WCHAR
*str1
, const WCHAR
*str2
, int n
)
1823 if (n
<= 0) return 0;
1824 while ((--n
> 0) && *str1
&& (*str1
== *str2
)) { str1
++; str2
++; }
1825 return *str1
- *str2
;
1828 static void test_decodeUnicodeNameValue(DWORD dwEncoding
)
1832 for (i
= 0; i
< sizeof(unicodeResults
) / sizeof(unicodeResults
[0]); i
++)
1838 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_UNICODE_NAME_VALUE
,
1839 unicodeResults
[i
].encoded
.pbData
, unicodeResults
[i
].encoded
.cbData
,
1840 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
1841 ok(ret
|| broken(GetLastError() == CRYPT_E_NOT_CHAR_STRING
/* Win9x */),
1842 "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1845 PCERT_NAME_VALUE value
= (PCERT_NAME_VALUE
)buf
;
1847 ok(value
->dwValueType
== unicodeResults
[i
].valueType
,
1848 "Expected value type %d, got %d\n", unicodeResults
[i
].valueType
,
1849 value
->dwValueType
);
1850 ok(!strncmpW((LPWSTR
)value
->Value
.pbData
, unicodeResults
[i
].str
,
1851 value
->Value
.cbData
/ sizeof(WCHAR
)),
1852 "Unexpected decoded value for index %d (value type %d)\n", i
,
1853 unicodeResults
[i
].valueType
);
1859 struct encodedOctets
1862 const BYTE
*encoded
;
1865 static const unsigned char bin46
[] = { 'h','i',0 };
1866 static const unsigned char bin47
[] = { 0x04,0x02,'h','i',0 };
1867 static const unsigned char bin48
[] = {
1868 's','o','m','e','l','o','n','g',0xff,'s','t','r','i','n','g',0 };
1869 static const unsigned char bin49
[] = {
1870 0x04,0x0f,'s','o','m','e','l','o','n','g',0xff,'s','t','r','i','n','g',0 };
1871 static const unsigned char bin50
[] = { 0 };
1872 static const unsigned char bin51
[] = { 0x04,0x00,0 };
1874 static const struct encodedOctets octets
[] = {
1880 static void test_encodeOctets(DWORD dwEncoding
)
1882 CRYPT_DATA_BLOB blob
;
1885 for (i
= 0; i
< sizeof(octets
) / sizeof(octets
[0]); i
++)
1891 blob
.cbData
= strlen((const char*)octets
[i
].val
);
1892 blob
.pbData
= (BYTE
*)octets
[i
].val
;
1893 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_OCTET_STRING
, &blob
,
1894 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
1895 ok(ret
, "CryptEncodeObjectEx failed: %d\n", GetLastError());
1899 "Got unexpected type %d for octet string (expected 4)\n", buf
[0]);
1900 ok(buf
[1] == octets
[i
].encoded
[1], "Got length %d, expected %d\n",
1901 buf
[1], octets
[i
].encoded
[1]);
1902 ok(!memcmp(buf
+ 1, octets
[i
].encoded
+ 1,
1903 octets
[i
].encoded
[1] + 1), "Got unexpected value\n");
1909 static void test_decodeOctets(DWORD dwEncoding
)
1913 for (i
= 0; i
< sizeof(octets
) / sizeof(octets
[0]); i
++)
1919 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_OCTET_STRING
,
1920 octets
[i
].encoded
, octets
[i
].encoded
[1] + 2,
1921 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
1922 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
1923 ok(bufSize
>= sizeof(CRYPT_DATA_BLOB
) + octets
[i
].encoded
[1],
1924 "Expected size >= %d, got %d\n",
1925 (int)sizeof(CRYPT_DATA_BLOB
) + octets
[i
].encoded
[1], bufSize
);
1926 ok(buf
!= NULL
, "Expected allocated buffer\n");
1929 CRYPT_DATA_BLOB
*blob
= (CRYPT_DATA_BLOB
*)buf
;
1932 ok(!memcmp(blob
->pbData
, octets
[i
].val
, blob
->cbData
),
1933 "Unexpected value\n");
1939 static const BYTE bytesToEncode
[] = { 0xff, 0xff };
1944 const BYTE
*encoded
;
1946 const BYTE
*decoded
;
1949 static const unsigned char bin52
[] = { 0x03,0x03,0x00,0xff,0xff };
1950 static const unsigned char bin53
[] = { 0xff,0xff };
1951 static const unsigned char bin54
[] = { 0x03,0x03,0x01,0xff,0xfe };
1952 static const unsigned char bin55
[] = { 0xff,0xfe };
1953 static const unsigned char bin56
[] = { 0x03,0x02,0x01,0xfe };
1954 static const unsigned char bin57
[] = { 0xfe };
1955 static const unsigned char bin58
[] = { 0x03,0x01,0x00 };
1957 static const struct encodedBits bits
[] = {
1958 /* normal test cases */
1959 { 0, bin52
, 2, bin53
},
1960 { 1, bin54
, 2, bin55
},
1961 /* strange test case, showing cUnusedBits >= 8 is allowed */
1962 { 9, bin56
, 1, bin57
},
1963 /* even stranger test case, showing cUnusedBits > cbData * 8 is allowed */
1964 { 17, bin58
, 0, NULL
},
1967 static void test_encodeBits(DWORD dwEncoding
)
1971 for (i
= 0; i
< sizeof(bits
) / sizeof(bits
[0]); i
++)
1973 CRYPT_BIT_BLOB blob
;
1978 blob
.cbData
= sizeof(bytesToEncode
);
1979 blob
.pbData
= (BYTE
*)bytesToEncode
;
1980 blob
.cUnusedBits
= bits
[i
].cUnusedBits
;
1981 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_BITS
, &blob
,
1982 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
1983 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
1986 ok(bufSize
== bits
[i
].encoded
[1] + 2,
1987 "%d: Got unexpected size %d, expected %d\n", i
, bufSize
,
1988 bits
[i
].encoded
[1] + 2);
1989 ok(!memcmp(buf
, bits
[i
].encoded
, bits
[i
].encoded
[1] + 2),
1990 "%d: Unexpected value\n", i
);
1996 static void test_decodeBits(DWORD dwEncoding
)
1998 static const BYTE ber
[] = "\x03\x02\x01\xff";
1999 static const BYTE berDecoded
= 0xfe;
2006 for (i
= 0; i
< sizeof(bits
) / sizeof(bits
[0]); i
++)
2008 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_BITS
, bits
[i
].encoded
,
2009 bits
[i
].encoded
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
,
2011 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
2014 CRYPT_BIT_BLOB
*blob
;
2016 ok(bufSize
>= sizeof(CRYPT_BIT_BLOB
) + bits
[i
].cbDecoded
,
2017 "Got unexpected size %d\n", bufSize
);
2018 blob
= (CRYPT_BIT_BLOB
*)buf
;
2019 ok(blob
->cbData
== bits
[i
].cbDecoded
,
2020 "Got unexpected length %d, expected %d\n", blob
->cbData
,
2022 if (blob
->cbData
&& bits
[i
].cbDecoded
)
2023 ok(!memcmp(blob
->pbData
, bits
[i
].decoded
, bits
[i
].cbDecoded
),
2024 "Unexpected value\n");
2028 /* special case: check that something that's valid in BER but not in DER
2029 * decodes successfully
2031 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_BITS
, ber
, ber
[1] + 2,
2032 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2033 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
2036 CRYPT_BIT_BLOB
*blob
;
2038 ok(bufSize
>= sizeof(CRYPT_BIT_BLOB
) + sizeof(berDecoded
),
2039 "Got unexpected size %d\n", bufSize
);
2040 blob
= (CRYPT_BIT_BLOB
*)buf
;
2041 ok(blob
->cbData
== sizeof(berDecoded
),
2042 "Got unexpected length %d\n", blob
->cbData
);
2044 ok(*blob
->pbData
== berDecoded
, "Unexpected value\n");
2051 CERT_BASIC_CONSTRAINTS2_INFO info
;
2052 const BYTE
*encoded
;
2055 static const unsigned char bin59
[] = { 0x30,0x00 };
2056 static const unsigned char bin60
[] = { 0x30,0x03,0x01,0x01,0xff };
2057 static const unsigned char bin61
[] = { 0x30,0x03,0x02,0x01,0x00 };
2058 static const unsigned char bin62
[] = { 0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
2059 static const struct Constraints2 constraints2
[] = {
2060 /* empty constraints */
2061 { { FALSE
, FALSE
, 0}, bin59
},
2063 { { TRUE
, FALSE
, 0}, bin60
},
2064 /* has path length constraints set (MSDN implies fCA needs to be TRUE as well,
2065 * but that's not the case
2067 { { FALSE
, TRUE
, 0}, bin61
},
2068 /* can be a CA and has path length constraints set */
2069 { { TRUE
, TRUE
, 1}, bin62
},
2072 static const BYTE emptyConstraint
[] = { 0x30, 0x03, 0x03, 0x01, 0x00 };
2073 static const BYTE encodedDomainName
[] = { 0x30, 0x2b, 0x31, 0x29, 0x30, 0x11,
2074 0x06, 0x0a, 0x09, 0x92, 0x26, 0x89, 0x93, 0xf2, 0x2c, 0x64, 0x01, 0x19, 0x16,
2075 0x03, 0x6f, 0x72, 0x67, 0x30, 0x14, 0x06, 0x0a, 0x09, 0x92, 0x26, 0x89, 0x93,
2076 0xf2, 0x2c, 0x64, 0x01, 0x19, 0x16, 0x06, 0x77, 0x69, 0x6e, 0x65, 0x68, 0x71 };
2077 static const BYTE constraintWithDomainName
[] = { 0x30, 0x32, 0x03, 0x01, 0x00,
2078 0x30, 0x2d, 0x30, 0x2b, 0x31, 0x29, 0x30, 0x11, 0x06, 0x0a, 0x09, 0x92, 0x26,
2079 0x89, 0x93, 0xf2, 0x2c, 0x64, 0x01, 0x19, 0x16, 0x03, 0x6f, 0x72, 0x67, 0x30,
2080 0x14, 0x06, 0x0a, 0x09, 0x92, 0x26, 0x89, 0x93, 0xf2, 0x2c, 0x64, 0x01, 0x19,
2081 0x16, 0x06, 0x77, 0x69, 0x6e, 0x65, 0x68, 0x71 };
2083 static void test_encodeBasicConstraints(DWORD dwEncoding
)
2085 DWORD i
, bufSize
= 0;
2086 CERT_BASIC_CONSTRAINTS_INFO info
= { { 0 } };
2087 CERT_NAME_BLOB nameBlob
= { sizeof(encodedDomainName
),
2088 (LPBYTE
)encodedDomainName
};
2092 /* First test with the simpler info2 */
2093 for (i
= 0; i
< sizeof(constraints2
) / sizeof(constraints2
[0]); i
++)
2095 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_BASIC_CONSTRAINTS2
,
2096 &constraints2
[i
].info
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
,
2098 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2101 ok(bufSize
== constraints2
[i
].encoded
[1] + 2,
2102 "Expected %d bytes, got %d\n", constraints2
[i
].encoded
[1] + 2,
2104 ok(!memcmp(buf
, constraints2
[i
].encoded
,
2105 constraints2
[i
].encoded
[1] + 2), "Unexpected value\n");
2109 /* Now test with more complex basic constraints */
2110 info
.SubjectType
.cbData
= 0;
2111 info
.fPathLenConstraint
= FALSE
;
2112 info
.cSubtreesConstraint
= 0;
2113 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_BASIC_CONSTRAINTS
, &info
,
2114 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2115 ok(ret
|| GetLastError() == OSS_BAD_PTR
/* Win9x */,
2116 "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2119 ok(bufSize
== sizeof(emptyConstraint
), "Wrong size %d\n", bufSize
);
2120 ok(!memcmp(buf
, emptyConstraint
, sizeof(emptyConstraint
)),
2121 "Unexpected value\n");
2124 /* None of the certs I examined had any subtree constraint, but I test one
2125 * anyway just in case.
2127 info
.cSubtreesConstraint
= 1;
2128 info
.rgSubtreesConstraint
= &nameBlob
;
2129 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_BASIC_CONSTRAINTS
, &info
,
2130 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2131 ok(ret
|| GetLastError() == OSS_BAD_PTR
/* Win9x */,
2132 "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2135 ok(bufSize
== sizeof(constraintWithDomainName
), "Wrong size %d\n", bufSize
);
2136 ok(!memcmp(buf
, constraintWithDomainName
,
2137 sizeof(constraintWithDomainName
)), "Unexpected value\n");
2140 /* FIXME: test encoding with subject type. */
2143 static const unsigned char bin63
[] = { 0x30,0x06,0x01,0x01,0x01,0x02,0x01,0x01 };
2145 static void test_decodeBasicConstraints(DWORD dwEncoding
)
2147 static const BYTE inverted
[] = { 0x30, 0x06, 0x02, 0x01, 0x01, 0x01, 0x01,
2149 static const struct Constraints2 badBool
= { { TRUE
, TRUE
, 1 }, bin63
};
2155 /* First test with simpler info2 */
2156 for (i
= 0; i
< sizeof(constraints2
) / sizeof(constraints2
[0]); i
++)
2158 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_BASIC_CONSTRAINTS2
,
2159 constraints2
[i
].encoded
, constraints2
[i
].encoded
[1] + 2,
2160 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2161 ok(ret
, "CryptDecodeObjectEx failed for item %d: %08x\n", i
,
2165 CERT_BASIC_CONSTRAINTS2_INFO
*info
=
2166 (CERT_BASIC_CONSTRAINTS2_INFO
*)buf
;
2168 ok(!memcmp(info
, &constraints2
[i
].info
, sizeof(*info
)),
2169 "Unexpected value for item %d\n", i
);
2173 /* Check with the order of encoded elements inverted */
2175 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_BASIC_CONSTRAINTS2
,
2176 inverted
, inverted
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
,
2178 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_CORRUPT
||
2179 GetLastError() == OSS_DATA_ERROR
/* Win9x */),
2180 "Expected CRYPT_E_ASN1_CORRUPT or OSS_DATA_ERROR, got %08x\n",
2182 ok(!buf
, "Expected buf to be set to NULL\n");
2183 /* Check with a non-DER bool */
2184 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_BASIC_CONSTRAINTS2
,
2185 badBool
.encoded
, badBool
.encoded
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
,
2187 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
2190 CERT_BASIC_CONSTRAINTS2_INFO
*info
=
2191 (CERT_BASIC_CONSTRAINTS2_INFO
*)buf
;
2193 ok(!memcmp(info
, &badBool
.info
, sizeof(*info
)), "Unexpected value\n");
2196 /* Check with a non-basic constraints value */
2197 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_BASIC_CONSTRAINTS2
,
2198 encodedCommonName
, encodedCommonName
[1] + 2,
2199 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2200 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_CORRUPT
||
2201 GetLastError() == OSS_DATA_ERROR
/* Win9x */),
2202 "Expected CRYPT_E_ASN1_CORRUPT or OSS_DATA_ERROR, got %08x\n",
2204 /* Now check with the more complex CERT_BASIC_CONSTRAINTS_INFO */
2205 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_BASIC_CONSTRAINTS
,
2206 emptyConstraint
, sizeof(emptyConstraint
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
2208 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
2211 CERT_BASIC_CONSTRAINTS_INFO
*info
= (CERT_BASIC_CONSTRAINTS_INFO
*)buf
;
2213 ok(info
->SubjectType
.cbData
== 0, "Expected no subject type\n");
2214 ok(!info
->fPathLenConstraint
, "Expected no path length constraint\n");
2215 ok(info
->cSubtreesConstraint
== 0, "Expected no subtree constraints\n");
2218 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_BASIC_CONSTRAINTS
,
2219 constraintWithDomainName
, sizeof(constraintWithDomainName
),
2220 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2221 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
2224 CERT_BASIC_CONSTRAINTS_INFO
*info
= (CERT_BASIC_CONSTRAINTS_INFO
*)buf
;
2226 ok(info
->SubjectType
.cbData
== 0, "Expected no subject type\n");
2227 ok(!info
->fPathLenConstraint
, "Expected no path length constraint\n");
2228 ok(info
->cSubtreesConstraint
== 1, "Expected a subtree constraint\n");
2229 if (info
->cSubtreesConstraint
&& info
->rgSubtreesConstraint
)
2231 ok(info
->rgSubtreesConstraint
[0].cbData
==
2232 sizeof(encodedDomainName
), "Wrong size %d\n",
2233 info
->rgSubtreesConstraint
[0].cbData
);
2234 ok(!memcmp(info
->rgSubtreesConstraint
[0].pbData
, encodedDomainName
,
2235 sizeof(encodedDomainName
)), "Unexpected value\n");
2241 /* These are terrible public keys of course, I'm just testing encoding */
2242 static const BYTE modulus1
[] = { 0,0,0,1,1,1,1,1 };
2243 static const BYTE modulus2
[] = { 1,1,1,1,1,0,0,0 };
2244 static const BYTE modulus3
[] = { 0x80,1,1,1,1,0,0,0 };
2245 static const BYTE modulus4
[] = { 1,1,1,1,1,0,0,0x80 };
2246 static const BYTE mod1_encoded
[] = { 0x30,0x0f,0x02,0x08,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x02,0x03,0x01,0x00,0x01 };
2247 static const BYTE mod2_encoded
[] = { 0x30,0x0c,0x02,0x05,0x01,0x01,0x01,0x01,0x01,0x02,0x03,0x01,0x00,0x01 };
2248 static const BYTE mod3_encoded
[] = { 0x30,0x0c,0x02,0x05,0x01,0x01,0x01,0x01,0x80,0x02,0x03,0x01,0x00,0x01 };
2249 static const BYTE mod4_encoded
[] = { 0x30,0x10,0x02,0x09,0x00,0x80,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x02,0x03,0x01,0x00,0x01 };
2251 struct EncodedRSAPubKey
2253 const BYTE
*modulus
;
2255 const BYTE
*encoded
;
2256 size_t decodedModulusLen
;
2259 struct EncodedRSAPubKey rsaPubKeys
[] = {
2260 { modulus1
, sizeof(modulus1
), mod1_encoded
, sizeof(modulus1
) },
2261 { modulus2
, sizeof(modulus2
), mod2_encoded
, 5 },
2262 { modulus3
, sizeof(modulus3
), mod3_encoded
, 5 },
2263 { modulus4
, sizeof(modulus4
), mod4_encoded
, 8 },
2266 static void test_encodeRsaPublicKey(DWORD dwEncoding
)
2268 BYTE toEncode
[sizeof(BLOBHEADER
) + sizeof(RSAPUBKEY
) + sizeof(modulus1
)];
2269 BLOBHEADER
*hdr
= (BLOBHEADER
*)toEncode
;
2270 RSAPUBKEY
*rsaPubKey
= (RSAPUBKEY
*)(toEncode
+ sizeof(BLOBHEADER
));
2273 DWORD bufSize
= 0, i
;
2275 /* Try with a bogus blob type */
2277 hdr
->bVersion
= CUR_BLOB_VERSION
;
2279 hdr
->aiKeyAlg
= CALG_RSA_KEYX
;
2280 rsaPubKey
->magic
= 0x31415352;
2281 rsaPubKey
->bitlen
= sizeof(modulus1
) * 8;
2282 rsaPubKey
->pubexp
= 65537;
2283 memcpy(toEncode
+ sizeof(BLOBHEADER
) + sizeof(RSAPUBKEY
), modulus1
,
2286 ret
= pCryptEncodeObjectEx(dwEncoding
, RSA_CSP_PUBLICKEYBLOB
,
2287 toEncode
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2288 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2289 "Expected E_INVALIDARG, got %08x\n", GetLastError());
2290 /* Now with a bogus reserved field */
2291 hdr
->bType
= PUBLICKEYBLOB
;
2293 ret
= pCryptEncodeObjectEx(dwEncoding
, RSA_CSP_PUBLICKEYBLOB
,
2294 toEncode
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2297 ok(bufSize
== rsaPubKeys
[0].encoded
[1] + 2,
2298 "Expected size %d, got %d\n", rsaPubKeys
[0].encoded
[1] + 2, bufSize
);
2299 ok(!memcmp(buf
, rsaPubKeys
[0].encoded
, bufSize
), "Unexpected value\n");
2302 /* Now with a bogus blob version */
2305 ret
= pCryptEncodeObjectEx(dwEncoding
, RSA_CSP_PUBLICKEYBLOB
,
2306 toEncode
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2309 ok(bufSize
== rsaPubKeys
[0].encoded
[1] + 2,
2310 "Expected size %d, got %d\n", rsaPubKeys
[0].encoded
[1] + 2, bufSize
);
2311 ok(!memcmp(buf
, rsaPubKeys
[0].encoded
, bufSize
), "Unexpected value\n");
2314 /* And with a bogus alg ID */
2315 hdr
->bVersion
= CUR_BLOB_VERSION
;
2316 hdr
->aiKeyAlg
= CALG_DES
;
2317 ret
= pCryptEncodeObjectEx(dwEncoding
, RSA_CSP_PUBLICKEYBLOB
,
2318 toEncode
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2321 ok(bufSize
== rsaPubKeys
[0].encoded
[1] + 2,
2322 "Expected size %d, got %d\n", rsaPubKeys
[0].encoded
[1] + 2, bufSize
);
2323 ok(!memcmp(buf
, rsaPubKeys
[0].encoded
, bufSize
), "Unexpected value\n");
2326 /* Check a couple of RSA-related OIDs */
2327 hdr
->aiKeyAlg
= CALG_RSA_KEYX
;
2328 ret
= pCryptEncodeObjectEx(dwEncoding
, szOID_RSA_RSA
,
2329 toEncode
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2330 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
2331 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
2332 ret
= pCryptEncodeObjectEx(dwEncoding
, szOID_RSA_SHA1RSA
,
2333 toEncode
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2334 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
2335 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
2336 /* Finally, all valid */
2337 hdr
->aiKeyAlg
= CALG_RSA_KEYX
;
2338 for (i
= 0; i
< sizeof(rsaPubKeys
) / sizeof(rsaPubKeys
[0]); i
++)
2340 memcpy(toEncode
+ sizeof(BLOBHEADER
) + sizeof(RSAPUBKEY
),
2341 rsaPubKeys
[i
].modulus
, rsaPubKeys
[i
].modulusLen
);
2342 ret
= pCryptEncodeObjectEx(dwEncoding
, RSA_CSP_PUBLICKEYBLOB
,
2343 toEncode
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2344 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2347 ok(bufSize
== rsaPubKeys
[i
].encoded
[1] + 2,
2348 "Expected size %d, got %d\n", rsaPubKeys
[i
].encoded
[1] + 2,
2350 ok(!memcmp(buf
, rsaPubKeys
[i
].encoded
, bufSize
),
2351 "Unexpected value\n");
2357 static void test_decodeRsaPublicKey(DWORD dwEncoding
)
2364 /* Try with a bad length */
2365 ret
= pCryptDecodeObjectEx(dwEncoding
, RSA_CSP_PUBLICKEYBLOB
,
2366 rsaPubKeys
[0].encoded
, rsaPubKeys
[0].encoded
[1],
2367 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2368 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_EOD
||
2369 GetLastError() == OSS_MORE_INPUT
/* Win9x/NT4 */),
2370 "Expected CRYPT_E_ASN1_EOD or OSS_MORE_INPUT, got %08x\n",
2372 /* Try with a couple of RSA-related OIDs */
2373 ret
= pCryptDecodeObjectEx(dwEncoding
, szOID_RSA_RSA
,
2374 rsaPubKeys
[0].encoded
, rsaPubKeys
[0].encoded
[1] + 2,
2375 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2376 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
2377 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
2378 ret
= pCryptDecodeObjectEx(dwEncoding
, szOID_RSA_SHA1RSA
,
2379 rsaPubKeys
[0].encoded
, rsaPubKeys
[0].encoded
[1] + 2,
2380 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2381 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
2382 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
2383 /* Now try success cases */
2384 for (i
= 0; i
< sizeof(rsaPubKeys
) / sizeof(rsaPubKeys
[0]); i
++)
2387 ret
= pCryptDecodeObjectEx(dwEncoding
, RSA_CSP_PUBLICKEYBLOB
,
2388 rsaPubKeys
[i
].encoded
, rsaPubKeys
[i
].encoded
[1] + 2,
2389 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2390 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
2393 BLOBHEADER
*hdr
= (BLOBHEADER
*)buf
;
2394 RSAPUBKEY
*rsaPubKey
= (RSAPUBKEY
*)(buf
+ sizeof(BLOBHEADER
));
2396 ok(bufSize
>= sizeof(BLOBHEADER
) + sizeof(RSAPUBKEY
) +
2397 rsaPubKeys
[i
].decodedModulusLen
,
2398 "Wrong size %d\n", bufSize
);
2399 ok(hdr
->bType
== PUBLICKEYBLOB
,
2400 "Expected type PUBLICKEYBLOB (%d), got %d\n", PUBLICKEYBLOB
,
2402 ok(hdr
->bVersion
== CUR_BLOB_VERSION
,
2403 "Expected version CUR_BLOB_VERSION (%d), got %d\n",
2404 CUR_BLOB_VERSION
, hdr
->bVersion
);
2405 ok(hdr
->reserved
== 0, "Expected reserved 0, got %d\n",
2407 ok(hdr
->aiKeyAlg
== CALG_RSA_KEYX
,
2408 "Expected CALG_RSA_KEYX, got %08x\n", hdr
->aiKeyAlg
);
2409 ok(rsaPubKey
->magic
== 0x31415352,
2410 "Expected magic RSA1, got %08x\n", rsaPubKey
->magic
);
2411 ok(rsaPubKey
->bitlen
== rsaPubKeys
[i
].decodedModulusLen
* 8,
2412 "Wrong bit len %d\n", rsaPubKey
->bitlen
);
2413 ok(rsaPubKey
->pubexp
== 65537, "Expected pubexp 65537, got %d\n",
2415 ok(!memcmp(buf
+ sizeof(BLOBHEADER
) + sizeof(RSAPUBKEY
),
2416 rsaPubKeys
[i
].modulus
, rsaPubKeys
[i
].decodedModulusLen
),
2417 "Unexpected modulus\n");
2423 static const BYTE intSequence
[] = { 0x30, 0x1b, 0x02, 0x01, 0x01, 0x02, 0x01,
2424 0x7f, 0x02, 0x02, 0x00, 0x80, 0x02, 0x02, 0x01, 0x00, 0x02, 0x01, 0x80, 0x02,
2425 0x02, 0xff, 0x7f, 0x02, 0x04, 0xba, 0xdd, 0xf0, 0x0d };
2427 static const BYTE mixedSequence
[] = { 0x30, 0x27, 0x17, 0x0d, 0x30, 0x35, 0x30,
2428 0x36, 0x30, 0x36, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x5a, 0x02, 0x01, 0x7f,
2429 0x02, 0x02, 0x00, 0x80, 0x02, 0x02, 0x01, 0x00, 0x02, 0x01, 0x80, 0x02, 0x02,
2430 0xff, 0x7f, 0x02, 0x04, 0xba, 0xdd, 0xf0, 0x0d };
2432 static void test_encodeSequenceOfAny(DWORD dwEncoding
)
2434 CRYPT_DER_BLOB blobs
[sizeof(ints
) / sizeof(ints
[0])];
2435 CRYPT_SEQUENCE_OF_ANY seq
;
2441 /* Encode a homogeneous sequence */
2442 for (i
= 0; i
< sizeof(ints
) / sizeof(ints
[0]); i
++)
2444 blobs
[i
].cbData
= ints
[i
].encoded
[1] + 2;
2445 blobs
[i
].pbData
= (BYTE
*)ints
[i
].encoded
;
2447 seq
.cValue
= sizeof(ints
) / sizeof(ints
[0]);
2448 seq
.rgValue
= blobs
;
2450 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_SEQUENCE_OF_ANY
, &seq
,
2451 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2452 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2455 ok(bufSize
== sizeof(intSequence
), "Wrong size %d\n", bufSize
);
2456 ok(!memcmp(buf
, intSequence
, intSequence
[1] + 2), "Unexpected value\n");
2459 /* Change the type of the first element in the sequence, and give it
2462 blobs
[0].cbData
= times
[0].encodedTime
[1] + 2;
2463 blobs
[0].pbData
= (BYTE
*)times
[0].encodedTime
;
2464 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_SEQUENCE_OF_ANY
, &seq
,
2465 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2466 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2469 ok(bufSize
== sizeof(mixedSequence
), "Wrong size %d\n", bufSize
);
2470 ok(!memcmp(buf
, mixedSequence
, mixedSequence
[1] + 2),
2471 "Unexpected value\n");
2476 static void test_decodeSequenceOfAny(DWORD dwEncoding
)
2482 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_SEQUENCE_OF_ANY
, intSequence
,
2483 intSequence
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2484 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
2487 CRYPT_SEQUENCE_OF_ANY
*seq
= (CRYPT_SEQUENCE_OF_ANY
*)buf
;
2490 ok(seq
->cValue
== sizeof(ints
) / sizeof(ints
[0]),
2491 "Wrong elements %d\n", seq
->cValue
);
2492 for (i
= 0; i
< min(seq
->cValue
, sizeof(ints
) / sizeof(ints
[0])); i
++)
2494 ok(seq
->rgValue
[i
].cbData
== ints
[i
].encoded
[1] + 2,
2495 "Expected %d bytes, got %d\n", ints
[i
].encoded
[1] + 2,
2496 seq
->rgValue
[i
].cbData
);
2497 ok(!memcmp(seq
->rgValue
[i
].pbData
, ints
[i
].encoded
,
2498 ints
[i
].encoded
[1] + 2), "Unexpected value\n");
2502 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_SEQUENCE_OF_ANY
, mixedSequence
,
2503 mixedSequence
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
,
2505 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
2508 CRYPT_SEQUENCE_OF_ANY
*seq
= (CRYPT_SEQUENCE_OF_ANY
*)buf
;
2510 ok(seq
->cValue
== sizeof(ints
) / sizeof(ints
[0]),
2511 "Wrong elements %d\n", seq
->cValue
);
2512 /* Just check the first element since it's all that changed */
2513 ok(seq
->rgValue
[0].cbData
== times
[0].encodedTime
[1] + 2,
2514 "Expected %d bytes, got %d\n", times
[0].encodedTime
[1] + 2,
2515 seq
->rgValue
[0].cbData
);
2516 ok(!memcmp(seq
->rgValue
[0].pbData
, times
[0].encodedTime
,
2517 times
[0].encodedTime
[1] + 2), "Unexpected value\n");
2522 struct encodedExtensions
2524 CERT_EXTENSIONS exts
;
2525 const BYTE
*encoded
;
2528 static BYTE crit_ext_data
[] = { 0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
2529 static BYTE noncrit_ext_data
[] = { 0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
2530 static CHAR oid_basic_constraints2
[] = szOID_BASIC_CONSTRAINTS2
;
2531 static CERT_EXTENSION criticalExt
=
2532 { oid_basic_constraints2
, TRUE
, { 8, crit_ext_data
} };
2533 static CERT_EXTENSION nonCriticalExt
=
2534 { oid_basic_constraints2
, FALSE
, { 8, noncrit_ext_data
} };
2535 static CHAR oid_short
[] = "1.1";
2536 static CERT_EXTENSION extWithShortOid
=
2537 { oid_short
, FALSE
, { 0, NULL
} };
2539 static const BYTE ext0
[] = { 0x30,0x00 };
2540 static const BYTE ext1
[] = { 0x30,0x14,0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,
2541 0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
2542 static const BYTE ext2
[] = { 0x30,0x11,0x30,0x0f,0x06,0x03,0x55,0x1d,0x13,0x04,
2543 0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
2544 static const BYTE ext3
[] = { 0x30,0x07,0x30,0x05,0x06,0x01,0x29,0x04,0x00 };
2546 static const struct encodedExtensions exts
[] = {
2547 { { 0, NULL
}, ext0
},
2548 { { 1, &criticalExt
}, ext1
},
2549 { { 1, &nonCriticalExt
}, ext2
},
2550 { { 1, &extWithShortOid
}, ext3
}
2553 static void test_encodeExtensions(DWORD dwEncoding
)
2557 for (i
= 0; i
< sizeof(exts
) / sizeof(exts
[i
]); i
++)
2563 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_EXTENSIONS
, &exts
[i
].exts
,
2564 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2565 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2568 ok(bufSize
== exts
[i
].encoded
[1] + 2,
2569 "Expected %d bytes, got %d\n", exts
[i
].encoded
[1] + 2, bufSize
);
2570 ok(!memcmp(buf
, exts
[i
].encoded
, exts
[i
].encoded
[1] + 2),
2571 "Unexpected value\n");
2577 static void test_decodeExtensions(DWORD dwEncoding
)
2581 for (i
= 0; i
< sizeof(exts
) / sizeof(exts
[i
]); i
++)
2587 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_EXTENSIONS
,
2588 exts
[i
].encoded
, exts
[i
].encoded
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
,
2589 NULL
, &buf
, &bufSize
);
2590 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
2593 CERT_EXTENSIONS
*ext
= (CERT_EXTENSIONS
*)buf
;
2596 ok(ext
->cExtension
== exts
[i
].exts
.cExtension
,
2597 "Expected %d extensions, see %d\n", exts
[i
].exts
.cExtension
,
2599 for (j
= 0; j
< min(ext
->cExtension
, exts
[i
].exts
.cExtension
); j
++)
2601 ok(!strcmp(ext
->rgExtension
[j
].pszObjId
,
2602 exts
[i
].exts
.rgExtension
[j
].pszObjId
),
2603 "Expected OID %s, got %s\n",
2604 exts
[i
].exts
.rgExtension
[j
].pszObjId
,
2605 ext
->rgExtension
[j
].pszObjId
);
2606 ok(!memcmp(ext
->rgExtension
[j
].Value
.pbData
,
2607 exts
[i
].exts
.rgExtension
[j
].Value
.pbData
,
2608 exts
[i
].exts
.rgExtension
[j
].Value
.cbData
),
2609 "Unexpected value\n");
2616 /* MS encodes public key info with a NULL if the algorithm identifier's
2617 * parameters are empty. However, when encoding an algorithm in a CERT_INFO,
2618 * it encodes them by omitting the algorithm parameters. This latter approach
2619 * seems more correct, so accept either form.
2621 struct encodedPublicKey
2623 CERT_PUBLIC_KEY_INFO info
;
2624 const BYTE
*encoded
;
2625 const BYTE
*encodedNoNull
;
2626 CERT_PUBLIC_KEY_INFO decoded
;
2629 static const BYTE aKey
[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd,
2631 static const BYTE params
[] = { 0x02, 0x01, 0x01 };
2633 static const unsigned char bin64
[] = {
2634 0x30,0x0b,0x30,0x06,0x06,0x02,0x2a,0x03,0x05,0x00,0x03,0x01,0x00};
2635 static const unsigned char bin65
[] = {
2636 0x30,0x09,0x30,0x04,0x06,0x02,0x2a,0x03,0x03,0x01,0x00};
2637 static const unsigned char bin66
[] = {
2638 0x30,0x0f,0x30,0x0a,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x05,0x00,0x03,0x01,0x00};
2639 static const unsigned char bin67
[] = {
2640 0x30,0x0d,0x30,0x08,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x01,0x00};
2641 static const unsigned char bin68
[] = {
2642 0x30,0x1f,0x30,0x0a,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x05,0x00,0x03,0x11,0x00,0x00,0x01,
2643 0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
2644 static const unsigned char bin69
[] = {
2645 0x30,0x1d,0x30,0x08,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x11,0x00,0x00,0x01,
2646 0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
2647 static const unsigned char bin70
[] = {
2648 0x30,0x20,0x30,0x0b,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x01,0x01,
2649 0x03,0x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,
2651 static const unsigned char bin71
[] = {
2652 0x30,0x20,0x30,0x0b,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x01,0x01,
2653 0x03,0x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,
2655 static unsigned char bin72
[] = { 0x05,0x00};
2657 static CHAR oid_bogus
[] = "1.2.3",
2658 oid_rsa
[] = szOID_RSA
;
2660 static const struct encodedPublicKey pubKeys
[] = {
2661 /* with a bogus OID */
2662 { { { oid_bogus
, { 0, NULL
} }, { 0, NULL
, 0 } },
2664 { { oid_bogus
, { 2, bin72
} }, { 0, NULL
, 0 } } },
2665 /* some normal keys */
2666 { { { oid_rsa
, { 0, NULL
} }, { 0, NULL
, 0} },
2668 { { oid_rsa
, { 2, bin72
} }, { 0, NULL
, 0 } } },
2669 { { { oid_rsa
, { 0, NULL
} }, { sizeof(aKey
), (BYTE
*)aKey
, 0} },
2671 { { oid_rsa
, { 2, bin72
} }, { sizeof(aKey
), (BYTE
*)aKey
, 0} } },
2672 /* with add'l parameters--note they must be DER-encoded */
2673 { { { oid_rsa
, { sizeof(params
), (BYTE
*)params
} }, { sizeof(aKey
),
2674 (BYTE
*)aKey
, 0 } },
2676 { { oid_rsa
, { sizeof(params
), (BYTE
*)params
} }, { sizeof(aKey
),
2677 (BYTE
*)aKey
, 0 } } },
2680 static void test_encodePublicKeyInfo(DWORD dwEncoding
)
2684 for (i
= 0; i
< sizeof(pubKeys
) / sizeof(pubKeys
[0]); i
++)
2690 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_PUBLIC_KEY_INFO
,
2691 &pubKeys
[i
].info
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
,
2693 ok(ret
|| GetLastError() == OSS_BAD_PTR
/* Win9x */,
2694 "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2697 ok(bufSize
== pubKeys
[i
].encoded
[1] + 2 ||
2698 bufSize
== pubKeys
[i
].encodedNoNull
[1] + 2,
2699 "Expected %d or %d bytes, got %d\n", pubKeys
[i
].encoded
[1] + 2,
2700 pubKeys
[i
].encodedNoNull
[1] + 2, bufSize
);
2701 if (bufSize
== pubKeys
[i
].encoded
[1] + 2)
2702 ok(!memcmp(buf
, pubKeys
[i
].encoded
, pubKeys
[i
].encoded
[1] + 2),
2703 "Unexpected value\n");
2704 else if (bufSize
== pubKeys
[i
].encodedNoNull
[1] + 2)
2705 ok(!memcmp(buf
, pubKeys
[i
].encodedNoNull
,
2706 pubKeys
[i
].encodedNoNull
[1] + 2), "Unexpected value\n");
2712 static void comparePublicKeyInfo(const CERT_PUBLIC_KEY_INFO
*expected
,
2713 const CERT_PUBLIC_KEY_INFO
*got
)
2715 ok(!strcmp(expected
->Algorithm
.pszObjId
, got
->Algorithm
.pszObjId
),
2716 "Expected OID %s, got %s\n", expected
->Algorithm
.pszObjId
,
2717 got
->Algorithm
.pszObjId
);
2718 ok(expected
->Algorithm
.Parameters
.cbData
==
2719 got
->Algorithm
.Parameters
.cbData
,
2720 "Expected parameters of %d bytes, got %d\n",
2721 expected
->Algorithm
.Parameters
.cbData
, got
->Algorithm
.Parameters
.cbData
);
2722 if (expected
->Algorithm
.Parameters
.cbData
)
2723 ok(!memcmp(expected
->Algorithm
.Parameters
.pbData
,
2724 got
->Algorithm
.Parameters
.pbData
, got
->Algorithm
.Parameters
.cbData
),
2725 "Unexpected algorithm parameters\n");
2726 ok(expected
->PublicKey
.cbData
== got
->PublicKey
.cbData
,
2727 "Expected public key of %d bytes, got %d\n",
2728 expected
->PublicKey
.cbData
, got
->PublicKey
.cbData
);
2729 if (expected
->PublicKey
.cbData
)
2730 ok(!memcmp(expected
->PublicKey
.pbData
, got
->PublicKey
.pbData
,
2731 got
->PublicKey
.cbData
), "Unexpected public key value\n");
2734 static void test_decodePublicKeyInfo(DWORD dwEncoding
)
2736 static const BYTE bogusPubKeyInfo
[] = { 0x30, 0x22, 0x30, 0x0d, 0x06, 0x06,
2737 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03,
2738 0x11, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
2739 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
2745 for (i
= 0; i
< sizeof(pubKeys
) / sizeof(pubKeys
[0]); i
++)
2747 /* The NULL form decodes to the decoded member */
2748 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_PUBLIC_KEY_INFO
,
2749 pubKeys
[i
].encoded
, pubKeys
[i
].encoded
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
,
2750 NULL
, &buf
, &bufSize
);
2751 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
2754 comparePublicKeyInfo(&pubKeys
[i
].decoded
,
2755 (CERT_PUBLIC_KEY_INFO
*)buf
);
2758 /* The non-NULL form decodes to the original */
2759 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_PUBLIC_KEY_INFO
,
2760 pubKeys
[i
].encodedNoNull
, pubKeys
[i
].encodedNoNull
[1] + 2,
2761 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
2762 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
2765 comparePublicKeyInfo(&pubKeys
[i
].info
, (CERT_PUBLIC_KEY_INFO
*)buf
);
2769 /* Test with bogus (not valid DER) parameters */
2770 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_PUBLIC_KEY_INFO
,
2771 bogusPubKeyInfo
, bogusPubKeyInfo
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
,
2772 NULL
, &buf
, &bufSize
);
2773 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_CORRUPT
||
2774 GetLastError() == OSS_DATA_ERROR
/* Win9x */),
2775 "Expected CRYPT_E_ASN1_CORRUPT or OSS_DATA_ERROR, got %08x\n",
2779 static const BYTE v1Cert
[] = { 0x30, 0x33, 0x02, 0x00, 0x30, 0x02, 0x06, 0x00,
2780 0x30, 0x22, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30,
2781 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30,
2782 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x07, 0x30,
2783 0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
2784 static const BYTE v2Cert
[] = { 0x30, 0x38, 0xa0, 0x03, 0x02, 0x01, 0x01, 0x02,
2785 0x00, 0x30, 0x02, 0x06, 0x00, 0x30, 0x22, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31,
2786 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x18, 0x0f,
2787 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30,
2788 0x30, 0x5a, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
2789 static const BYTE v3Cert
[] = { 0x30, 0x38, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02,
2790 0x00, 0x30, 0x02, 0x06, 0x00, 0x30, 0x22, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31,
2791 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x18, 0x0f,
2792 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30,
2793 0x30, 0x5a, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
2794 static const BYTE v1CertWithConstraints
[] = { 0x30, 0x4b, 0x02, 0x00, 0x30,
2795 0x02, 0x06, 0x00, 0x30, 0x22, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31,
2796 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36,
2797 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a,
2798 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00, 0xa3, 0x16, 0x30, 0x14,
2799 0x30, 0x12, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x08, 0x30,
2800 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
2801 static const BYTE v1CertWithSerial
[] = { 0x30, 0x4c, 0x02, 0x01, 0x01, 0x30,
2802 0x02, 0x06, 0x00, 0x30, 0x22, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31,
2803 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36,
2804 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a,
2805 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00, 0xa3, 0x16, 0x30, 0x14,
2806 0x30, 0x12, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x08, 0x30,
2807 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
2808 static const BYTE bigCert
[] = { 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
2809 0x00, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
2810 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x22,
2811 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30,
2812 0x30, 0x30, 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30,
2813 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x15, 0x31, 0x13, 0x30,
2814 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20,
2815 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01,
2816 0x00, 0xa3, 0x16, 0x30, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01,
2817 0x01, 0xff, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
2818 static const BYTE v1CertWithPubKey
[] = {
2819 0x30,0x81,0x95,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
2820 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
2821 0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
2822 0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
2823 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
2824 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
2825 0x67,0x00,0x30,0x22,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
2826 0x01,0x01,0x05,0x00,0x03,0x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
2827 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,
2828 0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,
2830 static const BYTE v1CertWithPubKeyNoNull
[] = {
2831 0x30,0x81,0x93,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
2832 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
2833 0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
2834 0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
2835 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
2836 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
2837 0x67,0x00,0x30,0x20,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
2838 0x01,0x01,0x03,0x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,
2839 0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,0x55,
2840 0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
2841 static const BYTE v1CertWithSubjectKeyId
[] = {
2842 0x30,0x7b,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,
2843 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
2844 0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
2845 0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
2846 0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,
2847 0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,
2848 0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x17,0x30,0x15,0x30,
2849 0x13,0x06,0x03,0x55,0x1d,0x0e,0x04,0x0c,0x04,0x0a,0x4a,0x75,0x61,0x6e,0x20,
2850 0x4c,0x61,0x6e,0x67,0x00 };
2852 static const BYTE serialNum
[] = { 0x01 };
2854 static void test_encodeCertToBeSigned(DWORD dwEncoding
)
2859 CERT_INFO info
= { 0 };
2860 static char oid_rsa_rsa
[] = szOID_RSA_RSA
;
2861 static char oid_subject_key_identifier
[] = szOID_SUBJECT_KEY_IDENTIFIER
;
2866 /* Test with NULL pvStructInfo (crashes on win9x) */
2867 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, NULL
,
2868 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
2869 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
2870 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
2872 /* Test with a V1 cert */
2873 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, &info
,
2874 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
2875 ok(ret
|| GetLastError() == OSS_BAD_PTR
/* Win9x */,
2876 "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2879 ok(size
== v1Cert
[1] + 2, "Expected size %d, got %d\n",
2880 v1Cert
[1] + 2, size
);
2881 ok(!memcmp(buf
, v1Cert
, size
), "Got unexpected value\n");
2885 info
.dwVersion
= CERT_V2
;
2886 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, &info
,
2887 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
2888 ok(ret
|| GetLastError() == OSS_BAD_PTR
/* Win9x */,
2889 "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2892 ok(size
== sizeof(v2Cert
), "Wrong size %d\n", size
);
2893 ok(!memcmp(buf
, v2Cert
, size
), "Got unexpected value\n");
2897 info
.dwVersion
= CERT_V3
;
2898 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, &info
,
2899 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
2900 ok(ret
|| GetLastError() == OSS_BAD_PTR
/* Win9x */,
2901 "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2904 ok(size
== sizeof(v3Cert
), "Wrong size %d\n", size
);
2905 ok(!memcmp(buf
, v3Cert
, size
), "Got unexpected value\n");
2908 /* see if a V1 cert can have basic constraints set (RFC3280 says no, but
2909 * API doesn't prevent it)
2911 info
.dwVersion
= CERT_V1
;
2912 info
.cExtension
= 1;
2913 info
.rgExtension
= &criticalExt
;
2914 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, &info
,
2915 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
2916 ok(ret
|| GetLastError() == OSS_BAD_PTR
/* Win9x */,
2917 "CryptEncodeObjectEx failed: %08x\n", GetLastError());
2920 ok(size
== sizeof(v1CertWithConstraints
), "Wrong size %d\n", size
);
2921 ok(!memcmp(buf
, v1CertWithConstraints
, size
), "Got unexpected value\n");
2924 /* test v1 cert with a serial number */
2925 info
.SerialNumber
.cbData
= sizeof(serialNum
);
2926 info
.SerialNumber
.pbData
= (BYTE
*)serialNum
;
2927 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, &info
,
2928 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
2931 ok(size
== sizeof(v1CertWithSerial
), "Wrong size %d\n", size
);
2932 ok(!memcmp(buf
, v1CertWithSerial
, size
), "Got unexpected value\n");
2935 /* Test v1 cert with an issuer name, a subject name, and a serial number */
2936 info
.Issuer
.cbData
= sizeof(encodedCommonName
);
2937 info
.Issuer
.pbData
= (BYTE
*)encodedCommonName
;
2938 info
.Subject
.cbData
= sizeof(encodedCommonName
);
2939 info
.Subject
.pbData
= (BYTE
*)encodedCommonName
;
2940 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, &info
,
2941 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
2944 ok(size
== sizeof(bigCert
), "Wrong size %d\n", size
);
2945 ok(!memcmp(buf
, bigCert
, size
), "Got unexpected value\n");
2948 /* Add a public key */
2949 info
.SubjectPublicKeyInfo
.Algorithm
.pszObjId
= oid_rsa_rsa
;
2950 info
.SubjectPublicKeyInfo
.PublicKey
.cbData
= sizeof(aKey
);
2951 info
.SubjectPublicKeyInfo
.PublicKey
.pbData
= (LPBYTE
)aKey
;
2952 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, &info
,
2953 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
2956 ok(size
== sizeof(v1CertWithPubKey
) ||
2957 size
== sizeof(v1CertWithPubKeyNoNull
), "Wrong size %d\n", size
);
2958 if (size
== sizeof(v1CertWithPubKey
))
2959 ok(!memcmp(buf
, v1CertWithPubKey
, size
), "Got unexpected value\n");
2960 else if (size
== sizeof(v1CertWithPubKeyNoNull
))
2961 ok(!memcmp(buf
, v1CertWithPubKeyNoNull
, size
),
2962 "Got unexpected value\n");
2965 /* Remove the public key, and add a subject key identifier extension */
2966 info
.SubjectPublicKeyInfo
.Algorithm
.pszObjId
= NULL
;
2967 info
.SubjectPublicKeyInfo
.PublicKey
.cbData
= 0;
2968 info
.SubjectPublicKeyInfo
.PublicKey
.pbData
= NULL
;
2969 ext
.pszObjId
= oid_subject_key_identifier
;
2970 ext
.fCritical
= FALSE
;
2971 ext
.Value
.cbData
= sizeof(octetCommonNameValue
);
2972 ext
.Value
.pbData
= octetCommonNameValue
;
2973 info
.cExtension
= 1;
2974 info
.rgExtension
= &ext
;
2975 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, &info
,
2976 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
2979 ok(size
== sizeof(v1CertWithSubjectKeyId
), "Wrong size %d\n", size
);
2980 ok(!memcmp(buf
, v1CertWithSubjectKeyId
, size
), "Unexpected value\n");
2985 static void test_decodeCertToBeSigned(DWORD dwEncoding
)
2987 static const BYTE
*corruptCerts
[] = { v1Cert
, v2Cert
, v3Cert
,
2988 v1CertWithConstraints
, v1CertWithSerial
};
2993 /* Test with NULL pbEncoded */
2994 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, NULL
, 0,
2995 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
2996 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_EOD
||
2997 GetLastError() == OSS_BAD_ARG
/* Win9x */),
2998 "Expected CRYPT_E_ASN1_EOD or OSS_BAD_ARG, got %08x\n", GetLastError());
3001 /* Crashes on win9x */
3002 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, NULL
, 1,
3003 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3004 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
3005 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
3007 /* The following certs all fail with CRYPT_E_ASN1_CORRUPT, because at a
3008 * minimum a cert must have a non-zero serial number, an issuer, and a
3011 for (i
= 0; i
< sizeof(corruptCerts
) / sizeof(corruptCerts
[0]); i
++)
3013 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
,
3014 corruptCerts
[i
], corruptCerts
[i
][1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
,
3016 ok(!ret
, "Expected failure\n");
3018 /* Now check with serial number, subject and issuer specified */
3019 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, bigCert
,
3020 sizeof(bigCert
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3021 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3024 CERT_INFO
*info
= (CERT_INFO
*)buf
;
3026 ok(size
>= sizeof(CERT_INFO
), "Wrong size %d\n", size
);
3027 ok(info
->SerialNumber
.cbData
== 1,
3028 "Expected serial number size 1, got %d\n", info
->SerialNumber
.cbData
);
3029 ok(*info
->SerialNumber
.pbData
== *serialNum
,
3030 "Expected serial number %d, got %d\n", *serialNum
,
3031 *info
->SerialNumber
.pbData
);
3032 ok(info
->Issuer
.cbData
== sizeof(encodedCommonName
),
3033 "Wrong size %d\n", info
->Issuer
.cbData
);
3034 ok(!memcmp(info
->Issuer
.pbData
, encodedCommonName
, info
->Issuer
.cbData
),
3035 "Unexpected issuer\n");
3036 ok(info
->Subject
.cbData
== sizeof(encodedCommonName
),
3037 "Wrong size %d\n", info
->Subject
.cbData
);
3038 ok(!memcmp(info
->Subject
.pbData
, encodedCommonName
,
3039 info
->Subject
.cbData
), "Unexpected subject\n");
3042 /* Check again with pub key specified */
3043 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
,
3044 v1CertWithPubKey
, sizeof(v1CertWithPubKey
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
3046 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3049 CERT_INFO
*info
= (CERT_INFO
*)buf
;
3051 ok(size
>= sizeof(CERT_INFO
), "Wrong size %d\n", size
);
3052 ok(info
->SerialNumber
.cbData
== 1,
3053 "Expected serial number size 1, got %d\n", info
->SerialNumber
.cbData
);
3054 ok(*info
->SerialNumber
.pbData
== *serialNum
,
3055 "Expected serial number %d, got %d\n", *serialNum
,
3056 *info
->SerialNumber
.pbData
);
3057 ok(info
->Issuer
.cbData
== sizeof(encodedCommonName
),
3058 "Wrong size %d\n", info
->Issuer
.cbData
);
3059 ok(!memcmp(info
->Issuer
.pbData
, encodedCommonName
, info
->Issuer
.cbData
),
3060 "Unexpected issuer\n");
3061 ok(info
->Subject
.cbData
== sizeof(encodedCommonName
),
3062 "Wrong size %d\n", info
->Subject
.cbData
);
3063 ok(!memcmp(info
->Subject
.pbData
, encodedCommonName
,
3064 info
->Subject
.cbData
), "Unexpected subject\n");
3065 ok(!strcmp(info
->SubjectPublicKeyInfo
.Algorithm
.pszObjId
,
3066 szOID_RSA_RSA
), "Expected szOID_RSA_RSA, got %s\n",
3067 info
->SubjectPublicKeyInfo
.Algorithm
.pszObjId
);
3068 ok(info
->SubjectPublicKeyInfo
.PublicKey
.cbData
== sizeof(aKey
),
3069 "Wrong size %d\n", info
->SubjectPublicKeyInfo
.PublicKey
.cbData
);
3070 ok(!memcmp(info
->SubjectPublicKeyInfo
.PublicKey
.pbData
, aKey
,
3071 sizeof(aKey
)), "Unexpected public key\n");
3076 static const BYTE hash
[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd,
3079 static const BYTE signedBigCert
[] = {
3080 0x30, 0x81, 0x93, 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06, 0x00, 0x30,
3081 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a,
3082 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x22, 0x18, 0x0f,
3083 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30,
3084 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30,
3085 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06,
3086 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61,
3087 0x6e, 0x67, 0x00, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00, 0xa3,
3088 0x16, 0x30, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff,
3089 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
3090 0x00, 0x03, 0x11, 0x00, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07,
3091 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 };
3093 static void test_encodeCert(DWORD dwEncoding
)
3095 /* Note the SignatureAlgorithm must match that in the encoded cert. Note
3096 * also that bigCert is a NULL-terminated string, so don't count its
3097 * last byte (otherwise the signed cert won't decode.)
3099 CERT_SIGNED_CONTENT_INFO info
= { { sizeof(bigCert
), (BYTE
*)bigCert
},
3100 { NULL
, { 0, NULL
} }, { sizeof(hash
), (BYTE
*)hash
, 0 } };
3105 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT
, &info
,
3106 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &bufSize
);
3107 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3110 ok(bufSize
== sizeof(signedBigCert
), "Wrong size %d\n", bufSize
);
3111 ok(!memcmp(buf
, signedBigCert
, bufSize
), "Unexpected cert\n");
3116 static void test_decodeCert(DWORD dwEncoding
)
3122 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT
, signedBigCert
,
3123 sizeof(signedBigCert
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3124 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3127 CERT_SIGNED_CONTENT_INFO
*info
= (CERT_SIGNED_CONTENT_INFO
*)buf
;
3129 ok(info
->ToBeSigned
.cbData
== sizeof(bigCert
),
3130 "Wrong cert size %d\n", info
->ToBeSigned
.cbData
);
3131 ok(!memcmp(info
->ToBeSigned
.pbData
, bigCert
, info
->ToBeSigned
.cbData
),
3132 "Unexpected cert\n");
3133 ok(info
->Signature
.cbData
== sizeof(hash
),
3134 "Wrong signature size %d\n", info
->Signature
.cbData
);
3135 ok(!memcmp(info
->Signature
.pbData
, hash
, info
->Signature
.cbData
),
3136 "Unexpected signature\n");
3139 /* A signed cert decodes as a CERT_INFO too */
3140 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_TO_BE_SIGNED
, signedBigCert
,
3141 sizeof(signedBigCert
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3142 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3145 CERT_INFO
*info
= (CERT_INFO
*)buf
;
3147 ok(size
>= sizeof(CERT_INFO
), "Wrong size %d\n", size
);
3148 ok(info
->SerialNumber
.cbData
== 1,
3149 "Expected serial number size 1, got %d\n", info
->SerialNumber
.cbData
);
3150 ok(*info
->SerialNumber
.pbData
== *serialNum
,
3151 "Expected serial number %d, got %d\n", *serialNum
,
3152 *info
->SerialNumber
.pbData
);
3153 ok(info
->Issuer
.cbData
== sizeof(encodedCommonName
),
3154 "Wrong size %d\n", info
->Issuer
.cbData
);
3155 ok(!memcmp(info
->Issuer
.pbData
, encodedCommonName
, info
->Issuer
.cbData
),
3156 "Unexpected issuer\n");
3157 ok(info
->Subject
.cbData
== sizeof(encodedCommonName
),
3158 "Wrong size %d\n", info
->Subject
.cbData
);
3159 ok(!memcmp(info
->Subject
.pbData
, encodedCommonName
,
3160 info
->Subject
.cbData
), "Unexpected subject\n");
3165 static const BYTE emptyDistPoint
[] = { 0x30, 0x02, 0x30, 0x00 };
3166 static const BYTE distPointWithUrl
[] = { 0x30, 0x19, 0x30, 0x17, 0xa0, 0x15,
3167 0xa0, 0x13, 0x86, 0x11, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x69,
3168 0x6e, 0x65, 0x68, 0x71, 0x2e, 0x6f, 0x72, 0x67 };
3169 static const BYTE distPointWithReason
[] = { 0x30, 0x06, 0x30, 0x04, 0x81, 0x02,
3171 static const BYTE distPointWithIssuer
[] = { 0x30, 0x17, 0x30, 0x15, 0xa2, 0x13,
3172 0x86, 0x11, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x69, 0x6e, 0x65,
3173 0x68, 0x71, 0x2e, 0x6f, 0x72, 0x67 };
3174 static const BYTE distPointWithUrlAndIssuer
[] = { 0x30, 0x2e, 0x30, 0x2c, 0xa0,
3175 0x15, 0xa0, 0x13, 0x86, 0x11, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77,
3176 0x69, 0x6e, 0x65, 0x68, 0x71, 0x2e, 0x6f, 0x72, 0x67, 0xa2, 0x13, 0x86, 0x11,
3177 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x69, 0x6e, 0x65, 0x68, 0x71,
3178 0x2e, 0x6f, 0x72, 0x67 };
3179 static const BYTE crlReason
= CRL_REASON_KEY_COMPROMISE
|
3180 CRL_REASON_AFFILIATION_CHANGED
;
3182 static void test_encodeCRLDistPoints(DWORD dwEncoding
)
3184 CRL_DIST_POINTS_INFO info
= { 0 };
3185 CRL_DIST_POINT point
= { { 0 } };
3186 CERT_ALT_NAME_ENTRY entry
= { 0 };
3191 /* Test with an empty info */
3192 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CRL_DIST_POINTS
, &info
,
3193 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3194 ok(!ret
&& GetLastError() == E_INVALIDARG
,
3195 "Expected E_INVALIDARG, got %08x\n", GetLastError());
3196 /* Test with one empty dist point */
3197 info
.cDistPoint
= 1;
3198 info
.rgDistPoint
= &point
;
3199 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CRL_DIST_POINTS
, &info
,
3200 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3201 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3204 ok(size
== sizeof(emptyDistPoint
), "Wrong size %d\n", size
);
3205 ok(!memcmp(buf
, emptyDistPoint
, size
), "Unexpected value\n");
3208 /* A dist point with an invalid name */
3209 point
.DistPointName
.dwDistPointNameChoice
= CRL_DIST_POINT_FULL_NAME
;
3210 entry
.dwAltNameChoice
= CERT_ALT_NAME_URL
;
3211 U(entry
).pwszURL
= (LPWSTR
)nihongoURL
;
3212 U(point
.DistPointName
).FullName
.cAltEntry
= 1;
3213 U(point
.DistPointName
).FullName
.rgAltEntry
= &entry
;
3214 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CRL_DIST_POINTS
, &info
,
3215 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3216 ok(!ret
&& GetLastError() == CRYPT_E_INVALID_IA5_STRING
,
3217 "Expected CRYPT_E_INVALID_IA5_STRING, got %08x\n", GetLastError());
3218 /* The first invalid character is at index 7 */
3219 ok(GET_CERT_ALT_NAME_VALUE_ERR_INDEX(size
) == 7,
3220 "Expected invalid char at index 7, got %d\n",
3221 GET_CERT_ALT_NAME_VALUE_ERR_INDEX(size
));
3222 /* A dist point with (just) a valid name */
3223 U(entry
).pwszURL
= (LPWSTR
)url
;
3224 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CRL_DIST_POINTS
, &info
,
3225 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3226 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3229 ok(size
== sizeof(distPointWithUrl
), "Wrong size %d\n", size
);
3230 ok(!memcmp(buf
, distPointWithUrl
, size
), "Unexpected value\n");
3233 /* A dist point with (just) reason flags */
3234 point
.DistPointName
.dwDistPointNameChoice
= CRL_DIST_POINT_NO_NAME
;
3235 point
.ReasonFlags
.cbData
= sizeof(crlReason
);
3236 point
.ReasonFlags
.pbData
= (LPBYTE
)&crlReason
;
3237 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CRL_DIST_POINTS
, &info
,
3238 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3239 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3242 ok(size
== sizeof(distPointWithReason
), "Wrong size %d\n", size
);
3243 ok(!memcmp(buf
, distPointWithReason
, size
), "Unexpected value\n");
3246 /* A dist point with just an issuer */
3247 point
.ReasonFlags
.cbData
= 0;
3248 point
.CRLIssuer
.cAltEntry
= 1;
3249 point
.CRLIssuer
.rgAltEntry
= &entry
;
3250 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CRL_DIST_POINTS
, &info
,
3251 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3252 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3255 ok(size
== sizeof(distPointWithIssuer
), "Wrong size %d\n", size
);
3256 ok(!memcmp(buf
, distPointWithIssuer
, size
), "Unexpected value\n");
3259 /* A dist point with both a name and an issuer */
3260 point
.DistPointName
.dwDistPointNameChoice
= CRL_DIST_POINT_FULL_NAME
;
3261 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CRL_DIST_POINTS
, &info
,
3262 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3263 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3266 ok(size
== sizeof(distPointWithUrlAndIssuer
),
3267 "Wrong size %d\n", size
);
3268 ok(!memcmp(buf
, distPointWithUrlAndIssuer
, size
), "Unexpected value\n");
3273 static void test_decodeCRLDistPoints(DWORD dwEncoding
)
3278 PCRL_DIST_POINTS_INFO info
;
3279 PCRL_DIST_POINT point
;
3280 PCERT_ALT_NAME_ENTRY entry
;
3282 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CRL_DIST_POINTS
,
3283 emptyDistPoint
, emptyDistPoint
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
,
3285 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3288 info
= (PCRL_DIST_POINTS_INFO
)buf
;
3289 ok(size
>= sizeof(CRL_DIST_POINTS_INFO
) + sizeof(CRL_DIST_POINT
),
3290 "Wrong size %d\n", size
);
3291 ok(info
->cDistPoint
== 1, "Expected 1 dist points, got %d\n",
3293 point
= info
->rgDistPoint
;
3294 ok(point
->DistPointName
.dwDistPointNameChoice
== CRL_DIST_POINT_NO_NAME
,
3295 "Expected CRL_DIST_POINT_NO_NAME, got %d\n",
3296 point
->DistPointName
.dwDistPointNameChoice
);
3297 ok(point
->ReasonFlags
.cbData
== 0, "Expected no reason\n");
3298 ok(point
->CRLIssuer
.cAltEntry
== 0, "Expected no issuer\n");
3301 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CRL_DIST_POINTS
,
3302 distPointWithUrl
, distPointWithUrl
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
,
3304 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3307 info
= (PCRL_DIST_POINTS_INFO
)buf
;
3308 ok(size
>= sizeof(CRL_DIST_POINTS_INFO
) + sizeof(CRL_DIST_POINT
),
3309 "Wrong size %d\n", size
);
3310 ok(info
->cDistPoint
== 1, "Expected 1 dist points, got %d\n",
3312 point
= info
->rgDistPoint
;
3313 ok(point
->DistPointName
.dwDistPointNameChoice
==
3314 CRL_DIST_POINT_FULL_NAME
,
3315 "Expected CRL_DIST_POINT_FULL_NAME, got %d\n",
3316 point
->DistPointName
.dwDistPointNameChoice
);
3317 ok(U(point
->DistPointName
).FullName
.cAltEntry
== 1,
3318 "Expected 1 name entry, got %d\n",
3319 U(point
->DistPointName
).FullName
.cAltEntry
);
3320 entry
= U(point
->DistPointName
).FullName
.rgAltEntry
;
3321 ok(entry
->dwAltNameChoice
== CERT_ALT_NAME_URL
,
3322 "Expected CERT_ALT_NAME_URL, got %d\n", entry
->dwAltNameChoice
);
3323 ok(!lstrcmpW(U(*entry
).pwszURL
, url
), "Unexpected name\n");
3324 ok(point
->ReasonFlags
.cbData
== 0, "Expected no reason\n");
3325 ok(point
->CRLIssuer
.cAltEntry
== 0, "Expected no issuer\n");
3328 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CRL_DIST_POINTS
,
3329 distPointWithReason
, distPointWithReason
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
,
3331 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3334 info
= (PCRL_DIST_POINTS_INFO
)buf
;
3335 ok(size
>= sizeof(CRL_DIST_POINTS_INFO
) + sizeof(CRL_DIST_POINT
),
3336 "Wrong size %d\n", size
);
3337 ok(info
->cDistPoint
== 1, "Expected 1 dist points, got %d\n",
3339 point
= info
->rgDistPoint
;
3340 ok(point
->DistPointName
.dwDistPointNameChoice
==
3341 CRL_DIST_POINT_NO_NAME
,
3342 "Expected CRL_DIST_POINT_NO_NAME, got %d\n",
3343 point
->DistPointName
.dwDistPointNameChoice
);
3344 ok(point
->ReasonFlags
.cbData
== sizeof(crlReason
),
3345 "Expected reason length\n");
3346 ok(!memcmp(point
->ReasonFlags
.pbData
, &crlReason
, sizeof(crlReason
)),
3347 "Unexpected reason\n");
3348 ok(point
->CRLIssuer
.cAltEntry
== 0, "Expected no issuer\n");
3351 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CRL_DIST_POINTS
,
3352 distPointWithUrlAndIssuer
, distPointWithUrlAndIssuer
[1] + 2,
3353 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3354 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3357 info
= (PCRL_DIST_POINTS_INFO
)buf
;
3358 ok(size
>= sizeof(CRL_DIST_POINTS_INFO
) + sizeof(CRL_DIST_POINT
),
3359 "Wrong size %d\n", size
);
3360 ok(info
->cDistPoint
== 1, "Expected 1 dist points, got %d\n",
3362 point
= info
->rgDistPoint
;
3363 ok(point
->DistPointName
.dwDistPointNameChoice
==
3364 CRL_DIST_POINT_FULL_NAME
,
3365 "Expected CRL_DIST_POINT_FULL_NAME, got %d\n",
3366 point
->DistPointName
.dwDistPointNameChoice
);
3367 ok(U(point
->DistPointName
).FullName
.cAltEntry
== 1,
3368 "Expected 1 name entry, got %d\n",
3369 U(point
->DistPointName
).FullName
.cAltEntry
);
3370 entry
= U(point
->DistPointName
).FullName
.rgAltEntry
;
3371 ok(entry
->dwAltNameChoice
== CERT_ALT_NAME_URL
,
3372 "Expected CERT_ALT_NAME_URL, got %d\n", entry
->dwAltNameChoice
);
3373 ok(!lstrcmpW(U(*entry
).pwszURL
, url
), "Unexpected name\n");
3374 ok(point
->ReasonFlags
.cbData
== 0, "Expected no reason\n");
3375 ok(point
->CRLIssuer
.cAltEntry
== 1,
3376 "Expected 1 issuer entry, got %d\n", point
->CRLIssuer
.cAltEntry
);
3377 entry
= point
->CRLIssuer
.rgAltEntry
;
3378 ok(entry
->dwAltNameChoice
== CERT_ALT_NAME_URL
,
3379 "Expected CERT_ALT_NAME_URL, got %d\n", entry
->dwAltNameChoice
);
3380 ok(!lstrcmpW(U(*entry
).pwszURL
, url
), "Unexpected name\n");
3385 static const BYTE badFlagsIDP
[] = { 0x30,0x06,0x81,0x01,0xff,0x82,0x01,0xff };
3386 static const BYTE emptyNameIDP
[] = { 0x30,0x04,0xa0,0x02,0xa0,0x00 };
3387 static const BYTE urlIDP
[] = { 0x30,0x17,0xa0,0x15,0xa0,0x13,0x86,0x11,0x68,
3388 0x74,0x74,0x70,0x3a,0x2f,0x2f,0x77,0x69,0x6e,0x65,0x68,0x71,0x2e,0x6f,0x72,
3391 static void test_encodeCRLIssuingDistPoint(DWORD dwEncoding
)
3396 CRL_ISSUING_DIST_POINT point
= { { 0 } };
3397 CERT_ALT_NAME_ENTRY entry
;
3399 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ISSUING_DIST_POINT
, NULL
,
3400 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3401 if (!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
)
3403 skip("no X509_ISSUING_DIST_POINT encode support\n");
3406 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
3407 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
3408 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ISSUING_DIST_POINT
, &point
,
3409 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3410 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3413 ok(size
== sizeof(emptySequence
), "Unexpected size %d\n", size
);
3414 ok(!memcmp(buf
, emptySequence
, size
), "Unexpected value\n");
3417 /* nonsensical flags */
3418 point
.fOnlyContainsUserCerts
= TRUE
;
3419 point
.fOnlyContainsCACerts
= TRUE
;
3420 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ISSUING_DIST_POINT
, &point
,
3421 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3422 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3425 ok(size
== sizeof(badFlagsIDP
), "Unexpected size %d\n", size
);
3426 ok(!memcmp(buf
, badFlagsIDP
, size
), "Unexpected value\n");
3429 /* unimplemented name type */
3430 point
.fOnlyContainsCACerts
= point
.fOnlyContainsUserCerts
= FALSE
;
3431 point
.DistPointName
.dwDistPointNameChoice
= CRL_DIST_POINT_ISSUER_RDN_NAME
;
3432 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ISSUING_DIST_POINT
, &point
,
3433 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3434 ok(!ret
&& GetLastError() == E_INVALIDARG
,
3435 "Expected E_INVALIDARG, got %08x\n", GetLastError());
3437 point
.DistPointName
.dwDistPointNameChoice
= CRL_DIST_POINT_FULL_NAME
;
3438 U(point
.DistPointName
).FullName
.cAltEntry
= 0;
3439 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ISSUING_DIST_POINT
, &point
,
3440 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3441 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3444 ok(size
== sizeof(emptyNameIDP
), "Unexpected size %d\n", size
);
3445 ok(!memcmp(buf
, emptyNameIDP
, size
), "Unexpected value\n");
3448 /* name with URL entry */
3449 entry
.dwAltNameChoice
= CERT_ALT_NAME_URL
;
3450 U(entry
).pwszURL
= (LPWSTR
)url
;
3451 U(point
.DistPointName
).FullName
.cAltEntry
= 1;
3452 U(point
.DistPointName
).FullName
.rgAltEntry
= &entry
;
3453 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ISSUING_DIST_POINT
, &point
,
3454 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3455 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3458 ok(size
== sizeof(urlIDP
), "Unexpected size %d\n", size
);
3459 ok(!memcmp(buf
, urlIDP
, size
), "Unexpected value\n");
3464 static void compareAltNameEntry(const CERT_ALT_NAME_ENTRY
*expected
,
3465 const CERT_ALT_NAME_ENTRY
*got
)
3467 ok(expected
->dwAltNameChoice
== got
->dwAltNameChoice
,
3468 "Expected name choice %d, got %d\n", expected
->dwAltNameChoice
,
3469 got
->dwAltNameChoice
);
3470 if (expected
->dwAltNameChoice
== got
->dwAltNameChoice
)
3472 switch (got
->dwAltNameChoice
)
3474 case CERT_ALT_NAME_RFC822_NAME
:
3475 case CERT_ALT_NAME_DNS_NAME
:
3476 case CERT_ALT_NAME_EDI_PARTY_NAME
:
3477 case CERT_ALT_NAME_URL
:
3478 case CERT_ALT_NAME_REGISTERED_ID
:
3479 ok((!U(*expected
).pwszURL
&& !U(*got
).pwszURL
) ||
3480 (!U(*expected
).pwszURL
&& !lstrlenW(U(*got
).pwszURL
)) ||
3481 (!U(*got
).pwszURL
&& !lstrlenW(U(*expected
).pwszURL
)) ||
3482 !lstrcmpW(U(*expected
).pwszURL
, U(*got
).pwszURL
),
3483 "Unexpected name\n");
3485 case CERT_ALT_NAME_X400_ADDRESS
:
3486 case CERT_ALT_NAME_DIRECTORY_NAME
:
3487 case CERT_ALT_NAME_IP_ADDRESS
:
3488 ok(U(*got
).IPAddress
.cbData
== U(*expected
).IPAddress
.cbData
,
3489 "Unexpected IP address length %d\n", U(*got
).IPAddress
.cbData
);
3490 ok(!memcmp(U(*got
).IPAddress
.pbData
, U(*got
).IPAddress
.pbData
,
3491 U(*got
).IPAddress
.cbData
), "Unexpected value\n");
3497 static void compareAltNameInfo(const CERT_ALT_NAME_INFO
*expected
,
3498 const CERT_ALT_NAME_INFO
*got
)
3502 ok(expected
->cAltEntry
== got
->cAltEntry
, "Expected %d entries, got %d\n",
3503 expected
->cAltEntry
, got
->cAltEntry
);
3504 for (i
= 0; i
< min(expected
->cAltEntry
, got
->cAltEntry
); i
++)
3505 compareAltNameEntry(&expected
->rgAltEntry
[i
], &got
->rgAltEntry
[i
]);
3508 static void compareDistPointName(const CRL_DIST_POINT_NAME
*expected
,
3509 const CRL_DIST_POINT_NAME
*got
)
3511 ok(got
->dwDistPointNameChoice
== expected
->dwDistPointNameChoice
,
3512 "Unexpected name choice %d\n", got
->dwDistPointNameChoice
);
3513 if (got
->dwDistPointNameChoice
== CRL_DIST_POINT_FULL_NAME
)
3514 compareAltNameInfo(&(U(*expected
).FullName
), &(U(*got
).FullName
));
3517 static void compareCRLIssuingDistPoints(const CRL_ISSUING_DIST_POINT
*expected
,
3518 const CRL_ISSUING_DIST_POINT
*got
)
3520 compareDistPointName(&expected
->DistPointName
, &got
->DistPointName
);
3521 ok(got
->fOnlyContainsUserCerts
== expected
->fOnlyContainsUserCerts
,
3522 "Unexpected fOnlyContainsUserCerts\n");
3523 ok(got
->fOnlyContainsCACerts
== expected
->fOnlyContainsCACerts
,
3524 "Unexpected fOnlyContainsCACerts\n");
3525 ok(got
->OnlySomeReasonFlags
.cbData
== expected
->OnlySomeReasonFlags
.cbData
,
3526 "Unexpected reason flags\n");
3527 ok(got
->fIndirectCRL
== expected
->fIndirectCRL
,
3528 "Unexpected fIndirectCRL\n");
3531 static void test_decodeCRLIssuingDistPoint(DWORD dwEncoding
)
3536 CRL_ISSUING_DIST_POINT point
= { { 0 } };
3538 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ISSUING_DIST_POINT
,
3539 emptySequence
, emptySequence
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
,
3541 if (!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
)
3543 skip("no X509_ISSUING_DIST_POINT decode support\n");
3546 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3549 compareCRLIssuingDistPoints(&point
, (PCRL_ISSUING_DIST_POINT
)buf
);
3552 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ISSUING_DIST_POINT
,
3553 badFlagsIDP
, badFlagsIDP
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
,
3555 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3558 point
.fOnlyContainsUserCerts
= point
.fOnlyContainsCACerts
= TRUE
;
3559 compareCRLIssuingDistPoints(&point
, (PCRL_ISSUING_DIST_POINT
)buf
);
3562 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ISSUING_DIST_POINT
,
3563 emptyNameIDP
, emptyNameIDP
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
,
3565 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3568 point
.fOnlyContainsCACerts
= point
.fOnlyContainsUserCerts
= FALSE
;
3569 point
.DistPointName
.dwDistPointNameChoice
= CRL_DIST_POINT_FULL_NAME
;
3570 U(point
.DistPointName
).FullName
.cAltEntry
= 0;
3571 compareCRLIssuingDistPoints(&point
, (PCRL_ISSUING_DIST_POINT
)buf
);
3574 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ISSUING_DIST_POINT
,
3575 urlIDP
, urlIDP
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3576 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
3579 CERT_ALT_NAME_ENTRY entry
;
3581 entry
.dwAltNameChoice
= CERT_ALT_NAME_URL
;
3582 U(entry
).pwszURL
= (LPWSTR
)url
;
3583 U(point
.DistPointName
).FullName
.cAltEntry
= 1;
3584 U(point
.DistPointName
).FullName
.rgAltEntry
= &entry
;
3585 compareCRLIssuingDistPoints(&point
, (PCRL_ISSUING_DIST_POINT
)buf
);
3590 static const BYTE v1CRL
[] = { 0x30, 0x15, 0x30, 0x02, 0x06, 0x00, 0x18, 0x0f,
3591 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30,
3593 static const BYTE v2CRL
[] = { 0x30, 0x18, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
3594 0x00, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30,
3595 0x30, 0x30, 0x30, 0x30, 0x5a };
3596 static const BYTE v1CRLWithIssuer
[] = { 0x30, 0x2c, 0x30, 0x02, 0x06, 0x00,
3597 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a,
3598 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x18, 0x0f, 0x31,
3599 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
3601 static const BYTE v1CRLWithIssuerAndEmptyEntry
[] = { 0x30, 0x43, 0x30, 0x02,
3602 0x06, 0x00, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03,
3603 0x13, 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x18,
3604 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30,
3605 0x30, 0x30, 0x5a, 0x30, 0x15, 0x30, 0x13, 0x02, 0x00, 0x18, 0x0f, 0x31, 0x36,
3606 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a };
3607 static const BYTE v1CRLWithIssuerAndEntry
[] = { 0x30, 0x44, 0x30, 0x02, 0x06,
3608 0x00, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
3609 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x18, 0x0f,
3610 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30,
3611 0x30, 0x5a, 0x30, 0x16, 0x30, 0x14, 0x02, 0x01, 0x01, 0x18, 0x0f, 0x31, 0x36,
3612 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a };
3613 static const BYTE v1CRLWithEntryExt
[] = { 0x30,0x5a,0x30,0x02,0x06,0x00,0x30,
3614 0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
3615 0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
3616 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x2c,0x30,0x2a,0x02,0x01,
3617 0x01,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,
3618 0x30,0x30,0x5a,0x30,0x14,0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,
3619 0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
3620 static const BYTE v1CRLWithExt
[] = { 0x30,0x5c,0x30,0x02,0x06,0x00,0x30,0x15,
3621 0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
3622 0x20,0x4c,0x61,0x6e,0x67,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
3623 0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x16,0x30,0x14,0x02,0x01,0x01,
3624 0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,
3625 0x30,0x5a,0xa0,0x16,0x30,0x14,0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,
3626 0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
3627 static const BYTE v2CRLWithExt
[] = { 0x30,0x5c,0x02,0x01,0x01,0x30,0x02,0x06,
3628 0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,
3629 0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,
3630 0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x16,0x30,0x14,
3631 0x02,0x01,0x01,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,
3632 0x30,0x30,0x30,0x30,0x5a,0xa0,0x13,0x30,0x11,0x30,0x0f,0x06,0x03,0x55,0x1d,
3633 0x13,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
3634 static const BYTE v2CRLWithIssuingDistPoint
[] = { 0x30,0x5c,0x02,0x01,0x01,
3635 0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
3636 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x18,0x0f,0x31,
3637 0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,
3638 0x16,0x30,0x14,0x02,0x01,0x01,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
3639 0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0xa0,0x13,0x30,0x11,0x30,0x0f,0x06,
3640 0x03,0x55,0x1d,0x13,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
3642 static void test_encodeCRLToBeSigned(DWORD dwEncoding
)
3646 static CHAR oid_issuing_dist_point
[] = szOID_ISSUING_DIST_POINT
;
3648 CRL_INFO info
= { 0 };
3649 CRL_ENTRY entry
= { { 0 }, { 0 }, 0, 0 };
3652 /* Test with a V1 CRL */
3653 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
, &info
,
3654 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3655 ok(ret
|| broken(GetLastError() == OSS_DATA_ERROR
/* Win9x */),
3656 "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3659 ok(size
== sizeof(v1CRL
), "Wrong size %d\n", size
);
3660 ok(!memcmp(buf
, v1CRL
, size
), "Got unexpected value\n");
3664 info
.dwVersion
= CRL_V2
;
3665 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
, &info
,
3666 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3667 ok(ret
|| broken(GetLastError() == OSS_DATA_ERROR
/* Win9x */),
3668 "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3671 ok(size
== v2CRL
[1] + 2, "Expected size %d, got %d\n",
3672 v2CRL
[1] + 2, size
);
3673 ok(!memcmp(buf
, v2CRL
, size
), "Got unexpected value\n");
3676 /* v1 CRL with a name */
3677 info
.dwVersion
= CRL_V1
;
3678 info
.Issuer
.cbData
= sizeof(encodedCommonName
);
3679 info
.Issuer
.pbData
= (BYTE
*)encodedCommonName
;
3680 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
, &info
,
3681 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3682 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3685 ok(size
== sizeof(v1CRLWithIssuer
), "Wrong size %d\n", size
);
3686 ok(!memcmp(buf
, v1CRLWithIssuer
, size
), "Got unexpected value\n");
3691 /* v1 CRL with a name and a NULL entry pointer (crashes on win9x) */
3693 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
, &info
,
3694 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3695 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
3696 "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
3698 /* now set an empty entry */
3700 info
.rgCRLEntry
= &entry
;
3701 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
, &info
,
3702 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3705 ok(size
== sizeof(v1CRLWithIssuerAndEmptyEntry
),
3706 "Wrong size %d\n", size
);
3707 ok(!memcmp(buf
, v1CRLWithIssuerAndEmptyEntry
, size
),
3708 "Got unexpected value\n");
3711 /* an entry with a serial number */
3712 entry
.SerialNumber
.cbData
= sizeof(serialNum
);
3713 entry
.SerialNumber
.pbData
= (BYTE
*)serialNum
;
3714 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
, &info
,
3715 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3718 ok(size
== sizeof(v1CRLWithIssuerAndEntry
),
3719 "Wrong size %d\n", size
);
3720 ok(!memcmp(buf
, v1CRLWithIssuerAndEntry
, size
),
3721 "Got unexpected value\n");
3724 /* an entry with an extension */
3725 entry
.cExtension
= 1;
3726 entry
.rgExtension
= &criticalExt
;
3727 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
, &info
,
3728 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3729 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3732 ok(size
== sizeof(v1CRLWithEntryExt
), "Wrong size %d\n", size
);
3733 ok(!memcmp(buf
, v1CRLWithEntryExt
, size
), "Got unexpected value\n");
3736 /* a CRL with an extension */
3737 entry
.cExtension
= 0;
3738 info
.cExtension
= 1;
3739 info
.rgExtension
= &criticalExt
;
3740 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
, &info
,
3741 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3742 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3745 ok(size
== sizeof(v1CRLWithExt
), "Wrong size %d\n", size
);
3746 ok(!memcmp(buf
, v1CRLWithExt
, size
), "Got unexpected value\n");
3749 /* a v2 CRL with an extension, this time non-critical */
3750 info
.dwVersion
= CRL_V2
;
3751 info
.rgExtension
= &nonCriticalExt
;
3752 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
, &info
,
3753 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3754 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3757 ok(size
== sizeof(v2CRLWithExt
), "Wrong size %d\n", size
);
3758 ok(!memcmp(buf
, v2CRLWithExt
, size
), "Got unexpected value\n");
3761 /* a v2 CRL with an issuing dist point extension */
3762 ext
.pszObjId
= oid_issuing_dist_point
;
3763 ext
.fCritical
= TRUE
;
3764 ext
.Value
.cbData
= sizeof(urlIDP
);
3765 ext
.Value
.pbData
= (LPBYTE
)urlIDP
;
3766 entry
.rgExtension
= &ext
;
3767 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
, &info
,
3768 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
3769 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
3772 ok(size
== sizeof(v2CRLWithIssuingDistPoint
), "Wrong size %d\n", size
);
3773 ok(!memcmp(buf
, v2CRLWithIssuingDistPoint
, size
), "Unexpected value\n");
3778 static const BYTE verisignCRL
[] = { 0x30, 0x82, 0x01, 0xb1, 0x30, 0x82, 0x01,
3779 0x1a, 0x02, 0x01, 0x01, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
3780 0x0d, 0x01, 0x01, 0x02, 0x05, 0x00, 0x30, 0x61, 0x31, 0x11, 0x30, 0x0f, 0x06,
3781 0x03, 0x55, 0x04, 0x07, 0x13, 0x08, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65,
3782 0x74, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0e, 0x56,
3783 0x65, 0x72, 0x69, 0x53, 0x69, 0x67, 0x6e, 0x2c, 0x20, 0x49, 0x6e, 0x63, 0x2e,
3784 0x31, 0x33, 0x30, 0x31, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x2a, 0x56, 0x65,
3785 0x72, 0x69, 0x53, 0x69, 0x67, 0x6e, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x72,
3786 0x63, 0x69, 0x61, 0x6c, 0x20, 0x53, 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65,
3787 0x20, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x73, 0x20, 0x43,
3788 0x41, 0x17, 0x0d, 0x30, 0x31, 0x30, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30,
3789 0x30, 0x30, 0x5a, 0x17, 0x0d, 0x30, 0x34, 0x30, 0x31, 0x30, 0x37, 0x32, 0x33,
3790 0x35, 0x39, 0x35, 0x39, 0x5a, 0x30, 0x69, 0x30, 0x21, 0x02, 0x10, 0x1b, 0x51,
3791 0x90, 0xf7, 0x37, 0x24, 0x39, 0x9c, 0x92, 0x54, 0xcd, 0x42, 0x46, 0x37, 0x99,
3792 0x6a, 0x17, 0x0d, 0x30, 0x31, 0x30, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31,
3793 0x32, 0x34, 0x5a, 0x30, 0x21, 0x02, 0x10, 0x75, 0x0e, 0x40, 0xff, 0x97, 0xf0,
3794 0x47, 0xed, 0xf5, 0x56, 0xc7, 0x08, 0x4e, 0xb1, 0xab, 0xfd, 0x17, 0x0d, 0x30,
3795 0x31, 0x30, 0x31, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x5a, 0x30,
3796 0x21, 0x02, 0x10, 0x77, 0xe6, 0x5a, 0x43, 0x59, 0x93, 0x5d, 0x5f, 0x7a, 0x75,
3797 0x80, 0x1a, 0xcd, 0xad, 0xc2, 0x22, 0x17, 0x0d, 0x30, 0x30, 0x30, 0x38, 0x33,
3798 0x31, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x5a, 0xa0, 0x1a, 0x30, 0x18, 0x30,
3799 0x09, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04, 0x02, 0x30, 0x00, 0x30, 0x0b, 0x06,
3800 0x03, 0x55, 0x1d, 0x0f, 0x04, 0x04, 0x03, 0x02, 0x05, 0xa0, 0x30, 0x0d, 0x06,
3801 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x02, 0x05, 0x00, 0x03,
3802 0x81, 0x81, 0x00, 0x18, 0x2c, 0xe8, 0xfc, 0x16, 0x6d, 0x91, 0x4a, 0x3d, 0x88,
3803 0x54, 0x48, 0x5d, 0xb8, 0x11, 0xbf, 0x64, 0xbb, 0xf9, 0xda, 0x59, 0x19, 0xdd,
3804 0x0e, 0x65, 0xab, 0xc0, 0x0c, 0xfa, 0x67, 0x7e, 0x21, 0x1e, 0x83, 0x0e, 0xcf,
3805 0x9b, 0x89, 0x8a, 0xcf, 0x0c, 0x4b, 0xc1, 0x39, 0x9d, 0xe7, 0x6a, 0xac, 0x46,
3806 0x74, 0x6a, 0x91, 0x62, 0x22, 0x0d, 0xc4, 0x08, 0xbd, 0xf5, 0x0a, 0x90, 0x7f,
3807 0x06, 0x21, 0x3d, 0x7e, 0xa7, 0xaa, 0x5e, 0xcd, 0x22, 0x15, 0xe6, 0x0c, 0x75,
3808 0x8e, 0x6e, 0xad, 0xf1, 0x84, 0xe4, 0x22, 0xb4, 0x30, 0x6f, 0xfb, 0x64, 0x8f,
3809 0xd7, 0x80, 0x43, 0xf5, 0x19, 0x18, 0x66, 0x1d, 0x72, 0xa3, 0xe3, 0x94, 0x82,
3810 0x28, 0x52, 0xa0, 0x06, 0x4e, 0xb1, 0xc8, 0x92, 0x0c, 0x97, 0xbe, 0x15, 0x07,
3811 0xab, 0x7a, 0xc9, 0xea, 0x08, 0x67, 0x43, 0x4d, 0x51, 0x63, 0x3b, 0x9c, 0x9c,
3813 static const BYTE verisignCRLWithLotsOfEntries
[] = {
3814 0x30,0x82,0x1d,0xbd,0x30,0x82,0x1d,0x26,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,
3815 0x86,0xf7,0x0d,0x01,0x01,0x04,0x05,0x00,0x30,0x61,0x31,0x11,0x30,0x0f,0x06,
3816 0x03,0x55,0x04,0x07,0x13,0x08,0x49,0x6e,0x74,0x65,0x72,0x6e,0x65,0x74,0x31,
3817 0x17,0x30,0x15,0x06,0x03,0x55,0x04,0x0a,0x13,0x0e,0x56,0x65,0x72,0x69,0x53,
3818 0x69,0x67,0x6e,0x2c,0x20,0x49,0x6e,0x63,0x2e,0x31,0x33,0x30,0x31,0x06,0x03,
3819 0x55,0x04,0x0b,0x13,0x2a,0x56,0x65,0x72,0x69,0x53,0x69,0x67,0x6e,0x20,0x43,
3820 0x6f,0x6d,0x6d,0x65,0x72,0x63,0x69,0x61,0x6c,0x20,0x53,0x6f,0x66,0x74,0x77,
3821 0x61,0x72,0x65,0x20,0x50,0x75,0x62,0x6c,0x69,0x73,0x68,0x65,0x72,0x73,0x20,
3822 0x43,0x41,0x17,0x0d,0x30,0x34,0x30,0x33,0x33,0x31,0x30,0x30,0x30,0x30,0x30,
3823 0x30,0x5a,0x17,0x0d,0x30,0x34,0x30,0x35,0x33,0x31,0x32,0x33,0x35,0x39,0x35,
3824 0x39,0x5a,0x30,0x82,0x1c,0x92,0x30,0x21,0x02,0x10,0x01,0x22,0xb8,0xb2,0xf3,
3825 0x76,0x42,0xcc,0x48,0x71,0xb6,0x11,0xbf,0xd1,0xcf,0xda,0x17,0x0d,0x30,0x32,
3826 0x30,0x34,0x31,0x35,0x31,0x35,0x34,0x30,0x32,0x34,0x5a,0x30,0x21,0x02,0x10,
3827 0x01,0x83,0x93,0xfb,0x96,0xde,0x1d,0x89,0x4e,0xc3,0x47,0x9c,0xe1,0x60,0x13,
3828 0x63,0x17,0x0d,0x30,0x32,0x30,0x35,0x30,0x39,0x31,0x33,0x35,0x37,0x35,0x38,
3829 0x5a,0x30,0x21,0x02,0x10,0x01,0xdc,0xdb,0x63,0xd4,0xc9,0x9f,0x31,0xb8,0x16,
3830 0xf9,0x2c,0xf5,0xb1,0x08,0x8e,0x17,0x0d,0x30,0x32,0x30,0x34,0x31,0x38,0x31,
3831 0x37,0x34,0x36,0x31,0x34,0x5a,0x30,0x21,0x02,0x10,0x02,0x1a,0xa6,0xaf,0x94,
3832 0x71,0xf0,0x07,0x6e,0xf1,0x17,0xe4,0xd4,0x17,0x82,0xdb,0x17,0x0d,0x30,0x32,
3833 0x30,0x37,0x31,0x39,0x32,0x31,0x32,0x38,0x33,0x31,0x5a,0x30,0x21,0x02,0x10,
3834 0x02,0x4c,0xe8,0x9d,0xfd,0x5f,0x77,0x4d,0x4b,0xf5,0x79,0x8b,0xb1,0x08,0x67,
3835 0xac,0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x32,0x30,0x36,0x31,0x36,0x35,0x30,
3836 0x5a,0x30,0x21,0x02,0x10,0x02,0x59,0xae,0x6c,0x4c,0x21,0xf1,0x59,0x49,0x87,
3837 0xb0,0x95,0xf9,0x65,0xf3,0x20,0x17,0x0d,0x30,0x33,0x30,0x36,0x31,0x39,0x30,
3838 0x38,0x30,0x34,0x34,0x37,0x5a,0x30,0x21,0x02,0x10,0x03,0x3c,0x41,0x0e,0x2f,
3839 0x42,0x5c,0x32,0x2c,0xb1,0x35,0xfe,0xe7,0x61,0x97,0xa5,0x17,0x0d,0x30,0x32,
3840 0x30,0x34,0x32,0x34,0x31,0x39,0x34,0x37,0x30,0x32,0x5a,0x30,0x21,0x02,0x10,
3841 0x03,0x4e,0x68,0xfa,0x8b,0xb2,0x8e,0xb9,0x72,0xea,0x72,0xe5,0x3b,0x15,0xac,
3842 0x8b,0x17,0x0d,0x30,0x32,0x30,0x39,0x32,0x36,0x32,0x31,0x35,0x31,0x35,0x31,
3843 0x5a,0x30,0x21,0x02,0x10,0x03,0xc9,0xa8,0xe3,0x48,0xb0,0x5f,0xcf,0x08,0xee,
3844 0xb9,0x93,0xf9,0xe9,0xaf,0x0c,0x17,0x0d,0x30,0x32,0x30,0x34,0x31,0x38,0x31,
3845 0x33,0x34,0x39,0x32,0x32,0x5a,0x30,0x21,0x02,0x10,0x04,0x9b,0x23,0x6a,0x37,
3846 0x5c,0x06,0x98,0x0a,0x31,0xc8,0x86,0xdc,0x3a,0x95,0xcc,0x17,0x0d,0x30,0x32,
3847 0x31,0x30,0x30,0x31,0x32,0x32,0x31,0x30,0x35,0x36,0x5a,0x30,0x21,0x02,0x10,
3848 0x06,0x08,0xba,0xc7,0xac,0xf8,0x5a,0x7c,0xa1,0xf4,0x25,0x85,0xbb,0x4e,0x8c,
3849 0x4f,0x17,0x0d,0x30,0x33,0x30,0x31,0x30,0x33,0x30,0x37,0x35,0x37,0x31,0x34,
3850 0x5a,0x30,0x21,0x02,0x10,0x07,0x66,0x22,0x4a,0x4a,0x9d,0xff,0x6e,0xb5,0x11,
3851 0x0b,0xa9,0x94,0xfc,0x68,0x20,0x17,0x0d,0x30,0x32,0x30,0x38,0x32,0x32,0x30,
3852 0x31,0x34,0x30,0x31,0x32,0x5a,0x30,0x21,0x02,0x10,0x07,0x8f,0xa1,0x4d,0xb5,
3853 0xfc,0x0c,0xc6,0x42,0x72,0x88,0x37,0x76,0x29,0x44,0x31,0x17,0x0d,0x30,0x32,
3854 0x30,0x33,0x31,0x35,0x32,0x30,0x31,0x39,0x34,0x39,0x5a,0x30,0x21,0x02,0x10,
3855 0x07,0xb9,0xd9,0x42,0x19,0x81,0xc4,0xfd,0x49,0x4f,0x72,0xce,0xf2,0xf8,0x6d,
3856 0x76,0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x35,0x31,0x35,0x33,0x37,0x31,0x39,
3857 0x5a,0x30,0x21,0x02,0x10,0x08,0x6e,0xf9,0x6c,0x7f,0xbf,0xbc,0xc8,0x86,0x70,
3858 0x62,0x3f,0xe9,0xc4,0x2f,0x2b,0x17,0x0d,0x30,0x32,0x31,0x31,0x32,0x38,0x30,
3859 0x30,0x32,0x38,0x31,0x34,0x5a,0x30,0x21,0x02,0x10,0x09,0x08,0xe4,0xaa,0xf5,
3860 0x2d,0x2b,0xc0,0x15,0x9e,0x00,0x8b,0x3f,0x97,0x93,0xf9,0x17,0x0d,0x30,0x33,
3861 0x30,0x32,0x31,0x32,0x32,0x32,0x30,0x30,0x32,0x33,0x5a,0x30,0x21,0x02,0x10,
3862 0x09,0x13,0x0a,0x4f,0x0f,0x88,0xe5,0x50,0x05,0xc3,0x5f,0xf4,0xff,0x15,0x39,
3863 0xdd,0x17,0x0d,0x30,0x32,0x30,0x33,0x30,0x36,0x30,0x38,0x31,0x31,0x33,0x30,
3864 0x5a,0x30,0x21,0x02,0x10,0x09,0x8d,0xdd,0x37,0xda,0xe7,0x84,0x03,0x9d,0x98,
3865 0x96,0xf8,0x88,0x3a,0x55,0xca,0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x31,0x32,
3866 0x33,0x33,0x35,0x32,0x36,0x5a,0x30,0x21,0x02,0x10,0x0a,0x35,0x0c,0xd7,0xf4,
3867 0x53,0xe6,0xc1,0x4e,0xf2,0x2a,0xd3,0xce,0xf8,0x7c,0xe7,0x17,0x0d,0x30,0x32,
3868 0x30,0x38,0x30,0x32,0x32,0x32,0x32,0x34,0x32,0x38,0x5a,0x30,0x21,0x02,0x10,
3869 0x0b,0x9c,0xb8,0xf8,0xfb,0x35,0x38,0xf2,0x91,0xfd,0xa1,0xe9,0x69,0x4a,0xb1,
3870 0x24,0x17,0x0d,0x30,0x33,0x30,0x34,0x30,0x38,0x30,0x31,0x30,0x32,0x32,0x32,
3871 0x5a,0x30,0x21,0x02,0x10,0x0c,0x2f,0x7f,0x32,0x15,0xe0,0x2f,0x74,0xfa,0x05,
3872 0x22,0x67,0xbc,0x8a,0x2d,0xd0,0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x36,0x31,
3873 0x39,0x30,0x37,0x35,0x34,0x5a,0x30,0x21,0x02,0x10,0x0c,0x32,0x5b,0x78,0x32,
3874 0xc6,0x7c,0xd8,0xdd,0x25,0x91,0x22,0x4d,0x84,0x0a,0x94,0x17,0x0d,0x30,0x32,
3875 0x30,0x33,0x31,0x38,0x31,0x32,0x33,0x39,0x30,0x33,0x5a,0x30,0x21,0x02,0x10,
3876 0x0d,0x76,0x36,0xb9,0x1c,0x72,0xb7,0x9d,0xdf,0xa5,0x35,0x82,0xc5,0xa8,0xf7,
3877 0xbb,0x17,0x0d,0x30,0x32,0x30,0x38,0x32,0x37,0x32,0x31,0x34,0x32,0x31,0x31,
3878 0x5a,0x30,0x21,0x02,0x10,0x0f,0x28,0x79,0x98,0x56,0xb8,0xa5,0x5e,0xeb,0x79,
3879 0x5f,0x1b,0xed,0x0b,0x86,0x76,0x17,0x0d,0x30,0x32,0x30,0x33,0x31,0x33,0x30,
3880 0x31,0x31,0x30,0x34,0x37,0x5a,0x30,0x21,0x02,0x10,0x0f,0x80,0x3c,0x24,0xf4,
3881 0x62,0x27,0x24,0xbe,0x6a,0x74,0x9c,0x18,0x8e,0x4b,0x3b,0x17,0x0d,0x30,0x32,
3882 0x31,0x31,0x32,0x30,0x31,0x37,0x31,0x31,0x33,0x35,0x5a,0x30,0x21,0x02,0x10,
3883 0x0f,0xf2,0xa7,0x8c,0x80,0x9c,0xbe,0x2f,0xc8,0xa9,0xeb,0xfe,0x94,0x86,0x5a,
3884 0x5c,0x17,0x0d,0x30,0x32,0x30,0x36,0x32,0x30,0x31,0x39,0x35,0x38,0x34,0x35,
3885 0x5a,0x30,0x21,0x02,0x10,0x10,0x45,0x13,0x35,0x45,0xf3,0xc6,0x02,0x8d,0x8d,
3886 0x18,0xb1,0xc4,0x0a,0x7a,0x18,0x17,0x0d,0x30,0x32,0x30,0x34,0x32,0x36,0x31,
3887 0x37,0x33,0x32,0x35,0x39,0x5a,0x30,0x21,0x02,0x10,0x10,0x79,0xb1,0x71,0x1b,
3888 0x26,0x98,0x92,0x08,0x1e,0x3c,0xe4,0x8b,0x29,0x37,0xf9,0x17,0x0d,0x30,0x32,
3889 0x30,0x33,0x32,0x38,0x31,0x36,0x33,0x32,0x35,0x35,0x5a,0x30,0x21,0x02,0x10,
3890 0x11,0x38,0x80,0x77,0xcb,0x6b,0xe5,0xd6,0xa7,0xf2,0x99,0xa1,0xc8,0xe9,0x40,
3891 0x25,0x17,0x0d,0x30,0x32,0x30,0x34,0x31,0x39,0x31,0x32,0x32,0x34,0x31,0x37,
3892 0x5a,0x30,0x21,0x02,0x10,0x11,0x7a,0xc3,0x82,0xfe,0x74,0x36,0x11,0x21,0xd6,
3893 0x92,0x86,0x09,0xdf,0xe6,0xf3,0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x39,0x31,
3894 0x35,0x31,0x31,0x33,0x36,0x5a,0x30,0x21,0x02,0x10,0x11,0xab,0x8e,0x21,0x28,
3895 0x7f,0x6d,0xf2,0xc1,0xc8,0x40,0x3e,0xa5,0xde,0x98,0xd3,0x17,0x0d,0x30,0x32,
3896 0x30,0x35,0x30,0x32,0x31,0x38,0x34,0x34,0x33,0x31,0x5a,0x30,0x21,0x02,0x10,
3897 0x12,0x3c,0x38,0xae,0x3f,0x64,0x53,0x3a,0xf7,0xbc,0x6c,0x27,0xe2,0x9c,0x65,
3898 0x75,0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x33,0x32,0x33,0x30,0x38,0x35,0x39,
3899 0x5a,0x30,0x21,0x02,0x10,0x12,0x88,0xb6,0x6c,0x9b,0xcf,0xe7,0x50,0x92,0xd2,
3900 0x87,0x63,0x8f,0xb7,0xa6,0xe3,0x17,0x0d,0x30,0x32,0x30,0x37,0x30,0x32,0x32,
3901 0x30,0x35,0x35,0x30,0x33,0x5a,0x30,0x21,0x02,0x10,0x12,0x95,0x4e,0xb6,0x8f,
3902 0x3a,0x19,0x6a,0x16,0x73,0x4f,0x6e,0x15,0xba,0xa5,0xe7,0x17,0x0d,0x30,0x32,
3903 0x30,0x36,0x31,0x37,0x31,0x38,0x35,0x36,0x30,0x31,0x5a,0x30,0x21,0x02,0x10,
3904 0x13,0x37,0x0b,0x41,0x8c,0x31,0x43,0x1c,0x27,0xaa,0xe1,0x83,0x0f,0x99,0x21,
3905 0xcd,0x17,0x0d,0x30,0x32,0x30,0x37,0x32,0x32,0x31,0x32,0x31,0x37,0x31,0x36,
3906 0x5a,0x30,0x21,0x02,0x10,0x14,0x7a,0x29,0x0a,0x09,0x38,0xf4,0x53,0x28,0x33,
3907 0x6f,0x37,0x07,0x23,0x12,0x10,0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x32,0x30,
3908 0x32,0x30,0x30,0x31,0x34,0x5a,0x30,0x21,0x02,0x10,0x15,0x04,0x81,0x1e,0xe2,
3909 0x6f,0xf0,0xd8,0xdd,0x12,0x55,0x05,0x66,0x51,0x6e,0x1a,0x17,0x0d,0x30,0x32,
3910 0x30,0x33,0x31,0x33,0x31,0x30,0x35,0x33,0x30,0x38,0x5a,0x30,0x21,0x02,0x10,
3911 0x15,0x30,0x0d,0x8a,0xbd,0x0e,0x89,0x0e,0x66,0x4f,0x49,0x93,0xa2,0x8f,0xbc,
3912 0x2e,0x17,0x0d,0x30,0x32,0x30,0x34,0x30,0x34,0x30,0x36,0x34,0x32,0x32,0x33,
3913 0x5a,0x30,0x21,0x02,0x10,0x16,0xbe,0x64,0xd6,0x4f,0x90,0xf4,0xf7,0x2b,0xc8,
3914 0xca,0x67,0x5c,0x82,0x13,0xe8,0x17,0x0d,0x30,0x32,0x30,0x36,0x30,0x36,0x31,
3915 0x39,0x30,0x39,0x30,0x37,0x5a,0x30,0x21,0x02,0x10,0x18,0x51,0x9c,0xe4,0x48,
3916 0x62,0x06,0xfe,0xb8,0x2d,0x93,0xb7,0xc9,0xc9,0x1b,0x4e,0x17,0x0d,0x30,0x32,
3917 0x30,0x34,0x31,0x37,0x30,0x35,0x30,0x30,0x34,0x34,0x5a,0x30,0x21,0x02,0x10,
3918 0x19,0x82,0xdb,0x39,0x74,0x00,0x38,0x36,0x59,0xf6,0xcc,0xc1,0x23,0x8d,0x40,
3919 0xe9,0x17,0x0d,0x30,0x32,0x30,0x33,0x30,0x36,0x30,0x37,0x35,0x34,0x35,0x34,
3920 0x5a,0x30,0x21,0x02,0x10,0x1b,0x51,0x90,0xf7,0x37,0x24,0x39,0x9c,0x92,0x54,
3921 0xcd,0x42,0x46,0x37,0x99,0x6a,0x17,0x0d,0x30,0x31,0x30,0x31,0x33,0x30,0x30,
3922 0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x21,0x02,0x10,0x1b,0xe4,0xb2,0xbb,0xb6,
3923 0x74,0x5d,0x6b,0x8b,0x04,0xb6,0xa0,0x1b,0x35,0xeb,0x29,0x17,0x0d,0x30,0x32,
3924 0x30,0x39,0x32,0x35,0x32,0x30,0x31,0x34,0x35,0x36,0x5a,0x30,0x21,0x02,0x10,
3925 0x1c,0x1d,0xd5,0x2a,0xf6,0xaa,0xfd,0xbb,0x47,0xc2,0x73,0x36,0xcf,0x53,0xbd,
3926 0x81,0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x33,0x31,0x39,0x30,0x33,0x34,0x32,
3927 0x5a,0x30,0x21,0x02,0x10,0x1c,0xb0,0x5a,0x1f,0xfd,0xa6,0x98,0xf6,0x46,0xf9,
3928 0x32,0x10,0x9e,0xef,0x52,0x8e,0x17,0x0d,0x30,0x32,0x30,0x36,0x32,0x37,0x31,
3929 0x33,0x30,0x33,0x32,0x32,0x5a,0x30,0x21,0x02,0x10,0x1d,0x01,0xfc,0xa7,0xdd,
3930 0xb4,0x0c,0x64,0xbd,0x65,0x45,0xe6,0xbf,0x1c,0x7e,0x90,0x17,0x0d,0x30,0x32,
3931 0x30,0x32,0x32,0x31,0x30,0x34,0x32,0x30,0x30,0x36,0x5a,0x30,0x21,0x02,0x10,
3932 0x1e,0x4d,0xc9,0xc6,0x6e,0x57,0xda,0x8a,0x07,0x97,0x70,0xfa,0xee,0x9c,0xc5,
3933 0x58,0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x39,0x32,0x32,0x33,0x34,0x32,0x31,
3934 0x5a,0x30,0x21,0x02,0x10,0x1e,0xbb,0x9b,0x28,0x61,0x50,0x7f,0x12,0x30,0xfb,
3935 0x02,0xb5,0xe1,0xb0,0x7e,0x9d,0x17,0x0d,0x30,0x32,0x30,0x33,0x30,0x36,0x30,
3936 0x30,0x30,0x34,0x32,0x30,0x5a,0x30,0x21,0x02,0x10,0x1f,0x5a,0x64,0xc9,0xa5,
3937 0x51,0x8c,0xe2,0x2d,0x50,0x83,0xc2,0x4c,0x7c,0xe7,0x85,0x17,0x0d,0x30,0x32,
3938 0x30,0x38,0x32,0x34,0x30,0x36,0x33,0x31,0x32,0x38,0x5a,0x30,0x21,0x02,0x10,
3939 0x1f,0xc2,0x4e,0xd0,0xac,0x52,0xd3,0x39,0x18,0x6d,0xd0,0x0f,0x23,0xd7,0x45,
3940 0x72,0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x38,0x31,0x39,0x31,0x35,0x34,0x32,
3941 0x5a,0x30,0x20,0x02,0x0f,0x24,0x60,0x7a,0x8e,0x0e,0x86,0xa4,0x88,0x68,0xaf,
3942 0xd9,0x0c,0x6b,0xba,0xff,0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x38,0x30,0x35,
3943 0x31,0x38,0x32,0x34,0x5a,0x30,0x21,0x02,0x10,0x20,0x41,0x73,0xbb,0x72,0x88,
3944 0x6e,0x4b,0x1c,0xb6,0x70,0x02,0x67,0xaa,0x3b,0x3d,0x17,0x0d,0x30,0x32,0x30,
3945 0x39,0x30,0x33,0x31,0x37,0x30,0x36,0x32,0x31,0x5a,0x30,0x21,0x02,0x10,0x20,
3946 0x6e,0x0d,0xdc,0x8c,0xa4,0xac,0xf7,0x08,0x77,0x5c,0x80,0xf9,0xa3,0x68,0x92,
3947 0x17,0x0d,0x30,0x32,0x30,0x34,0x31,0x30,0x32,0x30,0x35,0x37,0x31,0x36,0x5a,
3948 0x30,0x21,0x02,0x10,0x21,0xe4,0x6b,0x98,0x47,0x91,0xe6,0x02,0xdf,0xb2,0x45,
3949 0xbc,0x31,0x37,0xa0,0x7c,0x17,0x0d,0x30,0x32,0x30,0x33,0x30,0x38,0x32,0x33,
3950 0x32,0x33,0x31,0x33,0x5a,0x30,0x21,0x02,0x10,0x22,0x00,0x95,0x70,0x79,0xf9,
3951 0x9c,0x34,0x91,0xbb,0x84,0xb9,0x91,0xde,0x22,0x55,0x17,0x0d,0x30,0x32,0x30,
3952 0x32,0x31,0x33,0x30,0x36,0x35,0x39,0x33,0x39,0x5a,0x30,0x21,0x02,0x10,0x22,
3953 0xf9,0x67,0x4f,0xcd,0x29,0xc6,0xdc,0xc8,0x22,0x6e,0xe9,0x0a,0xa1,0x48,0x5a,
3954 0x17,0x0d,0x30,0x32,0x30,0x34,0x30,0x33,0x30,0x30,0x34,0x33,0x32,0x36,0x5a,
3955 0x30,0x21,0x02,0x10,0x24,0xa3,0xa7,0xd0,0xb8,0x1d,0x1c,0xf7,0xe6,0x1f,0x6e,
3956 0xba,0xc9,0x98,0x59,0xed,0x17,0x0d,0x30,0x33,0x30,0x37,0x32,0x34,0x32,0x30,
3957 0x35,0x38,0x30,0x32,0x5a,0x30,0x21,0x02,0x10,0x24,0xef,0x89,0xa1,0x30,0x4f,
3958 0x51,0x63,0xfe,0xdb,0xdb,0x64,0x6e,0x4c,0x5a,0x81,0x17,0x0d,0x30,0x32,0x30,
3959 0x37,0x30,0x33,0x30,0x39,0x32,0x31,0x31,0x37,0x5a,0x30,0x21,0x02,0x10,0x25,
3960 0x08,0xe5,0xac,0xdd,0x6f,0x74,0x44,0x51,0x1a,0xf5,0xdb,0xf8,0xba,0x25,0xe0,
3961 0x17,0x0d,0x30,0x32,0x30,0x34,0x30,0x39,0x30,0x34,0x31,0x36,0x32,0x32,0x5a,
3962 0x30,0x21,0x02,0x10,0x25,0x81,0xe8,0x18,0x60,0x88,0xbc,0x1a,0xe9,0x14,0x84,
3963 0xed,0xd4,0x62,0xf5,0x47,0x17,0x0d,0x30,0x32,0x30,0x38,0x32,0x33,0x30,0x31,
3964 0x35,0x37,0x31,0x39,0x5a,0x30,0x21,0x02,0x10,0x26,0xe5,0x5c,0xab,0x16,0xec,
3965 0x61,0x38,0x49,0x2c,0xd2,0xb1,0x48,0x89,0xd5,0x47,0x17,0x0d,0x30,0x32,0x30,
3966 0x33,0x31,0x33,0x31,0x38,0x30,0x30,0x33,0x38,0x5a,0x30,0x21,0x02,0x10,0x27,
3967 0xbe,0xda,0x7f,0x4f,0x1f,0x6c,0x76,0x09,0xc0,0x9a,0xaf,0xd4,0x68,0xe2,0x16,
3968 0x17,0x0d,0x30,0x32,0x30,0x35,0x31,0x30,0x31,0x38,0x33,0x32,0x33,0x30,0x5a,
3969 0x30,0x21,0x02,0x10,0x28,0x89,0xd0,0xb3,0xb5,0xc4,0x56,0x36,0x9b,0x3e,0x81,
3970 0x1a,0x21,0x56,0xaa,0x42,0x17,0x0d,0x30,0x32,0x31,0x31,0x30,0x34,0x31,0x31,
3971 0x30,0x33,0x30,0x38,0x5a,0x30,0x21,0x02,0x10,0x28,0xab,0x93,0x06,0xb1,0x1e,
3972 0x05,0xe0,0xe1,0x25,0x75,0xc7,0x74,0xcb,0x55,0xa6,0x17,0x0d,0x30,0x33,0x30,
3973 0x31,0x32,0x34,0x31,0x39,0x34,0x38,0x32,0x33,0x5a,0x30,0x21,0x02,0x10,0x29,
3974 0xe9,0x3b,0x44,0x8d,0xc3,0x4b,0x80,0x17,0xda,0xe4,0x1c,0x43,0x96,0x83,0x59,
3975 0x17,0x0d,0x30,0x32,0x30,0x36,0x30,0x37,0x32,0x31,0x34,0x33,0x33,0x39,0x5a,
3976 0x30,0x21,0x02,0x10,0x2a,0x08,0x64,0x2b,0x48,0xe2,0x17,0x89,0x6a,0x0c,0xf9,
3977 0x7e,0x10,0x66,0x8f,0xe7,0x17,0x0d,0x30,0x32,0x30,0x38,0x31,0x39,0x31,0x38,
3978 0x33,0x35,0x32,0x39,0x5a,0x30,0x21,0x02,0x10,0x2a,0x44,0xee,0x91,0x5d,0xe3,
3979 0xa5,0x2b,0x09,0xf3,0x56,0x59,0xe0,0x8f,0x25,0x22,0x17,0x0d,0x30,0x32,0x30,
3980 0x32,0x32,0x31,0x31,0x39,0x33,0x31,0x32,0x34,0x5a,0x30,0x21,0x02,0x10,0x2a,
3981 0x8b,0x4e,0xa5,0xb6,0x06,0xc8,0x48,0x3b,0x0e,0x71,0x1e,0x6b,0xf4,0x16,0xc1,
3982 0x17,0x0d,0x30,0x32,0x30,0x34,0x33,0x30,0x30,0x39,0x32,0x31,0x31,0x38,0x5a,
3983 0x30,0x21,0x02,0x10,0x2b,0x03,0xfc,0x2f,0xc2,0x8e,0x38,0x29,0x6f,0xa1,0x0f,
3984 0xe9,0x47,0x1b,0x35,0xd7,0x17,0x0d,0x30,0x32,0x31,0x31,0x31,0x34,0x32,0x30,
3985 0x31,0x38,0x33,0x33,0x5a,0x30,0x21,0x02,0x10,0x2c,0x48,0xf7,0xd6,0xd5,0x71,
3986 0xc0,0xd1,0xbd,0x6a,0x00,0x65,0x1d,0x2d,0xa9,0xdd,0x17,0x0d,0x30,0x32,0x30,
3987 0x33,0x30,0x36,0x31,0x37,0x32,0x30,0x34,0x33,0x5a,0x30,0x21,0x02,0x10,0x2c,
3988 0xbf,0x84,0x1d,0xe4,0x58,0x32,0x79,0x32,0x10,0x37,0xde,0xd7,0x94,0xff,0x85,
3989 0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x32,0x31,0x39,0x30,0x32,0x32,0x35,0x5a,
3990 0x30,0x21,0x02,0x10,0x2d,0x03,0x54,0x35,0x54,0x45,0x2c,0x6d,0x39,0xf0,0x1b,
3991 0x74,0x68,0xde,0xcf,0x93,0x17,0x0d,0x30,0x32,0x30,0x39,0x32,0x33,0x31,0x33,
3992 0x32,0x33,0x33,0x37,0x5a,0x30,0x21,0x02,0x10,0x2d,0x24,0x94,0x34,0x19,0x92,
3993 0xb1,0xf2,0x37,0x9d,0x6e,0xc5,0x35,0x93,0xdd,0xf0,0x17,0x0d,0x30,0x32,0x30,
3994 0x33,0x31,0x35,0x31,0x37,0x31,0x37,0x32,0x37,0x5a,0x30,0x21,0x02,0x10,0x2d,
3995 0x47,0x24,0x61,0x87,0x91,0xba,0x2e,0xf2,0xf7,0x92,0x21,0xf3,0x1b,0x8b,0x1e,
3996 0x17,0x0d,0x30,0x32,0x30,0x35,0x31,0x34,0x32,0x33,0x30,0x38,0x32,0x32,0x5a,
3997 0x30,0x21,0x02,0x10,0x2d,0x84,0xc2,0xb1,0x01,0xa1,0x3a,0x6f,0xb0,0x30,0x13,
3998 0x76,0x5a,0x69,0xec,0x41,0x17,0x0d,0x30,0x32,0x30,0x37,0x31,0x35,0x31,0x37,
3999 0x32,0x39,0x32,0x33,0x5a,0x30,0x21,0x02,0x10,0x2d,0xd5,0x26,0xc3,0xcd,0x01,
4000 0xce,0xfd,0x67,0xb8,0x08,0xac,0x5a,0x70,0xc4,0x34,0x17,0x0d,0x30,0x32,0x30,
4001 0x32,0x32,0x37,0x30,0x34,0x34,0x36,0x31,0x34,0x5a,0x30,0x21,0x02,0x10,0x2e,
4002 0x2b,0x0a,0x94,0x4d,0xf1,0xa4,0x37,0xb7,0xa3,0x9b,0x4b,0x96,0x26,0xa8,0xe3,
4003 0x17,0x0d,0x30,0x33,0x30,0x31,0x30,0x39,0x30,0x36,0x32,0x38,0x32,0x38,0x5a,
4004 0x30,0x21,0x02,0x10,0x2e,0x31,0x30,0xc1,0x2e,0x16,0x31,0xd9,0x2b,0x0a,0x70,
4005 0xca,0x3f,0x31,0x73,0x62,0x17,0x0d,0x30,0x33,0x30,0x31,0x32,0x39,0x30,0x31,
4006 0x34,0x39,0x32,0x37,0x5a,0x30,0x21,0x02,0x10,0x2e,0xbd,0x6d,0xdf,0xce,0x20,
4007 0x6f,0xe7,0xa8,0xf4,0xf3,0x25,0x9c,0xc3,0xc1,0x12,0x17,0x0d,0x30,0x32,0x30,
4008 0x39,0x32,0x30,0x31,0x33,0x35,0x34,0x34,0x32,0x5a,0x30,0x21,0x02,0x10,0x2f,
4009 0x56,0x16,0x22,0xba,0x87,0xd5,0xfd,0xff,0xe6,0xb0,0xdd,0x3c,0x08,0x26,0x2c,
4010 0x17,0x0d,0x30,0x32,0x30,0x33,0x31,0x33,0x31,0x37,0x35,0x33,0x31,0x31,0x5a,
4011 0x30,0x21,0x02,0x10,0x30,0x3e,0x77,0x7b,0xec,0xcb,0x89,0x2c,0x15,0x55,0x7f,
4012 0x20,0xf2,0x33,0xc1,0x1e,0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x31,0x32,0x33,
4013 0x35,0x30,0x34,0x39,0x5a,0x30,0x21,0x02,0x10,0x30,0x59,0x6c,0xaa,0x5f,0xd3,
4014 0xac,0x50,0x86,0x2c,0xc4,0xfa,0x3c,0x48,0x50,0xd1,0x17,0x0d,0x30,0x32,0x30,
4015 0x32,0x32,0x31,0x30,0x34,0x31,0x39,0x33,0x35,0x5a,0x30,0x21,0x02,0x10,0x30,
4016 0xce,0x9a,0xf1,0xfa,0x17,0xfa,0xf5,0x4c,0xbc,0x52,0x8a,0xf4,0x26,0x2b,0x7b,
4017 0x17,0x0d,0x30,0x32,0x30,0x33,0x30,0x31,0x31,0x39,0x31,0x32,0x33,0x39,0x5a,
4018 0x30,0x21,0x02,0x10,0x31,0x16,0x4a,0x6a,0x2e,0x6d,0x34,0x4d,0xd2,0x40,0xf0,
4019 0x5f,0x47,0xe6,0x5b,0x47,0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x32,0x31,0x37,
4020 0x33,0x38,0x35,0x32,0x5a,0x30,0x21,0x02,0x10,0x31,0xdb,0x97,0x5b,0x06,0x63,
4021 0x0b,0xd8,0xfe,0x06,0xb3,0xf5,0xf9,0x64,0x0a,0x59,0x17,0x0d,0x30,0x32,0x30,
4022 0x32,0x31,0x32,0x31,0x35,0x35,0x39,0x32,0x33,0x5a,0x30,0x21,0x02,0x10,0x32,
4023 0xbc,0xeb,0x0c,0xca,0x65,0x06,0x3f,0xa4,0xd5,0x4a,0x56,0x46,0x7c,0x22,0x09,
4024 0x17,0x0d,0x30,0x32,0x30,0x38,0x31,0x36,0x30,0x37,0x33,0x33,0x35,0x35,0x5a,
4025 0x30,0x21,0x02,0x10,0x33,0x17,0xef,0xe1,0x89,0xec,0x11,0x25,0x15,0x8f,0x3b,
4026 0x67,0x7a,0x64,0x0b,0x50,0x17,0x0d,0x30,0x32,0x30,0x39,0x31,0x38,0x31,0x37,
4027 0x30,0x33,0x34,0x36,0x5a,0x30,0x21,0x02,0x10,0x34,0x24,0xa0,0xd2,0x00,0x61,
4028 0xeb,0xd3,0x9a,0xa7,0x2a,0x66,0xb4,0x82,0x23,0x77,0x17,0x0d,0x30,0x32,0x30,
4029 0x33,0x31,0x35,0x32,0x32,0x34,0x33,0x33,0x39,0x5a,0x30,0x21,0x02,0x10,0x34,
4030 0xa8,0x16,0x67,0xa5,0x1b,0xa3,0x31,0x11,0x5e,0x26,0xc8,0x3f,0x21,0x38,0xbe,
4031 0x17,0x0d,0x30,0x32,0x30,0x33,0x32,0x31,0x32,0x31,0x31,0x36,0x32,0x31,0x5a,
4032 0x30,0x21,0x02,0x10,0x36,0x3a,0xbe,0x05,0x55,0x52,0x93,0x4f,0x32,0x5f,0x30,
4033 0x63,0xc0,0xd4,0x50,0xdf,0x17,0x0d,0x30,0x32,0x30,0x33,0x30,0x38,0x31,0x31,
4034 0x34,0x36,0x31,0x34,0x5a,0x30,0x21,0x02,0x10,0x37,0x19,0xcc,0xa5,0x9d,0x85,
4035 0x05,0x56,0xe1,0x63,0x42,0x4b,0x0d,0x3c,0xbf,0xd6,0x17,0x0d,0x30,0x33,0x30,
4036 0x31,0x30,0x38,0x31,0x38,0x35,0x38,0x32,0x34,0x5a,0x30,0x21,0x02,0x10,0x37,
4037 0x2f,0xfd,0x2b,0xec,0x4d,0x94,0x35,0x51,0xf4,0x07,0x2a,0xf5,0x0b,0x97,0xc4,
4038 0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x33,0x31,0x39,0x31,0x38,0x30,0x31,0x5a,
4039 0x30,0x21,0x02,0x10,0x37,0x83,0xf5,0x1e,0x7e,0xf4,0x5f,0xad,0x1f,0x0c,0x55,
4040 0x86,0x30,0x02,0x54,0xc1,0x17,0x0d,0x30,0x33,0x30,0x31,0x30,0x38,0x32,0x30,
4041 0x30,0x33,0x34,0x34,0x5a,0x30,0x21,0x02,0x10,0x38,0x32,0x3e,0x50,0x2b,0x36,
4042 0x93,0x01,0x32,0x0a,0x59,0x8c,0xce,0xad,0xa0,0xeb,0x17,0x0d,0x30,0x32,0x30,
4043 0x34,0x33,0x30,0x32,0x31,0x32,0x34,0x30,0x38,0x5a,0x30,0x21,0x02,0x10,0x3a,
4044 0x62,0xd8,0x64,0xd3,0x85,0xd5,0x61,0x1d,0x9d,0x3f,0x61,0x25,0xe9,0x3a,0x1d,
4045 0x17,0x0d,0x30,0x32,0x30,0x36,0x31,0x37,0x31,0x35,0x31,0x39,0x31,0x36,0x5a,
4046 0x30,0x21,0x02,0x10,0x3a,0x97,0x36,0xb1,0x26,0x14,0x73,0x50,0xa3,0xcc,0x3f,
4047 0xd0,0x3b,0x83,0x99,0xc9,0x17,0x0d,0x30,0x32,0x30,0x39,0x31,0x31,0x30,0x33,
4048 0x32,0x39,0x33,0x30,0x5a,0x30,0x21,0x02,0x10,0x3b,0x87,0x3e,0x20,0xbe,0x97,
4049 0xff,0xa7,0x6b,0x2b,0x5f,0xff,0x9a,0x7f,0x4c,0x95,0x17,0x0d,0x30,0x32,0x30,
4050 0x37,0x30,0x33,0x30,0x30,0x33,0x31,0x34,0x37,0x5a,0x30,0x21,0x02,0x10,0x3b,
4051 0xba,0xe5,0xf2,0x23,0x99,0xc6,0xd7,0xae,0xe2,0x98,0x0d,0xa4,0x13,0x5c,0xd4,
4052 0x17,0x0d,0x30,0x32,0x30,0x35,0x32,0x34,0x31,0x39,0x32,0x38,0x34,0x35,0x5a,
4053 0x30,0x21,0x02,0x10,0x3b,0xc2,0x7c,0xf0,0xbd,0xd2,0x9a,0x6f,0x97,0xdd,0x76,
4054 0xbc,0xa9,0x6c,0x45,0x0d,0x17,0x0d,0x30,0x32,0x30,0x33,0x30,0x38,0x31,0x30,
4055 0x34,0x32,0x30,0x33,0x5a,0x30,0x21,0x02,0x10,0x3b,0xc5,0xda,0x41,0x64,0x7a,
4056 0x37,0x8e,0x9f,0x7f,0x1f,0x9b,0x25,0x0a,0xb4,0xda,0x17,0x0d,0x30,0x32,0x30,
4057 0x33,0x30,0x36,0x31,0x33,0x32,0x34,0x34,0x38,0x5a,0x30,0x21,0x02,0x10,0x3c,
4058 0x1b,0xf1,0x9a,0x48,0xb0,0xb8,0xa0,0x45,0xd5,0x8f,0x0f,0x57,0x90,0xc2,0xcd,
4059 0x17,0x0d,0x30,0x32,0x30,0x33,0x31,0x38,0x30,0x36,0x34,0x33,0x32,0x33,0x5a,
4060 0x30,0x21,0x02,0x10,0x3d,0x15,0x48,0x80,0xb4,0xfe,0x51,0x7e,0xed,0x46,0xae,
4061 0x51,0xfd,0x47,0x73,0xde,0x17,0x0d,0x30,0x32,0x30,0x38,0x32,0x37,0x30,0x39,
4062 0x32,0x30,0x30,0x38,0x5a,0x30,0x21,0x02,0x10,0x3d,0x61,0x4e,0x87,0xea,0x39,
4063 0x02,0xf3,0x1e,0x3e,0x56,0x5c,0x0e,0x3b,0xa7,0xe3,0x17,0x0d,0x30,0x32,0x31,
4064 0x30,0x32,0x39,0x31,0x39,0x35,0x34,0x31,0x32,0x5a,0x30,0x21,0x02,0x10,0x3d,
4065 0xdd,0x61,0x92,0x82,0x69,0x6b,0x01,0x79,0x0e,0xef,0x96,0x12,0xa3,0x76,0x80,
4066 0x17,0x0d,0x30,0x32,0x30,0x35,0x30,0x31,0x32,0x32,0x32,0x34,0x31,0x36,0x5a,
4067 0x30,0x21,0x02,0x10,0x3e,0x0e,0x14,0x71,0x55,0xf3,0x48,0x09,0x1b,0x56,0x3b,
4068 0x91,0x7a,0x7d,0xec,0xc9,0x17,0x0d,0x30,0x32,0x30,0x33,0x31,0x31,0x32,0x31,
4069 0x34,0x35,0x35,0x31,0x5a,0x30,0x21,0x02,0x10,0x3e,0x23,0x00,0x1f,0x9b,0xbd,
4070 0xe8,0xb1,0xf0,0x06,0x67,0xa6,0x70,0x42,0x2e,0xc3,0x17,0x0d,0x30,0x32,0x30,
4071 0x38,0x30,0x38,0x31,0x32,0x32,0x31,0x33,0x32,0x5a,0x30,0x21,0x02,0x10,0x41,
4072 0x91,0x1a,0x8c,0xde,0x2d,0xb3,0xeb,0x79,0x1d,0xc7,0x99,0x99,0xbe,0x0c,0x0e,
4073 0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x35,0x31,0x39,0x31,0x38,0x35,0x34,0x5a,
4074 0x30,0x21,0x02,0x10,0x41,0xa8,0xd7,0x9c,0x10,0x5e,0x5a,0xac,0x16,0x7f,0x93,
4075 0xaa,0xd1,0x83,0x34,0x55,0x17,0x0d,0x30,0x32,0x30,0x34,0x31,0x30,0x31,0x32,
4076 0x35,0x33,0x34,0x30,0x5a,0x30,0x21,0x02,0x10,0x42,0x88,0x96,0xb0,0x7b,0x28,
4077 0xa2,0xfa,0x2f,0x91,0x73,0x58,0xa7,0x1e,0x53,0x7c,0x17,0x0d,0x30,0x33,0x30,
4078 0x33,0x30,0x31,0x30,0x39,0x34,0x33,0x33,0x31,0x5a,0x30,0x21,0x02,0x10,0x42,
4079 0x93,0x2f,0xd2,0x54,0xd3,0x94,0xd0,0x41,0x6a,0x2e,0x33,0x8b,0x81,0xb4,0x3c,
4080 0x17,0x0d,0x30,0x32,0x30,0x38,0x30,0x38,0x30,0x30,0x34,0x38,0x34,0x36,0x5a,
4081 0x30,0x21,0x02,0x10,0x44,0x24,0xdd,0xba,0x85,0xfd,0x3e,0xb2,0xb8,0x17,0x74,
4082 0xfd,0x9d,0x5c,0x0c,0xbd,0x17,0x0d,0x30,0x32,0x30,0x39,0x32,0x31,0x31,0x36,
4083 0x30,0x39,0x31,0x32,0x5a,0x30,0x21,0x02,0x10,0x45,0x02,0x18,0x7d,0x39,0x9c,
4084 0xb9,0x14,0xfb,0x10,0x37,0x96,0xf4,0xc1,0xdd,0x2f,0x17,0x0d,0x30,0x32,0x30,
4085 0x32,0x31,0x31,0x31,0x31,0x31,0x31,0x30,0x36,0x5a,0x30,0x21,0x02,0x10,0x45,
4086 0x16,0xbc,0x31,0x0b,0x4e,0x87,0x0a,0xcc,0xe3,0xd5,0x14,0x16,0x33,0x11,0x83,
4087 0x17,0x0d,0x30,0x32,0x30,0x34,0x30,0x32,0x30,0x32,0x32,0x30,0x31,0x37,0x5a,
4088 0x30,0x21,0x02,0x10,0x46,0x16,0x36,0xde,0x3f,0xef,0x8c,0xfa,0x67,0x53,0x12,
4089 0xcc,0x76,0x63,0xd6,0xdd,0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x34,0x31,0x36,
4090 0x35,0x39,0x34,0x33,0x5a,0x30,0x21,0x02,0x10,0x46,0x5f,0x85,0xa3,0xa4,0x98,
4091 0x3c,0x40,0x63,0xf6,0x1c,0xf7,0xc2,0xbe,0xfd,0x0e,0x17,0x0d,0x30,0x32,0x30,
4092 0x34,0x30,0x39,0x31,0x35,0x33,0x30,0x30,0x35,0x5a,0x30,0x21,0x02,0x10,0x47,
4093 0x20,0xc2,0xd8,0x85,0x85,0x54,0x39,0xcd,0xf2,0x10,0xf0,0xa7,0x88,0x52,0x75,
4094 0x17,0x0d,0x30,0x32,0x30,0x39,0x31,0x30,0x32,0x32,0x32,0x35,0x32,0x37,0x5a,
4095 0x30,0x21,0x02,0x10,0x47,0x42,0x6e,0xa2,0xab,0xc5,0x33,0x5d,0x50,0x44,0x0b,
4096 0x88,0x97,0x84,0x59,0x4c,0x17,0x0d,0x30,0x32,0x30,0x33,0x30,0x35,0x31,0x34,
4097 0x30,0x35,0x31,0x39,0x5a,0x30,0x21,0x02,0x10,0x49,0x20,0x3f,0xa8,0x6e,0x81,
4098 0xc8,0x3b,0x26,0x05,0xf4,0xa7,0x9b,0x5a,0x81,0x60,0x17,0x0d,0x30,0x32,0x30,
4099 0x37,0x31,0x31,0x31,0x37,0x35,0x30,0x34,0x38,0x5a,0x30,0x21,0x02,0x10,0x49,
4100 0x8b,0x6f,0x05,0xfb,0xcb,0xf4,0x5a,0xaf,0x09,0x47,0xb1,0x04,0xc5,0xe3,0x51,
4101 0x17,0x0d,0x30,0x32,0x30,0x34,0x31,0x32,0x31,0x37,0x34,0x38,0x30,0x38,0x5a,
4102 0x30,0x21,0x02,0x10,0x49,0xb2,0xc3,0x7a,0xbf,0x75,0x2a,0xb3,0x13,0xae,0x53,
4103 0xc6,0xcb,0x45,0x5a,0x3e,0x17,0x0d,0x30,0x32,0x31,0x31,0x31,0x35,0x32,0x31,
4104 0x33,0x35,0x33,0x37,0x5a,0x30,0x21,0x02,0x10,0x4b,0xca,0xc3,0xab,0x0a,0xc5,
4105 0xcd,0x90,0xa2,0xbe,0x43,0xfe,0xdd,0x06,0xe1,0x45,0x17,0x0d,0x30,0x32,0x30,
4106 0x37,0x32,0x30,0x31,0x37,0x33,0x32,0x31,0x32,0x5a,0x30,0x21,0x02,0x10,0x4c,
4107 0x00,0xcc,0x73,0xd5,0x74,0x61,0x62,0x92,0x52,0xff,0xde,0x5b,0xc1,0x55,0xbd,
4108 0x17,0x0d,0x30,0x32,0x30,0x38,0x32,0x36,0x31,0x34,0x30,0x31,0x35,0x31,0x5a,
4109 0x30,0x21,0x02,0x10,0x4c,0x59,0xc1,0xc3,0x56,0x40,0x27,0xd4,0x22,0x0e,0x37,
4110 0xf6,0x5f,0x26,0x50,0xc5,0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x36,0x30,0x39,
4111 0x35,0x37,0x34,0x34,0x5a,0x30,0x21,0x02,0x10,0x4c,0xca,0x12,0x59,0x46,0xf9,
4112 0x2b,0xc6,0x7d,0x33,0x78,0x40,0x2c,0x3b,0x7a,0x0c,0x17,0x0d,0x30,0x32,0x30,
4113 0x35,0x33,0x30,0x32,0x30,0x32,0x34,0x35,0x38,0x5a,0x30,0x21,0x02,0x10,0x4d,
4114 0x57,0x51,0x35,0x9b,0xe5,0x41,0x2c,0x69,0x66,0xc7,0x21,0xec,0xc6,0x29,0x32,
4115 0x17,0x0d,0x30,0x32,0x30,0x39,0x32,0x36,0x30,0x34,0x33,0x35,0x35,0x36,0x5a,
4116 0x30,0x21,0x02,0x10,0x4e,0x85,0xab,0x9e,0x17,0x54,0xe7,0x42,0x0f,0x8c,0xa1,
4117 0x65,0x96,0x88,0x53,0x54,0x17,0x0d,0x30,0x32,0x30,0x33,0x32,0x38,0x30,0x30,
4118 0x31,0x38,0x35,0x33,0x5a,0x30,0x21,0x02,0x10,0x50,0x3d,0xed,0xac,0x21,0x86,
4119 0x66,0x5d,0xa5,0x1a,0x13,0xee,0xfc,0xa7,0x0b,0xc6,0x17,0x0d,0x30,0x32,0x30,
4120 0x32,0x31,0x38,0x31,0x33,0x35,0x35,0x34,0x39,0x5a,0x30,0x21,0x02,0x10,0x50,
4121 0xa3,0x81,0x9c,0xcb,0x22,0xe4,0x0f,0x80,0xcb,0x7a,0xec,0x35,0xf8,0x73,0x82,
4122 0x17,0x0d,0x30,0x32,0x31,0x30,0x30,0x35,0x31,0x36,0x35,0x39,0x35,0x39,0x5a,
4123 0x30,0x21,0x02,0x10,0x51,0x28,0x73,0x26,0x17,0xcf,0x10,0x6e,0xeb,0x4a,0x03,
4124 0x74,0xa3,0x35,0xe5,0x60,0x17,0x0d,0x30,0x33,0x30,0x36,0x31,0x33,0x31,0x30,
4125 0x30,0x39,0x32,0x39,0x5a,0x30,0x21,0x02,0x10,0x51,0x52,0xff,0xdc,0x69,0x6b,
4126 0x1f,0x1f,0xff,0x7c,0xb1,0x7f,0x03,0x90,0xa9,0x6b,0x17,0x0d,0x30,0x32,0x30,
4127 0x36,0x31,0x34,0x31,0x36,0x30,0x34,0x30,0x32,0x5a,0x30,0x21,0x02,0x10,0x52,
4128 0xd9,0x53,0x69,0x9f,0xec,0xab,0xdd,0x5d,0x2a,0x2f,0xaa,0x57,0x86,0xb9,0x1f,
4129 0x17,0x0d,0x30,0x32,0x30,0x38,0x33,0x30,0x32,0x33,0x34,0x36,0x34,0x33,0x5a,
4130 0x30,0x21,0x02,0x10,0x54,0x46,0xa8,0x8f,0x69,0x2e,0x02,0xf4,0xb4,0xb2,0x69,
4131 0xda,0xbd,0x40,0x02,0xe0,0x17,0x0d,0x30,0x32,0x30,0x33,0x32,0x36,0x30,0x31,
4132 0x35,0x36,0x35,0x38,0x5a,0x30,0x21,0x02,0x10,0x54,0xb5,0x81,0x73,0xb5,0x7c,
4133 0x6d,0xba,0x5c,0x99,0x0d,0xff,0x0a,0x4d,0xee,0xef,0x17,0x0d,0x30,0x32,0x30,
4134 0x37,0x32,0x34,0x31,0x36,0x33,0x39,0x35,0x31,0x5a,0x30,0x21,0x02,0x10,0x57,
4135 0x91,0x41,0x20,0x9f,0x57,0x6f,0x42,0x53,0x4e,0x19,0xcc,0xe4,0xc8,0x52,0x4a,
4136 0x17,0x0d,0x30,0x32,0x30,0x35,0x32,0x38,0x32,0x33,0x32,0x34,0x30,0x30,0x5a,
4137 0x30,0x21,0x02,0x10,0x57,0xc6,0xdc,0xa0,0xed,0xbf,0x77,0xdd,0x7e,0x18,0x68,
4138 0x83,0x57,0x0c,0x2a,0x4f,0x17,0x0d,0x30,0x32,0x30,0x35,0x32,0x31,0x31,0x34,
4139 0x30,0x36,0x31,0x31,0x5a,0x30,0x21,0x02,0x10,0x57,0xed,0xe2,0x5b,0xe2,0x62,
4140 0x3f,0x98,0xe1,0xf5,0x4d,0x30,0xa4,0x0e,0xdf,0xdf,0x17,0x0d,0x30,0x32,0x30,
4141 0x36,0x30,0x39,0x30,0x31,0x34,0x37,0x31,0x38,0x5a,0x30,0x21,0x02,0x10,0x58,
4142 0x47,0xd9,0xbd,0x83,0x1a,0x63,0x6f,0xb7,0x63,0x7f,0x4a,0x56,0x5e,0x8e,0x4d,
4143 0x17,0x0d,0x30,0x32,0x30,0x34,0x31,0x35,0x31,0x37,0x32,0x33,0x30,0x33,0x5a,
4144 0x30,0x21,0x02,0x10,0x58,0xc6,0x62,0x99,0x80,0xe6,0x0c,0x4f,0x00,0x8b,0x25,
4145 0x38,0x93,0xe6,0x18,0x10,0x17,0x0d,0x30,0x32,0x30,0x36,0x30,0x36,0x30,0x37,
4146 0x30,0x39,0x34,0x37,0x5a,0x30,0x21,0x02,0x10,0x59,0x52,0x09,0x0e,0x99,0xf3,
4147 0xa9,0xe5,0x2f,0xed,0xa9,0xb2,0xd8,0x61,0xe7,0xea,0x17,0x0d,0x30,0x32,0x30,
4148 0x36,0x32,0x36,0x31,0x34,0x31,0x38,0x33,0x36,0x5a,0x30,0x21,0x02,0x10,0x59,
4149 0x5c,0xaa,0xfb,0xbe,0xfb,0x73,0xd1,0xf4,0xab,0xc8,0xe3,0x3d,0x01,0x04,0xdd,
4150 0x17,0x0d,0x30,0x32,0x30,0x39,0x32,0x37,0x32,0x32,0x32,0x30,0x31,0x30,0x5a,
4151 0x30,0x21,0x02,0x10,0x59,0x97,0x59,0xa7,0x3d,0xb0,0xd9,0x7e,0xff,0x2a,0xcb,
4152 0x31,0xcc,0x66,0xf3,0x85,0x17,0x0d,0x30,0x32,0x30,0x38,0x32,0x32,0x30,0x30,
4153 0x35,0x35,0x35,0x38,0x5a,0x30,0x21,0x02,0x10,0x59,0xdd,0x45,0x36,0x61,0xd9,
4154 0x3e,0xe9,0xff,0xbd,0xad,0x2e,0xbf,0x9a,0x5d,0x98,0x17,0x0d,0x30,0x32,0x30,
4155 0x37,0x30,0x32,0x32,0x30,0x34,0x30,0x30,0x33,0x5a,0x30,0x21,0x02,0x10,0x5a,
4156 0x4b,0x48,0x18,0xa9,0x2a,0x9c,0xd5,0x91,0x2f,0x4f,0xa4,0xf8,0xb3,0x1b,0x4d,
4157 0x17,0x0d,0x30,0x32,0x30,0x34,0x30,0x34,0x32,0x33,0x33,0x33,0x31,0x32,0x5a,
4158 0x30,0x21,0x02,0x10,0x5a,0xdf,0x32,0x0d,0x64,0xeb,0x9b,0xd2,0x11,0xe2,0x58,
4159 0x50,0xbe,0x93,0x0c,0x65,0x17,0x0d,0x30,0x32,0x30,0x34,0x30,0x35,0x31,0x37,
4160 0x30,0x37,0x32,0x31,0x5a,0x30,0x21,0x02,0x10,0x5b,0x23,0xbf,0xbb,0xc4,0xb3,
4161 0xf4,0x02,0xe9,0xcb,0x10,0x9e,0xee,0xa5,0x3f,0xcd,0x17,0x0d,0x30,0x32,0x30,
4162 0x33,0x32,0x39,0x31,0x36,0x32,0x36,0x35,0x39,0x5a,0x30,0x21,0x02,0x10,0x5b,
4163 0x51,0xbc,0x38,0xbf,0xaf,0x9f,0x27,0xa9,0xc7,0xed,0x25,0xd0,0x8d,0xec,0x2e,
4164 0x17,0x0d,0x30,0x32,0x30,0x33,0x30,0x38,0x31,0x30,0x32,0x35,0x32,0x30,0x5a,
4165 0x30,0x21,0x02,0x10,0x5c,0x29,0x7f,0x46,0x61,0xdd,0x47,0x90,0x82,0x91,0xbd,
4166 0x79,0x22,0x6a,0x98,0x38,0x17,0x0d,0x30,0x32,0x31,0x31,0x30,0x38,0x31,0x35,
4167 0x35,0x34,0x32,0x36,0x5a,0x30,0x21,0x02,0x10,0x5e,0x38,0xf7,0x5b,0x00,0xf1,
4168 0xef,0x1c,0xb6,0xff,0xd5,0x5c,0x74,0xfb,0x95,0x5d,0x17,0x0d,0x30,0x32,0x31,
4169 0x31,0x32,0x33,0x30,0x31,0x34,0x39,0x32,0x39,0x5a,0x30,0x21,0x02,0x10,0x5e,
4170 0x88,0xbe,0xb6,0xb4,0xb2,0xaa,0xb0,0x92,0xf3,0xf6,0xc2,0xbc,0x72,0x21,0xca,
4171 0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x34,0x30,0x37,0x31,0x32,0x31,0x30,0x5a,
4172 0x30,0x21,0x02,0x10,0x5f,0x59,0xa0,0xbb,0xaf,0x26,0xc8,0xc1,0xb4,0x04,0x3a,
4173 0xbb,0xfc,0x4c,0x75,0xa5,0x17,0x0d,0x30,0x32,0x30,0x34,0x31,0x36,0x31,0x35,
4174 0x35,0x31,0x32,0x33,0x5a,0x30,0x21,0x02,0x10,0x5f,0x81,0x08,0x0f,0xa0,0xcd,
4175 0x44,0x73,0x23,0x58,0x8e,0x49,0x9f,0xb5,0x08,0x35,0x17,0x0d,0x30,0x32,0x30,
4176 0x36,0x31,0x39,0x31,0x34,0x31,0x37,0x34,0x33,0x5a,0x30,0x21,0x02,0x10,0x5f,
4177 0xba,0x1f,0x8f,0xb2,0x23,0x56,0xdd,0xbc,0xa6,0x72,0xb0,0x99,0x13,0xb5,0xb2,
4178 0x17,0x0d,0x30,0x32,0x30,0x35,0x30,0x36,0x30,0x38,0x34,0x37,0x31,0x30,0x5a,
4179 0x30,0x21,0x02,0x10,0x60,0x09,0xd5,0xb7,0x6b,0xf1,0x16,0x4a,0xfa,0xd0,0xa5,
4180 0x4c,0x8e,0xdd,0x02,0xcb,0x17,0x0d,0x30,0x32,0x30,0x36,0x31,0x37,0x31,0x36,
4181 0x31,0x32,0x32,0x39,0x5a,0x30,0x21,0x02,0x10,0x60,0x1d,0x19,0xd8,0x55,0xd5,
4182 0x14,0xd5,0xff,0x03,0x0d,0xad,0x5c,0x07,0x4c,0xe7,0x17,0x0d,0x30,0x32,0x30,
4183 0x37,0x31,0x35,0x32,0x33,0x30,0x31,0x31,0x31,0x5a,0x30,0x21,0x02,0x10,0x60,
4184 0x24,0x67,0xc3,0x0b,0xad,0x53,0x8f,0xce,0x89,0x05,0xb5,0x87,0xaf,0x7c,0xe4,
4185 0x17,0x0d,0x30,0x32,0x31,0x30,0x30,0x38,0x32,0x30,0x33,0x38,0x35,0x32,0x5a,
4186 0x30,0x21,0x02,0x10,0x60,0x5c,0xf3,0x3d,0x22,0x23,0x39,0x3f,0xe6,0x21,0x09,
4187 0xfd,0xdd,0x77,0xc2,0x8f,0x17,0x0d,0x30,0x32,0x30,0x37,0x30,0x32,0x31,0x37,
4188 0x32,0x37,0x35,0x38,0x5a,0x30,0x21,0x02,0x10,0x60,0xa2,0x5e,0xbf,0x07,0x83,
4189 0xa3,0x18,0x56,0x18,0x48,0x63,0xa7,0xfd,0xc7,0x63,0x17,0x0d,0x30,0x32,0x30,
4190 0x35,0x30,0x39,0x31,0x39,0x35,0x32,0x32,0x37,0x5a,0x30,0x21,0x02,0x10,0x60,
4191 0xc2,0xad,0xa8,0x0e,0xf9,0x9a,0x66,0x5d,0xa2,0x75,0x04,0x5e,0x5c,0x71,0xc2,
4192 0x17,0x0d,0x30,0x32,0x31,0x31,0x31,0x32,0x31,0x33,0x33,0x36,0x31,0x37,0x5a,
4193 0x30,0x21,0x02,0x10,0x60,0xdb,0x1d,0x37,0x34,0xf6,0x02,0x9d,0x68,0x1b,0x70,
4194 0xf1,0x13,0x00,0x2f,0x80,0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x38,0x30,0x39,
4195 0x35,0x35,0x33,0x33,0x5a,0x30,0x21,0x02,0x10,0x61,0xf0,0x38,0xea,0xbc,0x17,
4196 0x0d,0x11,0xd2,0x89,0xee,0x87,0x50,0x57,0xa0,0xed,0x17,0x0d,0x30,0x33,0x30,
4197 0x31,0x32,0x39,0x31,0x37,0x34,0x31,0x34,0x34,0x5a,0x30,0x21,0x02,0x10,0x61,
4198 0xfa,0x9b,0xeb,0x58,0xf9,0xe5,0xa5,0x9e,0x79,0xa8,0x3d,0x79,0xac,0x35,0x97,
4199 0x17,0x0d,0x30,0x32,0x31,0x30,0x31,0x30,0x32,0x30,0x31,0x36,0x33,0x37,0x5a,
4200 0x30,0x21,0x02,0x10,0x62,0x44,0x57,0x24,0x41,0xc0,0x89,0x3f,0x5b,0xd2,0xbd,
4201 0xe7,0x2f,0x75,0x41,0xfa,0x17,0x0d,0x30,0x32,0x30,0x38,0x30,0x38,0x31,0x38,
4202 0x33,0x30,0x31,0x35,0x5a,0x30,0x21,0x02,0x10,0x62,0x51,0x3a,0x2d,0x8d,0x82,
4203 0x39,0x65,0xfe,0xf6,0x8a,0xc8,0x4e,0x29,0x91,0xfd,0x17,0x0d,0x30,0x32,0x30,
4204 0x39,0x32,0x36,0x30,0x30,0x35,0x34,0x33,0x34,0x5a,0x30,0x21,0x02,0x10,0x62,
4205 0x52,0x49,0x49,0xf2,0x51,0x67,0x7a,0xe2,0xee,0xc9,0x0c,0x23,0x11,0x3d,0xb2,
4206 0x17,0x0d,0x30,0x32,0x30,0x34,0x31,0x37,0x31,0x38,0x30,0x36,0x35,0x35,0x5a,
4207 0x30,0x21,0x02,0x10,0x63,0x52,0xbd,0xdc,0xb7,0xbf,0xbb,0x90,0x6c,0x82,0xee,
4208 0xb5,0xa3,0x9f,0xd8,0xc9,0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x31,0x31,0x36,
4209 0x33,0x30,0x35,0x38,0x5a,0x30,0x21,0x02,0x10,0x63,0x5e,0x6b,0xe9,0xea,0x3d,
4210 0xd6,0x3b,0xc3,0x4d,0x09,0xc3,0x13,0xdb,0xdd,0xbc,0x17,0x0d,0x30,0x33,0x30,
4211 0x36,0x30,0x32,0x31,0x34,0x34,0x37,0x33,0x36,0x5a,0x30,0x21,0x02,0x10,0x63,
4212 0xda,0x0b,0xd5,0x13,0x1e,0x98,0x83,0x32,0xa2,0x3a,0x4b,0xdf,0x8c,0x89,0x86,
4213 0x17,0x0d,0x30,0x32,0x30,0x39,0x32,0x35,0x30,0x38,0x30,0x38,0x31,0x33,0x5a,
4214 0x30,0x21,0x02,0x10,0x64,0xfe,0xf0,0x1a,0x3a,0xed,0x89,0xf8,0xb5,0x34,0xd3,
4215 0x1e,0x0f,0xce,0x0d,0xce,0x17,0x0d,0x30,0x32,0x30,0x34,0x30,0x38,0x32,0x31,
4216 0x30,0x36,0x32,0x34,0x5a,0x30,0x21,0x02,0x10,0x65,0xa7,0x49,0xd8,0x37,0x22,
4217 0x4b,0x4a,0xe5,0xcf,0xa3,0xfe,0xd6,0x3b,0xc0,0x67,0x17,0x0d,0x30,0x32,0x31,
4218 0x32,0x30,0x34,0x31,0x37,0x31,0x34,0x31,0x36,0x5a,0x30,0x21,0x02,0x10,0x65,
4219 0xc9,0x9e,0x47,0x76,0x98,0x0d,0x9e,0x57,0xe4,0xae,0xc5,0x1c,0x3e,0xf2,0xe7,
4220 0x17,0x0d,0x30,0x32,0x30,0x39,0x32,0x33,0x31,0x34,0x30,0x38,0x31,0x38,0x5a,
4221 0x30,0x21,0x02,0x10,0x65,0xe0,0x7b,0xc5,0x74,0xe4,0xab,0x01,0x4f,0xa3,0x5e,
4222 0xd6,0xeb,0xcd,0xd5,0x69,0x17,0x0d,0x30,0x32,0x30,0x34,0x30,0x33,0x31,0x37,
4223 0x32,0x34,0x30,0x36,0x5a,0x30,0x21,0x02,0x10,0x66,0x51,0xb7,0xe5,0x62,0xb7,
4224 0xe3,0x31,0xc0,0xee,0xf2,0xe8,0xfe,0x84,0x6a,0x4e,0x17,0x0d,0x30,0x32,0x30,
4225 0x39,0x30,0x36,0x31,0x33,0x32,0x33,0x33,0x33,0x5a,0x30,0x21,0x02,0x10,0x67,
4226 0x7c,0x76,0xac,0x66,0x5a,0x6b,0x41,0x5c,0x07,0x83,0x02,0xd6,0xd9,0x63,0xc0,
4227 0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x38,0x31,0x33,0x35,0x35,0x31,0x30,0x5a,
4228 0x30,0x21,0x02,0x10,0x68,0x67,0xde,0xb3,0xaa,0x20,0xcf,0x4b,0x34,0xa5,0xe0,
4229 0xc8,0xc0,0xc5,0xc9,0xa4,0x17,0x0d,0x30,0x32,0x30,0x33,0x31,0x32,0x30,0x31,
4230 0x30,0x39,0x32,0x36,0x5a,0x30,0x21,0x02,0x10,0x69,0x23,0x34,0x5d,0x75,0x04,
4231 0xdc,0x99,0xbd,0xce,0x8d,0x21,0xb4,0x6b,0x10,0xfc,0x17,0x0d,0x30,0x32,0x30,
4232 0x39,0x30,0x33,0x31,0x33,0x31,0x39,0x32,0x30,0x5a,0x30,0x21,0x02,0x10,0x69,
4233 0x9f,0x20,0x31,0xd1,0x3f,0xfa,0x1e,0x70,0x2e,0x37,0xd5,0x9a,0x8c,0x0a,0x16,
4234 0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x30,0x30,0x39,0x30,0x31,0x33,0x35,0x5a,
4235 0x30,0x21,0x02,0x10,0x6a,0x94,0xd6,0x25,0xd0,0x67,0xe4,0x4d,0x79,0x2b,0xc6,
4236 0xd5,0xc9,0x4a,0x7f,0xc6,0x17,0x0d,0x30,0x32,0x30,0x32,0x31,0x31,0x31,0x39,
4237 0x31,0x35,0x34,0x30,0x5a,0x30,0x21,0x02,0x10,0x6b,0x5c,0xa4,0x45,0x5b,0xe9,
4238 0xcf,0xe7,0x3b,0x29,0xb1,0x32,0xd7,0xa1,0x04,0x3d,0x17,0x0d,0x30,0x32,0x31,
4239 0x30,0x31,0x38,0x31,0x35,0x34,0x33,0x34,0x38,0x5a,0x30,0x21,0x02,0x10,0x6b,
4240 0xc0,0x7d,0x4f,0x18,0xfe,0xb7,0x07,0xe8,0x56,0x9a,0x6c,0x40,0x0f,0x36,0x53,
4241 0x17,0x0d,0x30,0x32,0x30,0x39,0x32,0x36,0x32,0x31,0x30,0x31,0x32,0x36,0x5a,
4242 0x30,0x21,0x02,0x10,0x6b,0xe1,0xdd,0x36,0x3b,0xec,0xe0,0xa9,0xf5,0x92,0x7e,
4243 0x33,0xbf,0xed,0x48,0x46,0x17,0x0d,0x30,0x32,0x30,0x34,0x31,0x37,0x31,0x34,
4244 0x34,0x32,0x33,0x31,0x5a,0x30,0x21,0x02,0x10,0x6c,0xac,0xeb,0x37,0x2b,0x6a,
4245 0x42,0xe2,0xca,0xc8,0xd2,0xda,0xb8,0xb9,0x82,0x6a,0x17,0x0d,0x30,0x32,0x30,
4246 0x33,0x30,0x31,0x31,0x34,0x32,0x38,0x33,0x34,0x5a,0x30,0x21,0x02,0x10,0x6d,
4247 0x98,0x1b,0xb4,0x76,0xd1,0x62,0x59,0xa1,0x3c,0xee,0xd2,0x21,0xd8,0xdf,0x4c,
4248 0x17,0x0d,0x30,0x32,0x30,0x35,0x31,0x34,0x31,0x37,0x35,0x36,0x31,0x32,0x5a,
4249 0x30,0x21,0x02,0x10,0x6d,0xdd,0x0b,0x5a,0x3c,0x9c,0xab,0xd3,0x3b,0xd9,0x16,
4250 0xec,0x69,0x74,0xfb,0x9a,0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x32,0x31,0x32,
4251 0x32,0x36,0x33,0x38,0x5a,0x30,0x21,0x02,0x10,0x6e,0xde,0xfd,0x89,0x36,0xae,
4252 0xa0,0x41,0x8d,0x5c,0xec,0x2e,0x90,0x31,0xf8,0x9a,0x17,0x0d,0x30,0x32,0x30,
4253 0x34,0x30,0x38,0x32,0x32,0x33,0x36,0x31,0x32,0x5a,0x30,0x21,0x02,0x10,0x6f,
4254 0xb2,0x6b,0x4c,0x48,0xca,0xfe,0xe6,0x69,0x9a,0x06,0x63,0xc4,0x32,0x96,0xc1,
4255 0x17,0x0d,0x30,0x33,0x30,0x31,0x31,0x37,0x31,0x37,0x32,0x37,0x32,0x35,0x5a,
4256 0x30,0x21,0x02,0x10,0x70,0x0b,0xe1,0xee,0x44,0x89,0x51,0x52,0x65,0x27,0x2c,
4257 0x2d,0x34,0x7c,0xe0,0x8d,0x17,0x0d,0x30,0x32,0x30,0x39,0x31,0x38,0x30,0x30,
4258 0x33,0x36,0x30,0x30,0x5a,0x30,0x21,0x02,0x10,0x70,0x2d,0xc0,0xa6,0xb8,0xa5,
4259 0xa0,0xda,0x48,0x59,0xb3,0x96,0x34,0x80,0xc8,0x25,0x17,0x0d,0x30,0x32,0x30,
4260 0x38,0x33,0x30,0x31,0x34,0x30,0x31,0x30,0x31,0x5a,0x30,0x21,0x02,0x10,0x70,
4261 0xe1,0xd9,0x92,0xcd,0x76,0x42,0x63,0x51,0x6e,0xcd,0x8c,0x09,0x29,0x17,0x48,
4262 0x17,0x0d,0x30,0x32,0x30,0x35,0x31,0x37,0x31,0x31,0x31,0x30,0x34,0x31,0x5a,
4263 0x30,0x21,0x02,0x10,0x72,0x38,0xe4,0x91,0x6a,0x7a,0x8a,0xf3,0xbf,0xf0,0xd8,
4264 0xe0,0xa4,0x70,0x8d,0xa8,0x17,0x0d,0x30,0x32,0x30,0x33,0x30,0x34,0x31,0x39,
4265 0x30,0x36,0x34,0x30,0x5a,0x30,0x21,0x02,0x10,0x72,0x97,0xa1,0xd8,0x9c,0x3b,
4266 0x00,0xc2,0xc4,0x26,0x2d,0x06,0x2b,0x29,0x76,0x4e,0x17,0x0d,0x30,0x32,0x30,
4267 0x36,0x31,0x38,0x31,0x35,0x30,0x39,0x34,0x37,0x5a,0x30,0x21,0x02,0x10,0x72,
4268 0xd2,0x23,0x9b,0xf2,0x33,0xe9,0x7c,0xcf,0xb6,0xa9,0x41,0xd5,0x0e,0x5c,0x39,
4269 0x17,0x0d,0x30,0x33,0x30,0x34,0x30,0x39,0x31,0x37,0x30,0x32,0x32,0x39,0x5a,
4270 0x30,0x21,0x02,0x10,0x74,0x5c,0x9c,0xf9,0xaa,0xc3,0xfa,0x94,0x3c,0x25,0x39,
4271 0x65,0x44,0x95,0x13,0xf1,0x17,0x0d,0x30,0x32,0x30,0x37,0x30,0x39,0x32,0x33,
4272 0x35,0x33,0x32,0x30,0x5a,0x30,0x21,0x02,0x10,0x74,0x98,0x7f,0x68,0xad,0x17,
4273 0x92,0x93,0xf2,0x65,0x94,0x0c,0x33,0xe6,0xbd,0x49,0x17,0x0d,0x30,0x32,0x30,
4274 0x34,0x32,0x33,0x30,0x37,0x34,0x34,0x31,0x38,0x5a,0x30,0x21,0x02,0x10,0x75,
4275 0x0e,0x40,0xff,0x97,0xf0,0x47,0xed,0xf5,0x56,0xc7,0x08,0x4e,0xb1,0xab,0xfd,
4276 0x17,0x0d,0x30,0x31,0x30,0x31,0x33,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,
4277 0x30,0x21,0x02,0x10,0x75,0x26,0x51,0x59,0x65,0xb7,0x33,0x32,0x5f,0xe6,0xcd,
4278 0xaa,0x30,0x65,0x78,0xe0,0x17,0x0d,0x30,0x32,0x30,0x35,0x31,0x36,0x31,0x38,
4279 0x32,0x34,0x35,0x36,0x5a,0x30,0x21,0x02,0x10,0x76,0x13,0x6f,0xbf,0xc8,0xde,
4280 0xd9,0x36,0x30,0x39,0xcc,0x85,0x8f,0x00,0x2f,0x19,0x17,0x0d,0x30,0x32,0x30,
4281 0x33,0x31,0x34,0x30,0x39,0x34,0x38,0x32,0x34,0x5a,0x30,0x21,0x02,0x10,0x76,
4282 0x52,0x78,0x89,0x44,0xfa,0xc1,0xb3,0xd7,0xc9,0x4c,0xb3,0x32,0x95,0xaf,0x03,
4283 0x17,0x0d,0x30,0x32,0x31,0x31,0x31,0x34,0x31,0x39,0x31,0x35,0x34,0x33,0x5a,
4284 0x30,0x21,0x02,0x10,0x77,0x5d,0x4c,0x40,0xd9,0x8d,0xfa,0xc8,0x9a,0x24,0x8d,
4285 0x47,0x10,0x90,0x4a,0x0a,0x17,0x0d,0x30,0x32,0x30,0x35,0x30,0x39,0x30,0x31,
4286 0x31,0x33,0x30,0x32,0x5a,0x30,0x21,0x02,0x10,0x77,0xe6,0x5a,0x43,0x59,0x93,
4287 0x5d,0x5f,0x7a,0x75,0x80,0x1a,0xcd,0xad,0xc2,0x22,0x17,0x0d,0x30,0x30,0x30,
4288 0x38,0x33,0x31,0x31,0x38,0x32,0x32,0x35,0x30,0x5a,0x30,0x21,0x02,0x10,0x78,
4289 0x19,0xf1,0xb6,0x87,0x83,0xaf,0xdf,0x60,0x8d,0x9a,0x64,0x0d,0xec,0xe0,0x51,
4290 0x17,0x0d,0x30,0x32,0x30,0x35,0x32,0x30,0x31,0x37,0x32,0x38,0x31,0x36,0x5a,
4291 0x30,0x21,0x02,0x10,0x78,0x64,0x65,0x8f,0x82,0x79,0xdb,0xa5,0x1c,0x47,0x10,
4292 0x1d,0x72,0x23,0x66,0x52,0x17,0x0d,0x30,0x33,0x30,0x31,0x32,0x34,0x31,0x38,
4293 0x34,0x35,0x34,0x37,0x5a,0x30,0x21,0x02,0x10,0x78,0x64,0xe1,0xc0,0x69,0x8f,
4294 0x3a,0xc7,0x8b,0x23,0xe3,0x29,0xb1,0xee,0xa9,0x41,0x17,0x0d,0x30,0x32,0x30,
4295 0x35,0x30,0x38,0x31,0x37,0x34,0x36,0x32,0x36,0x5a,0x30,0x21,0x02,0x10,0x78,
4296 0x79,0x89,0x61,0x12,0x67,0x64,0x14,0xfd,0x08,0xcc,0xb3,0x05,0x55,0xc0,0x67,
4297 0x17,0x0d,0x30,0x32,0x30,0x34,0x30,0x32,0x31,0x33,0x31,0x38,0x35,0x33,0x5a,
4298 0x30,0x21,0x02,0x10,0x78,0x8a,0x56,0x22,0x08,0xce,0x42,0xee,0xd1,0xa3,0x79,
4299 0x10,0x14,0xfd,0x3a,0x36,0x17,0x0d,0x30,0x33,0x30,0x32,0x30,0x35,0x31,0x36,
4300 0x35,0x33,0x32,0x39,0x5a,0x30,0x21,0x02,0x10,0x7a,0xa0,0x6c,0xba,0x33,0x02,
4301 0xac,0x5f,0xf5,0x0b,0xb6,0x77,0x61,0xef,0x77,0x09,0x17,0x0d,0x30,0x32,0x30,
4302 0x32,0x32,0x38,0x31,0x37,0x35,0x35,0x31,0x31,0x5a,0x30,0x21,0x02,0x10,0x7b,
4303 0x91,0x33,0x66,0x6c,0xf0,0xd4,0xe3,0x9d,0xf6,0x88,0x29,0x9b,0xf7,0xd0,0xea,
4304 0x17,0x0d,0x30,0x32,0x31,0x31,0x32,0x30,0x32,0x32,0x31,0x36,0x34,0x39,0x5a,
4305 0x30,0x21,0x02,0x10,0x7c,0xef,0xf2,0x0a,0x08,0xae,0x10,0x57,0x1e,0xde,0xdc,
4306 0xd6,0x63,0x76,0xb0,0x5d,0x17,0x0d,0x30,0x32,0x30,0x32,0x32,0x36,0x31,0x30,
4307 0x32,0x32,0x33,0x30,0x5a,0x30,0x21,0x02,0x10,0x7f,0x76,0xef,0x69,0xeb,0xf5,
4308 0x3f,0x53,0x2e,0xaa,0xa5,0xed,0xde,0xc0,0xb4,0x06,0x17,0x0d,0x30,0x32,0x30,
4309 0x35,0x30,0x31,0x30,0x33,0x33,0x33,0x30,0x37,0x5a,0x30,0x21,0x02,0x10,0x7f,
4310 0xcb,0x6b,0x99,0x91,0xd0,0x76,0xe1,0x3c,0x0e,0x67,0x15,0xc4,0xd4,0x4d,0x7b,
4311 0x17,0x0d,0x30,0x32,0x30,0x34,0x31,0x30,0x32,0x31,0x31,0x38,0x34,0x30,0x5a,
4312 0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x04,0x05,0x00,
4313 0x03,0x81,0x81,0x00,0x5c,0xb9,0xb3,0xbe,0xd3,0xd6,0x73,0xa3,0xfe,0x4a,0xb2,
4314 0x21,0x80,0xea,0xaa,0x05,0x61,0x14,0x1d,0x67,0xb1,0xdf,0xa6,0xf9,0x42,0x08,
4315 0x0d,0x59,0x62,0x9c,0x11,0x5f,0x0e,0x92,0xc5,0xc6,0xae,0x74,0x64,0xc7,0x84,
4316 0x3e,0x64,0x43,0xd2,0xec,0xbb,0xe1,0x9b,0x52,0x74,0x57,0xcf,0x96,0xef,0x68,
4317 0x02,0x7a,0x7b,0x36,0xb7,0xc6,0x9a,0x5f,0xca,0x9c,0x37,0x47,0xc8,0x3a,0x5c,
4318 0x34,0x35,0x3b,0x4b,0xca,0x20,0x77,0x44,0x68,0x07,0x02,0x34,0x46,0xaa,0x0f,
4319 0xd0,0x4d,0xd9,0x47,0xf4,0xb3,0x2d,0xb1,0x44,0xa5,0x69,0xa9,0x85,0x13,0x43,
4320 0xcd,0xcc,0x1d,0x9a,0xe6,0x2d,0xfd,0x9f,0xdc,0x2f,0x83,0xbb,0x8c,0xe2,0x8c,
4321 0x61,0xc0,0x99,0x16,0x71,0x05,0xb6,0x25,0x14,0x64,0x4f,0x30 };
4323 static void test_decodeCRLToBeSigned(DWORD dwEncoding
)
4325 static const BYTE
*corruptCRLs
[] = { v1CRL
, v2CRL
};
4330 for (i
= 0; i
< sizeof(corruptCRLs
) / sizeof(corruptCRLs
[0]); i
++)
4332 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
,
4333 corruptCRLs
[i
], corruptCRLs
[i
][1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
,
4335 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_CORRUPT
||
4336 GetLastError() == OSS_DATA_ERROR
/* Win9x */),
4337 "Expected CRYPT_E_ASN1_CORRUPT or OSS_DATA_ERROR, got %08x\n",
4340 /* at a minimum, a CRL must contain an issuer: */
4341 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
,
4342 v1CRLWithIssuer
, v1CRLWithIssuer
[1] + 2, CRYPT_DECODE_ALLOC_FLAG
, NULL
,
4344 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4347 CRL_INFO
*info
= (CRL_INFO
*)buf
;
4349 ok(size
>= sizeof(CRL_INFO
), "Wrong size %d\n", size
);
4350 ok(info
->cCRLEntry
== 0, "Expected 0 CRL entries, got %d\n",
4352 ok(info
->Issuer
.cbData
== sizeof(encodedCommonName
),
4353 "Wrong issuer size %d\n", info
->Issuer
.cbData
);
4354 ok(!memcmp(info
->Issuer
.pbData
, encodedCommonName
, info
->Issuer
.cbData
),
4355 "Unexpected issuer\n");
4358 /* check decoding with an empty CRL entry */
4359 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
,
4360 v1CRLWithIssuerAndEmptyEntry
, v1CRLWithIssuerAndEmptyEntry
[1] + 2,
4361 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4362 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_CORRUPT
||
4363 GetLastError() == OSS_DATA_ERROR
/* Win9x */),
4364 "Expected CRYPT_E_ASN1_CORRUPT or OSS_DATA_ERROR, got %08x\n",
4366 /* with a real CRL entry */
4367 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
,
4368 v1CRLWithIssuerAndEntry
, v1CRLWithIssuerAndEntry
[1] + 2,
4369 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4370 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4373 CRL_INFO
*info
= (CRL_INFO
*)buf
;
4376 ok(size
>= sizeof(CRL_INFO
), "Wrong size %d\n", size
);
4377 ok(info
->cCRLEntry
== 1, "Expected 1 CRL entries, got %d\n",
4379 ok(info
->rgCRLEntry
!= NULL
, "Expected a valid CRL entry array\n");
4380 entry
= info
->rgCRLEntry
;
4381 ok(entry
->SerialNumber
.cbData
== 1,
4382 "Expected serial number size 1, got %d\n",
4383 entry
->SerialNumber
.cbData
);
4384 ok(*entry
->SerialNumber
.pbData
== *serialNum
,
4385 "Expected serial number %d, got %d\n", *serialNum
,
4386 *entry
->SerialNumber
.pbData
);
4387 ok(info
->Issuer
.cbData
== sizeof(encodedCommonName
),
4388 "Wrong issuer size %d\n", info
->Issuer
.cbData
);
4389 ok(!memcmp(info
->Issuer
.pbData
, encodedCommonName
, info
->Issuer
.cbData
),
4390 "Unexpected issuer\n");
4393 /* a real CRL from verisign that has extensions */
4394 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
,
4395 verisignCRL
, sizeof(verisignCRL
), CRYPT_DECODE_ALLOC_FLAG
,
4397 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4400 CRL_INFO
*info
= (CRL_INFO
*)buf
;
4403 ok(size
>= sizeof(CRL_INFO
), "Wrong size %d\n", size
);
4404 ok(info
->cCRLEntry
== 3, "Expected 3 CRL entries, got %d\n",
4406 ok(info
->rgCRLEntry
!= NULL
, "Expected a valid CRL entry array\n");
4407 entry
= info
->rgCRLEntry
;
4408 ok(info
->cExtension
== 2, "Expected 2 extensions, got %d\n",
4412 /* another real CRL from verisign that has lots of entries */
4413 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
,
4414 verisignCRLWithLotsOfEntries
, sizeof(verisignCRLWithLotsOfEntries
),
4415 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4416 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4419 CRL_INFO
*info
= (CRL_INFO
*)buf
;
4421 ok(size
>= sizeof(CRL_INFO
), "Got size %d\n", size
);
4422 ok(info
->cCRLEntry
== 209, "Expected 209 CRL entries, got %d\n",
4424 ok(info
->cExtension
== 0, "Expected 0 extensions, got %d\n",
4428 /* and finally, with an extension */
4429 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
,
4430 v1CRLWithExt
, sizeof(v1CRLWithExt
), CRYPT_DECODE_ALLOC_FLAG
,
4432 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4435 CRL_INFO
*info
= (CRL_INFO
*)buf
;
4438 ok(size
>= sizeof(CRL_INFO
), "Wrong size %d\n", size
);
4439 ok(info
->cCRLEntry
== 1, "Expected 1 CRL entries, got %d\n",
4441 ok(info
->rgCRLEntry
!= NULL
, "Expected a valid CRL entry array\n");
4442 entry
= info
->rgCRLEntry
;
4443 ok(entry
->SerialNumber
.cbData
== 1,
4444 "Expected serial number size 1, got %d\n",
4445 entry
->SerialNumber
.cbData
);
4446 ok(*entry
->SerialNumber
.pbData
== *serialNum
,
4447 "Expected serial number %d, got %d\n", *serialNum
,
4448 *entry
->SerialNumber
.pbData
);
4449 ok(info
->Issuer
.cbData
== sizeof(encodedCommonName
),
4450 "Wrong issuer size %d\n", info
->Issuer
.cbData
);
4451 ok(!memcmp(info
->Issuer
.pbData
, encodedCommonName
, info
->Issuer
.cbData
),
4452 "Unexpected issuer\n");
4453 ok(info
->cExtension
== 1, "Expected 1 extensions, got %d\n",
4457 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
,
4458 v2CRLWithExt
, sizeof(v2CRLWithExt
), CRYPT_DECODE_ALLOC_FLAG
,
4460 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4463 CRL_INFO
*info
= (CRL_INFO
*)buf
;
4465 ok(info
->cExtension
== 1, "Expected 1 extensions, got %d\n",
4469 /* And again, with an issuing dist point */
4470 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_CRL_TO_BE_SIGNED
,
4471 v2CRLWithIssuingDistPoint
, sizeof(v2CRLWithIssuingDistPoint
),
4472 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4473 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4476 CRL_INFO
*info
= (CRL_INFO
*)buf
;
4478 ok(info
->cExtension
== 1, "Expected 1 extensions, got %d\n",
4484 static const LPCSTR keyUsages
[] = { szOID_PKIX_KP_CODE_SIGNING
,
4485 szOID_PKIX_KP_CLIENT_AUTH
, szOID_RSA_RSA
};
4486 static const BYTE encodedUsage
[] = {
4487 0x30, 0x1f, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x03,
4488 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02, 0x06, 0x09,
4489 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01 };
4491 static void test_encodeEnhancedKeyUsage(DWORD dwEncoding
)
4496 CERT_ENHKEY_USAGE usage
;
4498 /* Test with empty usage */
4499 usage
.cUsageIdentifier
= 0;
4500 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ENHANCED_KEY_USAGE
, &usage
,
4501 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4502 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4505 ok(size
== sizeof(emptySequence
), "Wrong size %d\n", size
);
4506 ok(!memcmp(buf
, emptySequence
, size
), "Got unexpected value\n");
4509 /* Test with a few usages */
4510 usage
.cUsageIdentifier
= sizeof(keyUsages
) / sizeof(keyUsages
[0]);
4511 usage
.rgpszUsageIdentifier
= (LPSTR
*)keyUsages
;
4512 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_ENHANCED_KEY_USAGE
, &usage
,
4513 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4514 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4517 ok(size
== sizeof(encodedUsage
), "Wrong size %d\n", size
);
4518 ok(!memcmp(buf
, encodedUsage
, size
), "Got unexpected value\n");
4523 static void test_decodeEnhancedKeyUsage(DWORD dwEncoding
)
4529 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ENHANCED_KEY_USAGE
,
4530 emptySequence
, sizeof(emptySequence
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
4532 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4535 CERT_ENHKEY_USAGE
*usage
= (CERT_ENHKEY_USAGE
*)buf
;
4537 ok(size
>= sizeof(CERT_ENHKEY_USAGE
),
4538 "Wrong size %d\n", size
);
4539 ok(usage
->cUsageIdentifier
== 0, "Expected 0 CRL entries, got %d\n",
4540 usage
->cUsageIdentifier
);
4543 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_ENHANCED_KEY_USAGE
,
4544 encodedUsage
, sizeof(encodedUsage
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
4546 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4549 CERT_ENHKEY_USAGE
*usage
= (CERT_ENHKEY_USAGE
*)buf
;
4552 ok(size
>= sizeof(CERT_ENHKEY_USAGE
),
4553 "Wrong size %d\n", size
);
4554 ok(usage
->cUsageIdentifier
== sizeof(keyUsages
) / sizeof(keyUsages
[0]),
4555 "Wrong CRL entries count %d\n", usage
->cUsageIdentifier
);
4556 for (i
= 0; i
< usage
->cUsageIdentifier
; i
++)
4557 ok(!strcmp(usage
->rgpszUsageIdentifier
[i
], keyUsages
[i
]),
4558 "Expected OID %s, got %s\n", keyUsages
[i
],
4559 usage
->rgpszUsageIdentifier
[i
]);
4564 static BYTE keyId
[] = { 1,2,3,4 };
4565 static const BYTE authorityKeyIdWithId
[] = {
4566 0x30,0x06,0x80,0x04,0x01,0x02,0x03,0x04 };
4567 static const BYTE authorityKeyIdWithIssuer
[] = { 0x30,0x19,0xa1,0x17,0x30,0x15,
4568 0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
4569 0x20,0x4c,0x61,0x6e,0x67,0x00 };
4570 static const BYTE authorityKeyIdWithSerial
[] = { 0x30,0x03,0x82,0x01,0x01 };
4572 static void test_encodeAuthorityKeyId(DWORD dwEncoding
)
4574 CERT_AUTHORITY_KEY_ID_INFO info
= { { 0 } };
4579 /* Test with empty id */
4580 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID
, &info
,
4581 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4582 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4585 ok(size
== sizeof(emptySequence
), "Unexpected size %d\n", size
);
4586 ok(!memcmp(buf
, emptySequence
, size
), "Unexpected value\n");
4589 /* With just a key id */
4590 info
.KeyId
.cbData
= sizeof(keyId
);
4591 info
.KeyId
.pbData
= keyId
;
4592 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID
, &info
,
4593 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4594 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4597 ok(size
== sizeof(authorityKeyIdWithId
), "Unexpected size %d\n", size
);
4598 ok(!memcmp(buf
, authorityKeyIdWithId
, size
), "Unexpected value\n");
4601 /* With just an issuer */
4602 info
.KeyId
.cbData
= 0;
4603 info
.CertIssuer
.cbData
= sizeof(encodedCommonName
);
4604 info
.CertIssuer
.pbData
= (BYTE
*)encodedCommonName
;
4605 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID
, &info
,
4606 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4607 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4610 ok(size
== sizeof(authorityKeyIdWithIssuer
), "Unexpected size %d\n",
4612 ok(!memcmp(buf
, authorityKeyIdWithIssuer
, size
), "Unexpected value\n");
4615 /* With just a serial number */
4616 info
.CertIssuer
.cbData
= 0;
4617 info
.CertSerialNumber
.cbData
= sizeof(serialNum
);
4618 info
.CertSerialNumber
.pbData
= (BYTE
*)serialNum
;
4619 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID
, &info
,
4620 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4621 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4624 ok(size
== sizeof(authorityKeyIdWithSerial
), "Unexpected size %d\n",
4626 ok(!memcmp(buf
, authorityKeyIdWithSerial
, size
), "Unexpected value\n");
4631 static void test_decodeAuthorityKeyId(DWORD dwEncoding
)
4637 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID
,
4638 emptySequence
, sizeof(emptySequence
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
4640 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4643 CERT_AUTHORITY_KEY_ID_INFO
*info
= (CERT_AUTHORITY_KEY_ID_INFO
*)buf
;
4645 ok(size
>= sizeof(CERT_AUTHORITY_KEY_ID_INFO
), "Unexpected size %d\n",
4647 ok(info
->KeyId
.cbData
== 0, "Expected no key id\n");
4648 ok(info
->CertIssuer
.cbData
== 0, "Expected no issuer name\n");
4649 ok(info
->CertSerialNumber
.cbData
== 0, "Expected no serial number\n");
4652 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID
,
4653 authorityKeyIdWithId
, sizeof(authorityKeyIdWithId
),
4654 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4655 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4658 CERT_AUTHORITY_KEY_ID_INFO
*info
= (CERT_AUTHORITY_KEY_ID_INFO
*)buf
;
4660 ok(size
>= sizeof(CERT_AUTHORITY_KEY_ID_INFO
), "Unexpected size %d\n",
4662 ok(info
->KeyId
.cbData
== sizeof(keyId
), "Unexpected key id len\n");
4663 ok(!memcmp(info
->KeyId
.pbData
, keyId
, sizeof(keyId
)),
4664 "Unexpected key id\n");
4665 ok(info
->CertIssuer
.cbData
== 0, "Expected no issuer name\n");
4666 ok(info
->CertSerialNumber
.cbData
== 0, "Expected no serial number\n");
4669 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID
,
4670 authorityKeyIdWithIssuer
, sizeof(authorityKeyIdWithIssuer
),
4671 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4672 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4675 CERT_AUTHORITY_KEY_ID_INFO
*info
= (CERT_AUTHORITY_KEY_ID_INFO
*)buf
;
4677 ok(size
>= sizeof(CERT_AUTHORITY_KEY_ID_INFO
), "Unexpected size %d\n",
4679 ok(info
->KeyId
.cbData
== 0, "Expected no key id\n");
4680 ok(info
->CertIssuer
.cbData
== sizeof(encodedCommonName
),
4681 "Unexpected issuer len\n");
4682 ok(!memcmp(info
->CertIssuer
.pbData
, encodedCommonName
,
4683 sizeof(encodedCommonName
)), "Unexpected issuer\n");
4684 ok(info
->CertSerialNumber
.cbData
== 0, "Expected no serial number\n");
4687 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID
,
4688 authorityKeyIdWithSerial
, sizeof(authorityKeyIdWithSerial
),
4689 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4690 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4693 CERT_AUTHORITY_KEY_ID_INFO
*info
= (CERT_AUTHORITY_KEY_ID_INFO
*)buf
;
4695 ok(size
>= sizeof(CERT_AUTHORITY_KEY_ID_INFO
), "Unexpected size %d\n",
4697 ok(info
->KeyId
.cbData
== 0, "Expected no key id\n");
4698 ok(info
->CertIssuer
.cbData
== 0, "Expected no issuer name\n");
4699 ok(info
->CertSerialNumber
.cbData
== sizeof(serialNum
),
4700 "Unexpected serial number len\n");
4701 ok(!memcmp(info
->CertSerialNumber
.pbData
, serialNum
, sizeof(serialNum
)),
4702 "Unexpected serial number\n");
4707 static const BYTE authorityKeyIdWithIssuerUrl
[] = { 0x30,0x15,0xa1,0x13,0x86,
4708 0x11,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x77,0x69,0x6e,0x65,0x68,0x71,0x2e,
4711 static void test_encodeAuthorityKeyId2(DWORD dwEncoding
)
4713 CERT_AUTHORITY_KEY_ID2_INFO info
= { { 0 } };
4714 CERT_ALT_NAME_ENTRY entry
= { 0 };
4719 /* Test with empty id */
4720 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID2
, &info
,
4721 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4722 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4725 ok(size
== sizeof(emptySequence
), "Unexpected size %d\n", size
);
4726 ok(!memcmp(buf
, emptySequence
, size
), "Unexpected value\n");
4729 /* With just a key id */
4730 info
.KeyId
.cbData
= sizeof(keyId
);
4731 info
.KeyId
.pbData
= keyId
;
4732 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID2
, &info
,
4733 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4734 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4737 ok(size
== sizeof(authorityKeyIdWithId
), "Unexpected size %d\n",
4739 ok(!memcmp(buf
, authorityKeyIdWithId
, size
), "Unexpected value\n");
4742 /* With a bogus issuer name */
4743 info
.KeyId
.cbData
= 0;
4744 info
.AuthorityCertIssuer
.cAltEntry
= 1;
4745 info
.AuthorityCertIssuer
.rgAltEntry
= &entry
;
4746 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID2
, &info
,
4747 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4748 ok(!ret
&& GetLastError() == E_INVALIDARG
,
4749 "Expected E_INVALIDARG, got %08x\n", GetLastError());
4750 /* With an issuer name */
4751 entry
.dwAltNameChoice
= CERT_ALT_NAME_URL
;
4752 U(entry
).pwszURL
= (LPWSTR
)url
;
4753 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID2
, &info
,
4754 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4755 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4758 ok(size
== sizeof(authorityKeyIdWithIssuerUrl
), "Unexpected size %d\n",
4760 ok(!memcmp(buf
, authorityKeyIdWithIssuerUrl
, size
),
4761 "Unexpected value\n");
4764 /* With just a serial number */
4765 info
.AuthorityCertIssuer
.cAltEntry
= 0;
4766 info
.AuthorityCertSerialNumber
.cbData
= sizeof(serialNum
);
4767 info
.AuthorityCertSerialNumber
.pbData
= (BYTE
*)serialNum
;
4768 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID2
, &info
,
4769 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4770 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4773 ok(size
== sizeof(authorityKeyIdWithSerial
), "Unexpected size %d\n",
4775 ok(!memcmp(buf
, authorityKeyIdWithSerial
, size
), "Unexpected value\n");
4780 static void test_decodeAuthorityKeyId2(DWORD dwEncoding
)
4786 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID2
,
4787 emptySequence
, sizeof(emptySequence
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
4789 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4792 CERT_AUTHORITY_KEY_ID2_INFO
*info
= (CERT_AUTHORITY_KEY_ID2_INFO
*)buf
;
4794 ok(size
>= sizeof(CERT_AUTHORITY_KEY_ID2_INFO
), "Unexpected size %d\n",
4796 ok(info
->KeyId
.cbData
== 0, "Expected no key id\n");
4797 ok(info
->AuthorityCertIssuer
.cAltEntry
== 0,
4798 "Expected no issuer name entries\n");
4799 ok(info
->AuthorityCertSerialNumber
.cbData
== 0,
4800 "Expected no serial number\n");
4803 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID2
,
4804 authorityKeyIdWithId
, sizeof(authorityKeyIdWithId
),
4805 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4806 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4809 CERT_AUTHORITY_KEY_ID2_INFO
*info
= (CERT_AUTHORITY_KEY_ID2_INFO
*)buf
;
4811 ok(size
>= sizeof(CERT_AUTHORITY_KEY_ID2_INFO
), "Unexpected size %d\n",
4813 ok(info
->KeyId
.cbData
== sizeof(keyId
), "Unexpected key id len\n");
4814 ok(!memcmp(info
->KeyId
.pbData
, keyId
, sizeof(keyId
)),
4815 "Unexpected key id\n");
4816 ok(info
->AuthorityCertIssuer
.cAltEntry
== 0,
4817 "Expected no issuer name entries\n");
4818 ok(info
->AuthorityCertSerialNumber
.cbData
== 0,
4819 "Expected no serial number\n");
4822 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID2
,
4823 authorityKeyIdWithIssuerUrl
, sizeof(authorityKeyIdWithIssuerUrl
),
4824 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4825 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4828 CERT_AUTHORITY_KEY_ID2_INFO
*info
= (CERT_AUTHORITY_KEY_ID2_INFO
*)buf
;
4830 ok(size
>= sizeof(CERT_AUTHORITY_KEY_ID2_INFO
), "Unexpected size %d\n",
4832 ok(info
->KeyId
.cbData
== 0, "Expected no key id\n");
4833 ok(info
->AuthorityCertIssuer
.cAltEntry
== 1,
4834 "Expected 1 issuer entry, got %d\n",
4835 info
->AuthorityCertIssuer
.cAltEntry
);
4836 ok(info
->AuthorityCertIssuer
.rgAltEntry
[0].dwAltNameChoice
==
4837 CERT_ALT_NAME_URL
, "Expected CERT_ALT_NAME_URL, got %d\n",
4838 info
->AuthorityCertIssuer
.rgAltEntry
[0].dwAltNameChoice
);
4839 ok(!lstrcmpW(U(info
->AuthorityCertIssuer
.rgAltEntry
[0]).pwszURL
,
4840 url
), "Unexpected URL\n");
4841 ok(info
->AuthorityCertSerialNumber
.cbData
== 0,
4842 "Expected no serial number\n");
4845 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_AUTHORITY_KEY_ID2
,
4846 authorityKeyIdWithSerial
, sizeof(authorityKeyIdWithSerial
),
4847 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4848 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
4851 CERT_AUTHORITY_KEY_ID2_INFO
*info
= (CERT_AUTHORITY_KEY_ID2_INFO
*)buf
;
4853 ok(size
>= sizeof(CERT_AUTHORITY_KEY_ID2_INFO
), "Unexpected size %d\n",
4855 ok(info
->KeyId
.cbData
== 0, "Expected no key id\n");
4856 ok(info
->AuthorityCertIssuer
.cAltEntry
== 0,
4857 "Expected no issuer name entries\n");
4858 ok(info
->AuthorityCertSerialNumber
.cbData
== sizeof(serialNum
),
4859 "Unexpected serial number len\n");
4860 ok(!memcmp(info
->AuthorityCertSerialNumber
.pbData
, serialNum
,
4861 sizeof(serialNum
)), "Unexpected serial number\n");
4866 static const BYTE authorityInfoAccessWithUrl
[] = {
4867 0x30,0x19,0x30,0x17,0x06,0x02,0x2a,0x03,0x86,0x11,0x68,0x74,0x74,0x70,0x3a,
4868 0x2f,0x2f,0x77,0x69,0x6e,0x65,0x68,0x71,0x2e,0x6f,0x72,0x67 };
4869 static const BYTE authorityInfoAccessWithUrlAndIPAddr
[] = {
4870 0x30,0x29,0x30,0x17,0x06,0x02,0x2a,0x03,0x86,0x11,0x68,0x74,0x74,0x70,0x3a,
4871 0x2f,0x2f,0x77,0x69,0x6e,0x65,0x68,0x71,0x2e,0x6f,0x72,0x67,0x30,0x0e,0x06,
4872 0x02,0x2d,0x06,0x87,0x08,0x30,0x06,0x87,0x04,0x7f,0x00,0x00,0x01 };
4874 static void test_encodeAuthorityInfoAccess(DWORD dwEncoding
)
4876 static char oid1
[] = "1.2.3";
4877 static char oid2
[] = "1.5.6";
4881 CERT_ACCESS_DESCRIPTION accessDescription
[2];
4882 CERT_AUTHORITY_INFO_ACCESS aia
;
4884 memset(accessDescription
, 0, sizeof(accessDescription
));
4886 aia
.rgAccDescr
= NULL
;
4887 /* Having no access descriptions is allowed */
4888 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_INFO_ACCESS
, &aia
,
4889 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4890 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4893 ok(size
== sizeof(emptySequence
), "unexpected size %d\n", size
);
4894 ok(!memcmp(buf
, emptySequence
, size
), "unexpected value\n");
4898 /* It can't have an empty access method */
4900 aia
.rgAccDescr
= accessDescription
;
4901 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_INFO_ACCESS
, &aia
,
4902 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4903 ok(!ret
&& (GetLastError() == E_INVALIDARG
||
4904 GetLastError() == OSS_LIMITED
/* Win9x */),
4905 "expected E_INVALIDARG or OSS_LIMITED, got %08x\n", GetLastError());
4906 /* It can't have an empty location */
4907 accessDescription
[0].pszAccessMethod
= oid1
;
4908 SetLastError(0xdeadbeef);
4909 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_INFO_ACCESS
, &aia
,
4910 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4911 ok(!ret
&& GetLastError() == E_INVALIDARG
,
4912 "expected E_INVALIDARG, got %08x\n", GetLastError());
4913 accessDescription
[0].AccessLocation
.dwAltNameChoice
= CERT_ALT_NAME_URL
;
4914 U(accessDescription
[0].AccessLocation
).pwszURL
= (LPWSTR
)url
;
4915 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_INFO_ACCESS
, &aia
,
4916 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4917 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4920 ok(size
== sizeof(authorityInfoAccessWithUrl
), "unexpected size %d\n",
4922 ok(!memcmp(buf
, authorityInfoAccessWithUrl
, size
),
4923 "unexpected value\n");
4927 accessDescription
[1].pszAccessMethod
= oid2
;
4928 accessDescription
[1].AccessLocation
.dwAltNameChoice
=
4929 CERT_ALT_NAME_IP_ADDRESS
;
4930 U(accessDescription
[1].AccessLocation
).IPAddress
.cbData
=
4931 sizeof(encodedIPAddr
);
4932 U(accessDescription
[1].AccessLocation
).IPAddress
.pbData
=
4933 (LPBYTE
)encodedIPAddr
;
4935 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_AUTHORITY_INFO_ACCESS
, &aia
,
4936 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4937 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
4940 ok(size
== sizeof(authorityInfoAccessWithUrlAndIPAddr
),
4941 "unexpected size %d\n", size
);
4942 ok(!memcmp(buf
, authorityInfoAccessWithUrlAndIPAddr
, size
),
4943 "unexpected value\n");
4949 static void compareAuthorityInfoAccess(LPCSTR header
,
4950 const CERT_AUTHORITY_INFO_ACCESS
*expected
,
4951 const CERT_AUTHORITY_INFO_ACCESS
*got
)
4955 ok(expected
->cAccDescr
== got
->cAccDescr
,
4956 "%s: expected %d access descriptions, got %d\n", header
,
4957 expected
->cAccDescr
, got
->cAccDescr
);
4958 for (i
= 0; i
< expected
->cAccDescr
; i
++)
4960 ok(!strcmp(expected
->rgAccDescr
[i
].pszAccessMethod
,
4961 got
->rgAccDescr
[i
].pszAccessMethod
), "%s[%d]: expected %s, got %s\n",
4962 header
, i
, expected
->rgAccDescr
[i
].pszAccessMethod
,
4963 got
->rgAccDescr
[i
].pszAccessMethod
);
4964 compareAltNameEntry(&expected
->rgAccDescr
[i
].AccessLocation
,
4965 &got
->rgAccDescr
[i
].AccessLocation
);
4969 static void test_decodeAuthorityInfoAccess(DWORD dwEncoding
)
4971 static char oid1
[] = "1.2.3";
4972 static char oid2
[] = "1.5.6";
4977 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_AUTHORITY_INFO_ACCESS
,
4978 emptySequence
, sizeof(emptySequence
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
4980 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
4983 CERT_AUTHORITY_INFO_ACCESS aia
= { 0, NULL
};
4985 compareAuthorityInfoAccess("empty AIA", &aia
,
4986 (CERT_AUTHORITY_INFO_ACCESS
*)buf
);
4990 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_AUTHORITY_INFO_ACCESS
,
4991 authorityInfoAccessWithUrl
, sizeof(authorityInfoAccessWithUrl
),
4992 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
4993 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
4996 CERT_ACCESS_DESCRIPTION accessDescription
;
4997 CERT_AUTHORITY_INFO_ACCESS aia
;
4999 accessDescription
.pszAccessMethod
= oid1
;
5000 accessDescription
.AccessLocation
.dwAltNameChoice
= CERT_ALT_NAME_URL
;
5001 U(accessDescription
.AccessLocation
).pwszURL
= (LPWSTR
)url
;
5003 aia
.rgAccDescr
= &accessDescription
;
5004 compareAuthorityInfoAccess("AIA with URL", &aia
,
5005 (CERT_AUTHORITY_INFO_ACCESS
*)buf
);
5009 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_AUTHORITY_INFO_ACCESS
,
5010 authorityInfoAccessWithUrlAndIPAddr
,
5011 sizeof(authorityInfoAccessWithUrlAndIPAddr
), CRYPT_DECODE_ALLOC_FLAG
,
5013 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
5016 CERT_ACCESS_DESCRIPTION accessDescription
[2];
5017 CERT_AUTHORITY_INFO_ACCESS aia
;
5019 accessDescription
[0].pszAccessMethod
= oid1
;
5020 accessDescription
[0].AccessLocation
.dwAltNameChoice
= CERT_ALT_NAME_URL
;
5021 U(accessDescription
[0].AccessLocation
).pwszURL
= (LPWSTR
)url
;
5022 accessDescription
[1].pszAccessMethod
= oid2
;
5023 accessDescription
[1].AccessLocation
.dwAltNameChoice
=
5024 CERT_ALT_NAME_IP_ADDRESS
;
5025 U(accessDescription
[1].AccessLocation
).IPAddress
.cbData
=
5026 sizeof(encodedIPAddr
);
5027 U(accessDescription
[1].AccessLocation
).IPAddress
.pbData
=
5028 (LPBYTE
)encodedIPAddr
;
5030 aia
.rgAccDescr
= accessDescription
;
5031 compareAuthorityInfoAccess("AIA with URL and IP addr", &aia
,
5032 (CERT_AUTHORITY_INFO_ACCESS
*)buf
);
5038 static const BYTE emptyCTL
[] = {
5039 0x30,0x17,0x30,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
5040 0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00 };
5041 static const BYTE emptyCTLWithVersion1
[] = {
5042 0x30,0x1a,0x02,0x01,0x01,0x30,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
5043 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00 };
5044 static const BYTE ctlWithUsageIdentifier
[] = {
5045 0x30,0x1b,0x30,0x04,0x06,0x02,0x2a,0x03,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,
5046 0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00 };
5047 static const BYTE ctlWithListIdentifier
[] = {
5048 0x30,0x1a,0x30,0x00,0x04,0x01,0x01,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
5049 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00 };
5050 static const BYTE ctlWithSequenceNumber
[] = {
5051 0x30,0x1a,0x30,0x00,0x02,0x01,0x01,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
5052 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00 };
5053 static const BYTE ctlWithThisUpdate
[] = {
5054 0x30,0x15,0x30,0x00,0x17,0x0d,0x30,0x35,0x30,0x36,0x30,0x36,0x31,0x36,0x31,
5055 0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00 };
5056 static const BYTE ctlWithThisAndNextUpdate
[] = {
5057 0x30,0x24,0x30,0x00,0x17,0x0d,0x30,0x35,0x30,0x36,0x30,0x36,0x31,0x36,0x31,
5058 0x30,0x30,0x30,0x5a,0x17,0x0d,0x30,0x35,0x30,0x36,0x30,0x36,0x31,0x36,0x31,
5059 0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00 };
5060 static const BYTE ctlWithAlgId
[] = {
5061 0x30,0x1b,0x30,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
5062 0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x06,0x06,0x02,0x2d,0x06,0x05,0x00 };
5063 static const BYTE ctlWithBogusEntry
[] = {
5064 0x30,0x29,0x30,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
5065 0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00,0x30,0x10,0x30,0x0e,0x04,
5066 0x01,0x01,0x31,0x09,0x30,0x07,0x06,0x02,0x2a,0x03,0x31,0x01,0x01 };
5067 static const BYTE ctlWithOneEntry
[] = {
5068 0x30,0x2a,0x30,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
5069 0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00,0x30,0x11,0x30,0x0f,0x04,
5070 0x01,0x01,0x31,0x0a,0x30,0x08,0x06,0x02,0x2a,0x03,0x31,0x02,0x30,0x00 };
5071 static const BYTE ctlWithTwoEntries
[] = {
5072 0x30,0x41,0x30,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
5073 0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00,0x30,0x28,0x30,0x0f,0x04,
5074 0x01,0x01,0x31,0x0a,0x30,0x08,0x06,0x02,0x2a,0x03,0x31,0x02,0x30,0x00,0x30,
5075 0x15,0x04,0x01,0x01,0x31,0x10,0x30,0x0e,0x06,0x02,0x2d,0x06,0x31,0x08,0x30,
5076 0x06,0x87,0x04,0x7f,0x00,0x00,0x01 };
5078 static void test_encodeCTL(DWORD dwEncoding
)
5080 static char oid1
[] = "1.2.3";
5081 static char oid2
[] = "1.5.6";
5087 SYSTEMTIME thisUpdate
= { 2005, 6, 1, 6, 16, 10, 0, 0 };
5088 CTL_ENTRY ctlEntry
[2];
5089 CRYPT_ATTRIBUTE attr1
, attr2
;
5090 CRYPT_ATTR_BLOB value1
, value2
;
5092 memset(&info
, 0, sizeof(info
));
5093 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CTL
, &info
,
5094 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5095 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
5098 ok(size
== sizeof(emptyCTL
), "unexpected size %d\n", size
);
5099 ok(!memcmp(buf
, emptyCTL
, size
), "unexpected value\n");
5104 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CTL
, &info
,
5105 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5106 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
5109 ok(size
== sizeof(emptyCTLWithVersion1
), "unexpected size %d\n", size
);
5110 ok(!memcmp(buf
, emptyCTLWithVersion1
, size
), "unexpected value\n");
5115 info
.SubjectUsage
.cUsageIdentifier
= 1;
5116 info
.SubjectUsage
.rgpszUsageIdentifier
= &pOid1
;
5117 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CTL
, &info
,
5118 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5119 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
5122 ok(size
== sizeof(ctlWithUsageIdentifier
), "unexpected size %d\n",
5124 ok(!memcmp(buf
, ctlWithUsageIdentifier
, size
), "unexpected value\n");
5128 info
.SubjectUsage
.cUsageIdentifier
= 0;
5129 info
.ListIdentifier
.cbData
= sizeof(serialNum
);
5130 info
.ListIdentifier
.pbData
= (LPBYTE
)serialNum
;
5131 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CTL
, &info
,
5132 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5133 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
5136 ok(size
== sizeof(ctlWithListIdentifier
), "unexpected size %d\n", size
);
5137 ok(!memcmp(buf
, ctlWithListIdentifier
, size
), "unexpected value\n");
5141 info
.ListIdentifier
.cbData
= 0;
5142 info
.SequenceNumber
.cbData
= sizeof(serialNum
);
5143 info
.SequenceNumber
.pbData
= (LPBYTE
)serialNum
;
5144 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CTL
, &info
,
5145 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5146 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
5149 ok(size
== sizeof(ctlWithSequenceNumber
), "unexpected size %d\n",
5151 ok(!memcmp(buf
, ctlWithSequenceNumber
, size
), "unexpected value\n");
5155 info
.SequenceNumber
.cbData
= 0;
5156 SystemTimeToFileTime(&thisUpdate
, &info
.ThisUpdate
);
5157 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CTL
, &info
,
5158 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5159 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
5162 ok(size
== sizeof(ctlWithThisUpdate
), "unexpected size %d\n", size
);
5163 ok(!memcmp(buf
, ctlWithThisUpdate
, size
), "unexpected value\n");
5167 SystemTimeToFileTime(&thisUpdate
, &info
.NextUpdate
);
5168 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CTL
, &info
,
5169 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5170 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
5173 ok(size
== sizeof(ctlWithThisAndNextUpdate
), "unexpected size %d\n",
5175 ok(!memcmp(buf
, ctlWithThisAndNextUpdate
, size
), "unexpected value\n");
5179 info
.ThisUpdate
.dwLowDateTime
= info
.ThisUpdate
.dwHighDateTime
= 0;
5180 info
.NextUpdate
.dwLowDateTime
= info
.NextUpdate
.dwHighDateTime
= 0;
5181 info
.SubjectAlgorithm
.pszObjId
= oid2
;
5182 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CTL
, &info
,
5183 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5184 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
5187 ok(size
== sizeof(ctlWithAlgId
), "unexpected size %d\n", size
);
5188 ok(!memcmp(buf
, ctlWithAlgId
, size
), "unexpected value\n");
5192 /* The value is supposed to be asn.1 encoded, so this'll fail to decode
5193 * (see tests below) but it'll encode fine.
5195 info
.SubjectAlgorithm
.pszObjId
= NULL
;
5196 value1
.cbData
= sizeof(serialNum
);
5197 value1
.pbData
= (LPBYTE
)serialNum
;
5198 attr1
.pszObjId
= oid1
;
5200 attr1
.rgValue
= &value1
;
5201 ctlEntry
[0].SubjectIdentifier
.cbData
= sizeof(serialNum
);
5202 ctlEntry
[0].SubjectIdentifier
.pbData
= (LPBYTE
)serialNum
;
5203 ctlEntry
[0].cAttribute
= 1;
5204 ctlEntry
[0].rgAttribute
= &attr1
;
5206 info
.rgCTLEntry
= ctlEntry
;
5207 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CTL
, &info
,
5208 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5209 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
5212 ok(size
== sizeof(ctlWithBogusEntry
), "unexpected size %d\n", size
);
5213 ok(!memcmp(buf
, ctlWithBogusEntry
, size
), "unexpected value\n");
5217 value1
.cbData
= sizeof(emptySequence
);
5218 value1
.pbData
= (LPBYTE
)emptySequence
;
5219 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CTL
, &info
,
5220 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5221 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
5224 ok(size
== sizeof(ctlWithOneEntry
), "unexpected size %d\n", size
);
5225 ok(!memcmp(buf
, ctlWithOneEntry
, size
), "unexpected value\n");
5229 value2
.cbData
= sizeof(encodedIPAddr
);
5230 value2
.pbData
= (LPBYTE
)encodedIPAddr
;
5231 attr2
.pszObjId
= oid2
;
5233 attr2
.rgValue
= &value2
;
5234 ctlEntry
[1].SubjectIdentifier
.cbData
= sizeof(serialNum
);
5235 ctlEntry
[1].SubjectIdentifier
.pbData
= (LPBYTE
)serialNum
;
5236 ctlEntry
[1].cAttribute
= 1;
5237 ctlEntry
[1].rgAttribute
= &attr2
;
5239 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CTL
, &info
,
5240 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5241 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
5244 ok(size
== sizeof(ctlWithTwoEntries
), "unexpected size %d\n", size
);
5245 ok(!memcmp(buf
, ctlWithTwoEntries
, size
), "unexpected value\n");
5251 static void compareCTLInfo(LPCSTR header
, const CTL_INFO
*expected
,
5252 const CTL_INFO
*got
)
5256 ok(expected
->dwVersion
== got
->dwVersion
,
5257 "%s: expected version %d, got %d\n", header
, expected
->dwVersion
,
5259 ok(expected
->SubjectUsage
.cUsageIdentifier
==
5260 got
->SubjectUsage
.cUsageIdentifier
,
5261 "%s: expected %d usage identifiers, got %d\n", header
,
5262 expected
->SubjectUsage
.cUsageIdentifier
,
5263 got
->SubjectUsage
.cUsageIdentifier
);
5264 for (i
= 0; i
< expected
->SubjectUsage
.cUsageIdentifier
; i
++)
5265 ok(!strcmp(expected
->SubjectUsage
.rgpszUsageIdentifier
[i
],
5266 got
->SubjectUsage
.rgpszUsageIdentifier
[i
]),
5267 "%s[%d]: expected %s, got %s\n", header
, i
,
5268 expected
->SubjectUsage
.rgpszUsageIdentifier
[i
],
5269 got
->SubjectUsage
.rgpszUsageIdentifier
[i
]);
5270 ok(expected
->ListIdentifier
.cbData
== got
->ListIdentifier
.cbData
,
5271 "%s: expected list identifier of %d bytes, got %d\n", header
,
5272 expected
->ListIdentifier
.cbData
, got
->ListIdentifier
.cbData
);
5273 if (expected
->ListIdentifier
.cbData
)
5274 ok(!memcmp(expected
->ListIdentifier
.pbData
, got
->ListIdentifier
.pbData
,
5275 expected
->ListIdentifier
.cbData
),
5276 "%s: unexpected list identifier value\n", header
);
5277 ok(expected
->SequenceNumber
.cbData
== got
->SequenceNumber
.cbData
,
5278 "%s: expected sequence number of %d bytes, got %d\n", header
,
5279 expected
->SequenceNumber
.cbData
, got
->SequenceNumber
.cbData
);
5280 if (expected
->SequenceNumber
.cbData
)
5281 ok(!memcmp(expected
->SequenceNumber
.pbData
, got
->SequenceNumber
.pbData
,
5282 expected
->SequenceNumber
.cbData
),
5283 "%s: unexpected sequence number value\n", header
);
5284 ok(!memcmp(&expected
->ThisUpdate
, &got
->ThisUpdate
, sizeof(FILETIME
)),
5285 "%s: expected this update = (%d, %d), got (%d, %d)\n", header
,
5286 expected
->ThisUpdate
.dwLowDateTime
, expected
->ThisUpdate
.dwHighDateTime
,
5287 got
->ThisUpdate
.dwLowDateTime
, got
->ThisUpdate
.dwHighDateTime
);
5288 ok(!memcmp(&expected
->NextUpdate
, &got
->NextUpdate
, sizeof(FILETIME
)),
5289 "%s: expected next update = (%d, %d), got (%d, %d)\n", header
,
5290 expected
->NextUpdate
.dwLowDateTime
, expected
->NextUpdate
.dwHighDateTime
,
5291 got
->NextUpdate
.dwLowDateTime
, got
->NextUpdate
.dwHighDateTime
);
5292 if (expected
->SubjectAlgorithm
.pszObjId
&&
5293 *expected
->SubjectAlgorithm
.pszObjId
&& !got
->SubjectAlgorithm
.pszObjId
)
5294 ok(0, "%s: expected subject algorithm %s, got NULL\n", header
,
5295 expected
->SubjectAlgorithm
.pszObjId
);
5296 if (expected
->SubjectAlgorithm
.pszObjId
&& got
->SubjectAlgorithm
.pszObjId
)
5297 ok(!strcmp(expected
->SubjectAlgorithm
.pszObjId
,
5298 got
->SubjectAlgorithm
.pszObjId
),
5299 "%s: expected subject algorithm %s, got %s\n", header
,
5300 expected
->SubjectAlgorithm
.pszObjId
, got
->SubjectAlgorithm
.pszObjId
);
5301 ok(expected
->SubjectAlgorithm
.Parameters
.cbData
==
5302 got
->SubjectAlgorithm
.Parameters
.cbData
,
5303 "%s: expected subject algorithm parameters of %d bytes, got %d\n", header
,
5304 expected
->SubjectAlgorithm
.Parameters
.cbData
,
5305 got
->SubjectAlgorithm
.Parameters
.cbData
);
5306 if (expected
->SubjectAlgorithm
.Parameters
.cbData
)
5307 ok(!memcmp(expected
->SubjectAlgorithm
.Parameters
.pbData
,
5308 got
->SubjectAlgorithm
.Parameters
.pbData
,
5309 expected
->SubjectAlgorithm
.Parameters
.cbData
),
5310 "%s: unexpected subject algorithm parameter value\n", header
);
5311 ok(expected
->cCTLEntry
== got
->cCTLEntry
,
5312 "%s: expected %d CTL entries, got %d\n", header
, expected
->cCTLEntry
,
5314 for (i
= 0; i
< expected
->cCTLEntry
; i
++)
5316 ok(expected
->rgCTLEntry
[i
].SubjectIdentifier
.cbData
==
5317 got
->rgCTLEntry
[i
].SubjectIdentifier
.cbData
,
5318 "%s[%d]: expected subject identifier of %d bytes, got %d\n",
5319 header
, i
, expected
->rgCTLEntry
[i
].SubjectIdentifier
.cbData
,
5320 got
->rgCTLEntry
[i
].SubjectIdentifier
.cbData
);
5321 if (expected
->rgCTLEntry
[i
].SubjectIdentifier
.cbData
)
5322 ok(!memcmp(expected
->rgCTLEntry
[i
].SubjectIdentifier
.pbData
,
5323 got
->rgCTLEntry
[i
].SubjectIdentifier
.pbData
,
5324 expected
->rgCTLEntry
[i
].SubjectIdentifier
.cbData
),
5325 "%s[%d]: unexpected subject identifier value\n",
5327 for (j
= 0; j
< expected
->rgCTLEntry
[i
].cAttribute
; j
++)
5329 ok(!strcmp(expected
->rgCTLEntry
[i
].rgAttribute
[j
].pszObjId
,
5330 got
->rgCTLEntry
[i
].rgAttribute
[j
].pszObjId
),
5331 "%s[%d][%d]: expected attribute OID %s, got %s\n", header
, i
, j
,
5332 expected
->rgCTLEntry
[i
].rgAttribute
[j
].pszObjId
,
5333 got
->rgCTLEntry
[i
].rgAttribute
[j
].pszObjId
);
5334 for (k
= 0; k
< expected
->rgCTLEntry
[i
].rgAttribute
[j
].cValue
; k
++)
5336 ok(expected
->rgCTLEntry
[i
].rgAttribute
[j
].rgValue
[k
].cbData
==
5337 got
->rgCTLEntry
[i
].rgAttribute
[j
].rgValue
[k
].cbData
,
5338 "%s[%d][%d][%d]: expected value of %d bytes, got %d\n",
5340 expected
->rgCTLEntry
[i
].rgAttribute
[j
].rgValue
[k
].cbData
,
5341 got
->rgCTLEntry
[i
].rgAttribute
[j
].rgValue
[k
].cbData
);
5342 if (expected
->rgCTLEntry
[i
].rgAttribute
[j
].rgValue
[k
].cbData
)
5344 expected
->rgCTLEntry
[i
].rgAttribute
[j
].rgValue
[k
].pbData
,
5345 got
->rgCTLEntry
[i
].rgAttribute
[j
].rgValue
[k
].pbData
,
5346 expected
->rgCTLEntry
[i
].rgAttribute
[j
].rgValue
[k
].cbData
),
5347 "%s[%d][%d][%d]: unexpected value\n",
5352 ok(expected
->cExtension
== got
->cExtension
,
5353 "%s: expected %d extensions, got %d\n", header
, expected
->cExtension
,
5355 for (i
= 0; i
< expected
->cExtension
; i
++)
5357 ok(!strcmp(expected
->rgExtension
[i
].pszObjId
,
5358 got
->rgExtension
[i
].pszObjId
), "%s[%d]: expected %s, got %s\n",
5359 header
, i
, expected
->rgExtension
[i
].pszObjId
,
5360 got
->rgExtension
[i
].pszObjId
);
5361 ok(expected
->rgExtension
[i
].fCritical
== got
->rgExtension
[i
].fCritical
,
5362 "%s[%d]: expected fCritical = %d, got %d\n", header
, i
,
5363 expected
->rgExtension
[i
].fCritical
, got
->rgExtension
[i
].fCritical
);
5364 ok(expected
->rgExtension
[i
].Value
.cbData
==
5365 got
->rgExtension
[i
].Value
.cbData
,
5366 "%s[%d]: expected extension value to have %d bytes, got %d\n",
5367 header
, i
, expected
->rgExtension
[i
].Value
.cbData
,
5368 got
->rgExtension
[i
].Value
.cbData
);
5369 if (expected
->rgExtension
[i
].Value
.cbData
)
5370 ok(!memcmp(expected
->rgExtension
[i
].Value
.pbData
,
5371 got
->rgExtension
[i
].Value
.pbData
,
5372 expected
->rgExtension
[i
].Value
.cbData
),
5373 "%s[%d]: unexpected extension value\n", header
, i
);
5377 static const BYTE signedCTL
[] = {
5378 0x30,0x81,0xc7,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
5379 0x81,0xb9,0x30,0x81,0xb6,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
5380 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x28,0x06,0x09,0x2a,0x86,
5381 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x1b,0x04,0x19,0x30,0x17,0x30,0x00,
5382 0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,
5383 0x30,0x5a,0x30,0x02,0x06,0x00,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,
5384 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,
5385 0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,
5386 0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,
5387 0x00,0x04,0x40,0xca,0xd8,0x32,0xd1,0xbd,0x97,0x61,0x54,0xd6,0x80,0xcf,0x0d,
5388 0xbd,0xa2,0x42,0xc7,0xca,0x37,0x91,0x7d,0x9d,0xac,0x8c,0xdf,0x05,0x8a,0x39,
5389 0xc6,0x07,0xc1,0x37,0xe6,0xb9,0xd1,0x0d,0x26,0xec,0xa5,0xb0,0x8a,0x51,0x26,
5390 0x2b,0x4f,0x73,0x44,0x86,0x83,0x5e,0x2b,0x6e,0xcc,0xf8,0x1b,0x85,0x53,0xe9,
5391 0x7a,0x80,0x8f,0x6b,0x42,0x19,0x93 };
5392 static const BYTE signedCTLWithCTLInnerContent
[] = {
5393 0x30,0x82,0x01,0x0f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
5394 0xa0,0x82,0x01,0x00,0x30,0x81,0xfd,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,
5395 0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x30,0x06,0x09,
5396 0x2b,0x06,0x01,0x04,0x01,0x82,0x37,0x0a,0x01,0xa0,0x23,0x30,0x21,0x30,0x00,
5397 0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,
5398 0x30,0x5a,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,
5399 0x00,0x31,0x81,0xb5,0x30,0x81,0xb2,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,
5400 0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,
5401 0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
5402 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0xa0,0x3b,0x30,0x18,0x06,0x09,0x2a,0x86,
5403 0x48,0x86,0xf7,0x0d,0x01,0x09,0x03,0x31,0x0b,0x06,0x09,0x2b,0x06,0x01,0x04,
5404 0x01,0x82,0x37,0x0a,0x01,0x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,
5405 0x01,0x09,0x04,0x31,0x12,0x04,0x10,0x54,0x71,0xbc,0xe1,0x56,0x31,0xa2,0xf9,
5406 0x65,0x70,0x34,0xf8,0xe2,0xe9,0xb4,0xf4,0x30,0x04,0x06,0x00,0x05,0x00,0x04,
5407 0x40,0x2f,0x1b,0x9f,0x5a,0x4a,0x15,0x73,0xfa,0xb1,0x93,0x3d,0x09,0x52,0xdf,
5408 0x6b,0x98,0x4b,0x13,0x5e,0xe7,0xbf,0x65,0xf4,0x9c,0xc2,0xb1,0x77,0x09,0xb1,
5409 0x66,0x4d,0x72,0x0d,0xb1,0x1a,0x50,0x20,0xe0,0x57,0xa2,0x39,0xc7,0xcd,0x7f,
5410 0x8e,0xe7,0x5f,0x76,0x2b,0xd1,0x6a,0x82,0xb3,0x30,0x25,0x61,0xf6,0x25,0x23,
5411 0x57,0x6c,0x0b,0x47,0xb8 };
5413 static void test_decodeCTL(DWORD dwEncoding
)
5415 static char oid1
[] = "1.2.3";
5416 static char oid2
[] = "1.5.6";
5417 static BYTE nullData
[] = { 5,0 };
5423 SYSTEMTIME thisUpdate
= { 2005, 6, 1, 6, 16, 10, 0, 0 };
5424 CTL_ENTRY ctlEntry
[2];
5425 CRYPT_ATTRIBUTE attr1
, attr2
;
5426 CRYPT_ATTR_BLOB value1
, value2
;
5428 memset(&info
, 0, sizeof(info
));
5429 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, emptyCTL
, sizeof(emptyCTL
),
5430 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5431 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
5434 compareCTLInfo("empty CTL", &info
, (CTL_INFO
*)buf
);
5439 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, emptyCTLWithVersion1
,
5440 sizeof(emptyCTLWithVersion1
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
,
5442 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
5445 compareCTLInfo("v1 CTL", &info
, (CTL_INFO
*)buf
);
5450 info
.SubjectUsage
.cUsageIdentifier
= 1;
5451 info
.SubjectUsage
.rgpszUsageIdentifier
= &pOid1
;
5452 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, ctlWithUsageIdentifier
,
5453 sizeof(ctlWithUsageIdentifier
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
5455 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
5458 compareCTLInfo("CTL with usage identifier", &info
, (CTL_INFO
*)buf
);
5462 info
.SubjectUsage
.cUsageIdentifier
= 0;
5463 info
.ListIdentifier
.cbData
= sizeof(serialNum
);
5464 info
.ListIdentifier
.pbData
= (LPBYTE
)serialNum
;
5465 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, ctlWithListIdentifier
,
5466 sizeof(ctlWithListIdentifier
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5467 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
5470 compareCTLInfo("CTL with list identifier", &info
, (CTL_INFO
*)buf
);
5474 info
.ListIdentifier
.cbData
= 0;
5475 info
.SequenceNumber
.cbData
= sizeof(serialNum
);
5476 info
.SequenceNumber
.pbData
= (LPBYTE
)serialNum
;
5477 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, ctlWithSequenceNumber
,
5478 sizeof(ctlWithSequenceNumber
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5479 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
5482 compareCTLInfo("CTL with sequence number", &info
, (CTL_INFO
*)buf
);
5486 info
.SequenceNumber
.cbData
= 0;
5487 SystemTimeToFileTime(&thisUpdate
, &info
.ThisUpdate
);
5488 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, ctlWithThisUpdate
,
5489 sizeof(ctlWithThisUpdate
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5490 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
5493 compareCTLInfo("CTL with this update", &info
, (CTL_INFO
*)buf
);
5497 SystemTimeToFileTime(&thisUpdate
, &info
.NextUpdate
);
5498 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, ctlWithThisAndNextUpdate
,
5499 sizeof(ctlWithThisAndNextUpdate
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
5501 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
5504 compareCTLInfo("CTL with this and next update", &info
, (CTL_INFO
*)buf
);
5508 info
.ThisUpdate
.dwLowDateTime
= info
.ThisUpdate
.dwHighDateTime
= 0;
5509 info
.NextUpdate
.dwLowDateTime
= info
.NextUpdate
.dwHighDateTime
= 0;
5510 info
.SubjectAlgorithm
.pszObjId
= oid2
;
5511 info
.SubjectAlgorithm
.Parameters
.cbData
= sizeof(nullData
);
5512 info
.SubjectAlgorithm
.Parameters
.pbData
= nullData
;
5513 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, ctlWithAlgId
,
5514 sizeof(ctlWithAlgId
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5515 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
5518 compareCTLInfo("CTL with algorithm identifier", &info
, (CTL_INFO
*)buf
);
5522 SetLastError(0xdeadbeef);
5523 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, ctlWithBogusEntry
,
5524 sizeof(ctlWithBogusEntry
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5525 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_EOD
|| CRYPT_E_ASN1_CORRUPT
),
5526 "expected CRYPT_E_ASN1_EOD or CRYPT_E_ASN1_CORRUPT, got %08x\n",
5528 info
.SubjectAlgorithm
.Parameters
.cbData
= 0;
5529 info
.ThisUpdate
.dwLowDateTime
= info
.ThisUpdate
.dwHighDateTime
= 0;
5530 info
.NextUpdate
.dwLowDateTime
= info
.NextUpdate
.dwHighDateTime
= 0;
5531 info
.SubjectAlgorithm
.pszObjId
= oid2
;
5532 info
.SubjectAlgorithm
.pszObjId
= NULL
;
5533 value1
.cbData
= sizeof(emptySequence
);
5534 value1
.pbData
= (LPBYTE
)emptySequence
;
5535 attr1
.pszObjId
= oid1
;
5537 attr1
.rgValue
= &value1
;
5538 ctlEntry
[0].SubjectIdentifier
.cbData
= sizeof(serialNum
);
5539 ctlEntry
[0].SubjectIdentifier
.pbData
= (LPBYTE
)serialNum
;
5540 ctlEntry
[0].cAttribute
= 1;
5541 ctlEntry
[0].rgAttribute
= &attr1
;
5543 info
.rgCTLEntry
= ctlEntry
;
5544 SetLastError(0xdeadbeef);
5545 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, ctlWithOneEntry
,
5546 sizeof(ctlWithOneEntry
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5547 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
5550 compareCTLInfo("CTL with one entry", &info
, (CTL_INFO
*)buf
);
5554 value2
.cbData
= sizeof(encodedIPAddr
);
5555 value2
.pbData
= (LPBYTE
)encodedIPAddr
;
5556 attr2
.pszObjId
= oid2
;
5558 attr2
.rgValue
= &value2
;
5559 ctlEntry
[1].SubjectIdentifier
.cbData
= sizeof(serialNum
);
5560 ctlEntry
[1].SubjectIdentifier
.pbData
= (LPBYTE
)serialNum
;
5561 ctlEntry
[1].cAttribute
= 1;
5562 ctlEntry
[1].rgAttribute
= &attr2
;
5564 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, ctlWithTwoEntries
,
5565 sizeof(ctlWithTwoEntries
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5566 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
5569 compareCTLInfo("CTL with two entries", &info
, (CTL_INFO
*)buf
);
5573 /* A signed CTL isn't decodable, even if the inner content is a CTL */
5574 SetLastError(0xdeadbeef);
5575 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
, signedCTL
,
5576 sizeof(signedCTL
), CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5577 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_BADTAG
||
5578 GetLastError() == OSS_DATA_ERROR
/* Win9x */),
5579 "expected CRYPT_E_ASN1_BADTAG or OSS_DATA_ERROR, got %08x\n",
5581 SetLastError(0xdeadbeef);
5582 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CTL
,
5583 signedCTLWithCTLInnerContent
, sizeof(signedCTLWithCTLInnerContent
),
5584 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5585 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_BADTAG
||
5586 GetLastError() == OSS_DATA_ERROR
/* Win9x */),
5587 "expected CRYPT_E_ASN1_BADTAG or OSS_DATA_ERROR, got %08x\n",
5591 static const BYTE emptyPKCSContentInfo
[] = { 0x30,0x04,0x06,0x02,0x2a,0x03 };
5592 static const BYTE emptyPKCSContentInfoExtraBytes
[] = { 0x30,0x04,0x06,0x02,0x2a,
5594 static const BYTE bogusPKCSContentInfo
[] = { 0x30,0x07,0x06,0x02,0x2a,0x03,
5596 static const BYTE intPKCSContentInfo
[] = { 0x30,0x09,0x06,0x02,0x2a,0x03,0xa0,
5597 0x03,0x02,0x01,0x01 };
5598 static BYTE bogusDER
[] = { 1 };
5600 static void test_encodePKCSContentInfo(DWORD dwEncoding
)
5605 CRYPT_CONTENT_INFO info
= { 0 };
5606 char oid1
[] = "1.2.3";
5610 /* Crashes on win9x */
5611 SetLastError(0xdeadbeef);
5612 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CONTENT_INFO
, NULL
,
5613 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5614 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
5615 "Expected STATUS_ACCESS_VIOLATION, got %x\n", GetLastError());
5617 SetLastError(0xdeadbeef);
5618 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CONTENT_INFO
, &info
,
5619 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5620 ok(!ret
&& (GetLastError() == E_INVALIDARG
||
5621 GetLastError() == OSS_LIMITED
/* Win9x */),
5622 "Expected E_INVALIDARG or OSS_LIMITED, got %x\n", GetLastError());
5623 info
.pszObjId
= oid1
;
5624 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CONTENT_INFO
, &info
,
5625 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5626 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
5629 ok(size
== sizeof(emptyPKCSContentInfo
), "Unexpected size %d\n", size
);
5630 ok(!memcmp(buf
, emptyPKCSContentInfo
, size
), "Unexpected value\n");
5633 info
.Content
.pbData
= bogusDER
;
5634 info
.Content
.cbData
= sizeof(bogusDER
);
5635 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CONTENT_INFO
, &info
,
5636 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5637 ok(ret
, "CryptEncodeObjectEx failed; %x\n", GetLastError());
5640 ok(size
== sizeof(bogusPKCSContentInfo
), "Unexpected size %d\n", size
);
5641 ok(!memcmp(buf
, bogusPKCSContentInfo
, size
), "Unexpected value\n");
5644 info
.Content
.pbData
= (BYTE
*)ints
[0].encoded
;
5645 info
.Content
.cbData
= ints
[0].encoded
[1] + 2;
5646 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_CONTENT_INFO
, &info
,
5647 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5650 ok(size
== sizeof(intPKCSContentInfo
), "Unexpected size %d\n", size
);
5651 ok(!memcmp(buf
, intPKCSContentInfo
, size
), "Unexpected value\n");
5656 static const BYTE indefiniteSignedPKCSContent
[] = {
5657 0x30,0x80,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,0x80,
5658 0x30,0x80,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,
5659 0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x80,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,
5660 0x0d,0x01,0x07,0x01,0xa0,0x80,0x24,0x80,0x04,0x04,0x01,0x02,0x03,0x04,0x04,
5661 0x04,0x01,0x02,0x03,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0xa0,0x81,0xd2,0x30,
5662 0x81,0xcf,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,
5663 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
5664 0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
5665 0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
5666 0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,
5667 0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,
5668 0x00,0x30,0x5c,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,
5669 0x01,0x05,0x00,0x03,0x4b,0x00,0x30,0x48,0x02,0x41,0x00,0xe2,0x54,0x3a,0xa7,
5670 0x83,0xb1,0x27,0x14,0x3e,0x59,0xbb,0xb4,0x53,0xe6,0x1f,0xe7,0x5d,0xf1,0x21,
5671 0x68,0xad,0x85,0x53,0xdb,0x6b,0x1e,0xeb,0x65,0x97,0x03,0x86,0x60,0xde,0xf3,
5672 0x6c,0x38,0x75,0xe0,0x4c,0x61,0xbb,0xbc,0x62,0x17,0xa9,0xcd,0x79,0x3f,0x21,
5673 0x4e,0x96,0xcb,0x0e,0xdc,0x61,0x94,0x30,0x18,0x10,0x6b,0xd0,0x1c,0x10,0x79,
5674 0x02,0x03,0x01,0x00,0x01,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,0x55,0x1d,
5675 0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01,0x31,
5676 0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,
5677 0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,
5678 0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,
5679 0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0x57,0xba,0xe0,0xad,
5680 0xfe,0x36,0x8d,0xb3,0x88,0xa2,0x8d,0x84,0x82,0x52,0x09,0x09,0xd9,0xf0,0xb8,
5681 0x04,0xfa,0xb5,0x51,0x0b,0x2b,0x2e,0xd5,0x72,0x3e,0x3d,0x13,0x8a,0x51,0xc3,
5682 0x71,0x65,0x9a,0x52,0xf2,0x8f,0xb2,0x5b,0x39,0x28,0xb3,0x29,0x36,0xa5,0x8d,
5683 0xe3,0x55,0x71,0x91,0xf9,0x2a,0xd1,0xb8,0xaa,0x52,0xb8,0x22,0x3a,0xeb,0x61,
5684 0x00,0x00,0x00,0x00,0x00,0x00 };
5686 static void test_decodePKCSContentInfo(DWORD dwEncoding
)
5691 CRYPT_CONTENT_INFO
*info
;
5693 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CONTENT_INFO
,
5694 emptyPKCSContentInfo
, sizeof(emptyPKCSContentInfo
),
5695 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5696 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
5699 info
= (CRYPT_CONTENT_INFO
*)buf
;
5701 ok(!strcmp(info
->pszObjId
, "1.2.3"), "Expected 1.2.3, got %s\n",
5703 ok(info
->Content
.cbData
== 0, "Expected no data, got %d\n",
5704 info
->Content
.cbData
);
5707 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CONTENT_INFO
,
5708 emptyPKCSContentInfoExtraBytes
, sizeof(emptyPKCSContentInfoExtraBytes
),
5709 0, NULL
, NULL
, &size
);
5710 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
5711 SetLastError(0xdeadbeef);
5712 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CONTENT_INFO
,
5713 bogusPKCSContentInfo
, sizeof(bogusPKCSContentInfo
),
5714 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5715 /* Native fails with CRYPT_E_ASN1_EOD, accept also CRYPT_E_ASN1_CORRUPT as
5716 * I doubt an app depends on that.
5718 ok((!ret
&& (GetLastError() == CRYPT_E_ASN1_EOD
||
5719 GetLastError() == CRYPT_E_ASN1_CORRUPT
)) || broken(ret
),
5720 "Expected CRYPT_E_ASN1_EOD or CRYPT_E_ASN1_CORRUPT, got %x\n",
5722 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CONTENT_INFO
,
5723 intPKCSContentInfo
, sizeof(intPKCSContentInfo
),
5724 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5725 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
5728 info
= (CRYPT_CONTENT_INFO
*)buf
;
5730 ok(!strcmp(info
->pszObjId
, "1.2.3"), "Expected 1.2.3, got %s\n",
5732 ok(info
->Content
.cbData
== ints
[0].encoded
[1] + 2,
5733 "Unexpected size %d\n", info
->Content
.cbData
);
5734 ok(!memcmp(info
->Content
.pbData
, ints
[0].encoded
,
5735 info
->Content
.cbData
), "Unexpected value\n");
5738 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_CONTENT_INFO
,
5739 indefiniteSignedPKCSContent
, sizeof(indefiniteSignedPKCSContent
),
5740 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5741 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
5744 info
= (CRYPT_CONTENT_INFO
*)buf
;
5746 ok(!strcmp(info
->pszObjId
, szOID_RSA_signedData
),
5747 "Expected %s, got %s\n", szOID_RSA_signedData
, info
->pszObjId
);
5748 ok(info
->Content
.cbData
== 392, "Expected 392, got %d\n",
5749 info
->Content
.cbData
);
5754 static const BYTE emptyPKCSAttr
[] = { 0x30,0x06,0x06,0x02,0x2a,0x03,0x31,
5756 static const BYTE bogusPKCSAttr
[] = { 0x30,0x07,0x06,0x02,0x2a,0x03,0x31,0x01,
5758 static const BYTE intPKCSAttr
[] = { 0x30,0x09,0x06,0x02,0x2a,0x03,0x31,0x03,
5761 static void test_encodePKCSAttribute(DWORD dwEncoding
)
5763 CRYPT_ATTRIBUTE attr
= { 0 };
5767 CRYPT_ATTR_BLOB blob
;
5768 char oid
[] = "1.2.3";
5772 /* Crashes on win9x */
5773 SetLastError(0xdeadbeef);
5774 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_ATTRIBUTE
, NULL
,
5775 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5776 ok(!ret
&& GetLastError() == STATUS_ACCESS_VIOLATION
,
5777 "Expected STATUS_ACCESS_VIOLATION, got %x\n", GetLastError());
5779 SetLastError(0xdeadbeef);
5780 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_ATTRIBUTE
, &attr
,
5781 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5782 ok(!ret
&& (GetLastError() == E_INVALIDARG
||
5783 GetLastError() == OSS_LIMITED
/* Win9x */),
5784 "Expected E_INVALIDARG or OSS_LIMITED, got %x\n", GetLastError());
5785 attr
.pszObjId
= oid
;
5786 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_ATTRIBUTE
, &attr
,
5787 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5788 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
5791 ok(size
== sizeof(emptyPKCSAttr
), "Unexpected size %d\n", size
);
5792 ok(!memcmp(buf
, emptyPKCSAttr
, size
), "Unexpected value\n");
5795 blob
.cbData
= sizeof(bogusDER
);
5796 blob
.pbData
= bogusDER
;
5798 attr
.rgValue
= &blob
;
5799 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_ATTRIBUTE
, &attr
,
5800 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5801 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
5804 ok(size
== sizeof(bogusPKCSAttr
), "Unexpected size %d\n", size
);
5805 ok(!memcmp(buf
, bogusPKCSAttr
, size
), "Unexpected value\n");
5808 blob
.pbData
= (BYTE
*)ints
[0].encoded
;
5809 blob
.cbData
= ints
[0].encoded
[1] + 2;
5810 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_ATTRIBUTE
, &attr
,
5811 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5814 ok(size
== sizeof(intPKCSAttr
), "Unexpected size %d\n", size
);
5815 ok(!memcmp(buf
, intPKCSAttr
, size
), "Unexpected value\n");
5820 static void test_decodePKCSAttribute(DWORD dwEncoding
)
5825 CRYPT_ATTRIBUTE
*attr
;
5827 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_ATTRIBUTE
,
5828 emptyPKCSAttr
, sizeof(emptyPKCSAttr
),
5829 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5830 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
5833 attr
= (CRYPT_ATTRIBUTE
*)buf
;
5835 ok(!strcmp(attr
->pszObjId
, "1.2.3"), "Expected 1.2.3, got %s\n",
5837 ok(attr
->cValue
== 0, "Expected no value, got %d\n", attr
->cValue
);
5840 SetLastError(0xdeadbeef);
5841 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_ATTRIBUTE
,
5842 bogusPKCSAttr
, sizeof(bogusPKCSAttr
),
5843 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5844 /* Native fails with CRYPT_E_ASN1_EOD, accept also CRYPT_E_ASN1_CORRUPT as
5845 * I doubt an app depends on that.
5847 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_EOD
||
5848 GetLastError() == CRYPT_E_ASN1_CORRUPT
|| OSS_MORE_INPUT
/* Win9x */),
5849 "Expected CRYPT_E_ASN1_EOD, CRYPT_E_ASN1_CORRUPT, or OSS_MORE_INPUT, got %x\n",
5851 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_ATTRIBUTE
,
5852 intPKCSAttr
, sizeof(intPKCSAttr
),
5853 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5854 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
5857 attr
= (CRYPT_ATTRIBUTE
*)buf
;
5859 ok(!strcmp(attr
->pszObjId
, "1.2.3"), "Expected 1.2.3, got %s\n",
5861 ok(attr
->cValue
== 1, "Expected 1 value, got %d\n", attr
->cValue
);
5862 ok(attr
->rgValue
[0].cbData
== ints
[0].encoded
[1] + 2,
5863 "Unexpected size %d\n", attr
->rgValue
[0].cbData
);
5864 ok(!memcmp(attr
->rgValue
[0].pbData
, ints
[0].encoded
,
5865 attr
->rgValue
[0].cbData
), "Unexpected value\n");
5870 static const BYTE emptyPKCSAttributes
[] = { 0x31,0x00 };
5871 static const BYTE singlePKCSAttributes
[] = { 0x31,0x08,0x30,0x06,0x06,0x02,
5872 0x2a,0x03,0x31,0x00 };
5873 static const BYTE doublePKCSAttributes
[] = { 0x31,0x13,0x30,0x06,0x06,0x02,
5874 0x2a,0x03,0x31,0x00,0x30,0x09,0x06,0x02,0x2d,0x06,0x31,0x03,0x02,0x01,0x01 };
5876 static void test_encodePKCSAttributes(DWORD dwEncoding
)
5878 CRYPT_ATTRIBUTES attributes
= { 0 };
5879 CRYPT_ATTRIBUTE attr
[2] = { { 0 } };
5880 CRYPT_ATTR_BLOB blob
;
5884 char oid1
[] = "1.2.3", oid2
[] = "1.5.6";
5886 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_ATTRIBUTES
, &attributes
,
5887 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5888 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
5891 ok(size
== sizeof(emptyPKCSAttributes
), "Unexpected size %d\n", size
);
5892 ok(!memcmp(buf
, emptyPKCSAttributes
, size
), "Unexpected value\n");
5895 attributes
.cAttr
= 1;
5896 attributes
.rgAttr
= attr
;
5897 SetLastError(0xdeadbeef);
5898 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_ATTRIBUTES
, &attributes
,
5899 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5900 ok(!ret
&& (GetLastError() == E_INVALIDARG
||
5901 GetLastError() == OSS_LIMITED
/* Win9x */),
5902 "Expected E_INVALIDARG or OSS_LIMITED, got %08x\n", GetLastError());
5903 attr
[0].pszObjId
= oid1
;
5904 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_ATTRIBUTES
, &attributes
,
5905 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5908 ok(size
== sizeof(singlePKCSAttributes
), "Unexpected size %d\n", size
);
5909 ok(!memcmp(buf
, singlePKCSAttributes
, size
), "Unexpected value\n");
5912 attr
[1].pszObjId
= oid2
;
5914 attr
[1].rgValue
= &blob
;
5915 blob
.pbData
= (BYTE
*)ints
[0].encoded
;
5916 blob
.cbData
= ints
[0].encoded
[1] + 2;
5917 attributes
.cAttr
= 2;
5918 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_ATTRIBUTES
, &attributes
,
5919 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5920 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
5923 ok(size
== sizeof(doublePKCSAttributes
), "Unexpected size %d\n", size
);
5924 ok(!memcmp(buf
, doublePKCSAttributes
, size
), "Unexpected value\n");
5929 static void test_decodePKCSAttributes(DWORD dwEncoding
)
5934 CRYPT_ATTRIBUTES
*attributes
;
5936 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_ATTRIBUTES
,
5937 emptyPKCSAttributes
, sizeof(emptyPKCSAttributes
),
5938 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5939 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
5942 attributes
= (CRYPT_ATTRIBUTES
*)buf
;
5943 ok(attributes
->cAttr
== 0, "Expected no attributes, got %d\n",
5947 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_ATTRIBUTES
,
5948 singlePKCSAttributes
, sizeof(singlePKCSAttributes
),
5949 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5950 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
5953 attributes
= (CRYPT_ATTRIBUTES
*)buf
;
5954 ok(attributes
->cAttr
== 1, "Expected 1 attribute, got %d\n",
5956 ok(!strcmp(attributes
->rgAttr
[0].pszObjId
, "1.2.3"),
5957 "Expected 1.2.3, got %s\n", attributes
->rgAttr
[0].pszObjId
);
5958 ok(attributes
->rgAttr
[0].cValue
== 0,
5959 "Expected no attributes, got %d\n", attributes
->rgAttr
[0].cValue
);
5962 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_ATTRIBUTES
,
5963 doublePKCSAttributes
, sizeof(doublePKCSAttributes
),
5964 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
5965 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
5968 attributes
= (CRYPT_ATTRIBUTES
*)buf
;
5969 ok(attributes
->cAttr
== 2, "Expected 2 attributes, got %d\n",
5971 ok(!strcmp(attributes
->rgAttr
[0].pszObjId
, "1.2.3"),
5972 "Expected 1.2.3, got %s\n", attributes
->rgAttr
[0].pszObjId
);
5973 ok(attributes
->rgAttr
[0].cValue
== 0,
5974 "Expected no attributes, got %d\n", attributes
->rgAttr
[0].cValue
);
5975 ok(!strcmp(attributes
->rgAttr
[1].pszObjId
, "1.5.6"),
5976 "Expected 1.5.6, got %s\n", attributes
->rgAttr
[1].pszObjId
);
5977 ok(attributes
->rgAttr
[1].cValue
== 1,
5978 "Expected 1 attribute, got %d\n", attributes
->rgAttr
[1].cValue
);
5979 ok(attributes
->rgAttr
[1].rgValue
[0].cbData
== ints
[0].encoded
[1] + 2,
5980 "Unexpected size %d\n", attributes
->rgAttr
[1].rgValue
[0].cbData
);
5981 ok(!memcmp(attributes
->rgAttr
[1].rgValue
[0].pbData
, ints
[0].encoded
,
5982 attributes
->rgAttr
[1].rgValue
[0].cbData
), "Unexpected value\n");
5987 static const BYTE singleCapability
[] = {
5988 0x30,0x06,0x30,0x04,0x06,0x02,0x2d,0x06 };
5989 static const BYTE twoCapabilities
[] = {
5990 0x30,0x0c,0x30,0x04,0x06,0x02,0x2d,0x06,0x30,0x04,0x06,0x02,0x2a,0x03 };
5991 static const BYTE singleCapabilitywithNULL
[] = {
5992 0x30,0x08,0x30,0x06,0x06,0x02,0x2d,0x06,0x05,0x00 };
5994 static void test_encodePKCSSMimeCapabilities(DWORD dwEncoding
)
5996 static char oid1
[] = "1.5.6", oid2
[] = "1.2.3";
6000 CRYPT_SMIME_CAPABILITY capability
[2];
6001 CRYPT_SMIME_CAPABILITIES capabilities
;
6003 /* An empty capabilities is allowed */
6004 capabilities
.cCapability
= 0;
6005 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_SMIME_CAPABILITIES
,
6006 &capabilities
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6007 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
6010 ok(size
== sizeof(emptySequence
), "unexpected size %d\n", size
);
6011 ok(!memcmp(buf
, emptySequence
, size
), "unexpected value\n");
6014 /* A non-empty capabilities with an empty capability (lacking an OID) is
6017 capability
[0].pszObjId
= NULL
;
6018 capability
[0].Parameters
.cbData
= 0;
6019 capabilities
.cCapability
= 1;
6020 capabilities
.rgCapability
= capability
;
6021 SetLastError(0xdeadbeef);
6022 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_SMIME_CAPABILITIES
,
6023 &capabilities
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6024 ok(!ret
&& (GetLastError() == E_INVALIDARG
||
6025 GetLastError() == OSS_LIMITED
/* Win9x */),
6026 "Expected E_INVALIDARG or OSS_LIMITED, got %08x\n", GetLastError());
6027 capability
[0].pszObjId
= oid1
;
6028 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_SMIME_CAPABILITIES
,
6029 &capabilities
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6030 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
6033 ok(size
== sizeof(singleCapability
), "unexpected size %d\n", size
);
6034 ok(!memcmp(buf
, singleCapability
, size
), "unexpected value\n");
6037 capability
[1].pszObjId
= oid2
;
6038 capability
[1].Parameters
.cbData
= 0;
6039 capabilities
.cCapability
= 2;
6040 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS_SMIME_CAPABILITIES
,
6041 &capabilities
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6042 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
6045 ok(size
== sizeof(twoCapabilities
), "unexpected size %d\n", size
);
6046 ok(!memcmp(buf
, twoCapabilities
, size
), "unexpected value\n");
6051 static void compareSMimeCapabilities(LPCSTR header
,
6052 const CRYPT_SMIME_CAPABILITIES
*expected
, const CRYPT_SMIME_CAPABILITIES
*got
)
6056 ok(got
->cCapability
== expected
->cCapability
,
6057 "%s: expected %d capabilities, got %d\n", header
, expected
->cCapability
,
6059 for (i
= 0; i
< expected
->cCapability
; i
++)
6061 ok(!strcmp(expected
->rgCapability
[i
].pszObjId
,
6062 got
->rgCapability
[i
].pszObjId
), "%s[%d]: expected %s, got %s\n",
6063 header
, i
, expected
->rgCapability
[i
].pszObjId
,
6064 got
->rgCapability
[i
].pszObjId
);
6065 ok(expected
->rgCapability
[i
].Parameters
.cbData
==
6066 got
->rgCapability
[i
].Parameters
.cbData
,
6067 "%s[%d]: expected %d bytes, got %d\n", header
, i
,
6068 expected
->rgCapability
[i
].Parameters
.cbData
,
6069 got
->rgCapability
[i
].Parameters
.cbData
);
6070 if (expected
->rgCapability
[i
].Parameters
.cbData
)
6071 ok(!memcmp(expected
->rgCapability
[i
].Parameters
.pbData
,
6072 got
->rgCapability
[i
].Parameters
.pbData
,
6073 expected
->rgCapability
[i
].Parameters
.cbData
),
6074 "%s[%d]: unexpected value\n", header
, i
);
6078 static void test_decodePKCSSMimeCapabilities(DWORD dwEncoding
)
6080 static char oid1
[] = "1.5.6", oid2
[] = "1.2.3";
6083 CRYPT_SMIME_CAPABILITY capability
[2];
6084 CRYPT_SMIME_CAPABILITIES capabilities
, *ptr
;
6086 SetLastError(0xdeadbeef);
6087 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_SMIME_CAPABILITIES
,
6088 emptySequence
, sizeof(emptySequence
),
6089 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &ptr
, &size
);
6090 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
6093 capabilities
.cCapability
= 0;
6094 compareSMimeCapabilities("empty capabilities", &capabilities
, ptr
);
6097 SetLastError(0xdeadbeef);
6098 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_SMIME_CAPABILITIES
,
6099 singleCapability
, sizeof(singleCapability
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
6101 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
6104 capability
[0].pszObjId
= oid1
;
6105 capability
[0].Parameters
.cbData
= 0;
6106 capabilities
.cCapability
= 1;
6107 capabilities
.rgCapability
= capability
;
6108 compareSMimeCapabilities("single capability", &capabilities
, ptr
);
6111 SetLastError(0xdeadbeef);
6112 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_SMIME_CAPABILITIES
,
6113 singleCapabilitywithNULL
, sizeof(singleCapabilitywithNULL
),
6114 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &ptr
, &size
);
6115 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
6118 BYTE NULLparam
[] = {0x05, 0x00};
6119 capability
[0].pszObjId
= oid1
;
6120 capability
[0].Parameters
.cbData
= 2;
6121 capability
[0].Parameters
.pbData
= NULLparam
;
6122 capabilities
.cCapability
= 1;
6123 capabilities
.rgCapability
= capability
;
6124 compareSMimeCapabilities("single capability with NULL", &capabilities
,
6128 SetLastError(0xdeadbeef);
6129 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS_SMIME_CAPABILITIES
,
6130 twoCapabilities
, sizeof(twoCapabilities
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
6132 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
6135 capability
[0].Parameters
.cbData
= 0;
6136 capability
[1].pszObjId
= oid2
;
6137 capability
[1].Parameters
.cbData
= 0;
6138 capabilities
.cCapability
= 2;
6139 compareSMimeCapabilities("two capabilities", &capabilities
, ptr
);
6144 static BYTE encodedCommonNameNoNull
[] = { 0x30,0x14,0x31,0x12,0x30,0x10,
6145 0x06,0x03,0x55,0x04,0x03,0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
6147 static const BYTE minimalPKCSSigner
[] = {
6148 0x30,0x2b,0x02,0x01,0x00,0x30,0x18,0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,
6149 0x55,0x04,0x03,0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x02,
6150 0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
6151 static const BYTE PKCSSignerWithSerial
[] = {
6152 0x30,0x2c,0x02,0x01,0x00,0x30,0x19,0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,
6153 0x55,0x04,0x03,0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x02,
6154 0x01,0x01,0x30,0x04,0x06,0x00,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,
6156 static const BYTE PKCSSignerWithHashAlgo
[] = {
6157 0x30,0x2e,0x02,0x01,0x00,0x30,0x19,0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,
6158 0x55,0x04,0x03,0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x02,
6159 0x01,0x01,0x30,0x06,0x06,0x02,0x2a,0x03,0x05,0x00,0x30,0x04,0x06,0x00,0x05,
6161 static const BYTE PKCSSignerWithHashAndEncryptionAlgo
[] = {
6162 0x30,0x30,0x02,0x01,0x00,0x30,0x19,0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,
6163 0x55,0x04,0x03,0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x02,
6164 0x01,0x01,0x30,0x06,0x06,0x02,0x2a,0x03,0x05,0x00,0x30,0x06,0x06,0x02,0x2d,
6165 0x06,0x05,0x00,0x04,0x00 };
6166 static const BYTE PKCSSignerWithHash
[] = {
6167 0x30,0x40,0x02,0x01,0x00,0x30,0x19,0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,
6168 0x55,0x04,0x03,0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x02,
6169 0x01,0x01,0x30,0x06,0x06,0x02,0x2a,0x03,0x05,0x00,0x30,0x06,0x06,0x02,0x2d,
6170 0x06,0x05,0x00,0x04,0x10,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,
6171 0x0a,0x0b,0x0c,0x0d,0x0e,0x0f };
6172 static const BYTE PKCSSignerWithAuthAttr
[] = {
6173 0x30,0x62,0x02,0x01,0x00,0x30,0x19,0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,
6174 0x55,0x04,0x03,0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x02,
6175 0x01,0x01,0x30,0x06,0x06,0x02,0x2a,0x03,0x05,0x00,0xa0,0x20,0x30,0x1e,0x06,
6176 0x03,0x55,0x04,0x03,0x31,0x17,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,
6177 0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,
6178 0x06,0x06,0x02,0x2d,0x06,0x05,0x00,0x04,0x10,0x00,0x01,0x02,0x03,0x04,0x05,
6179 0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f };
6181 static void test_encodePKCSSignerInfo(DWORD dwEncoding
)
6183 static char oid1
[] = "1.2.3", oid2
[] = "1.5.6";
6187 CMSG_SIGNER_INFO info
= { 0 };
6188 char oid_common_name
[] = szOID_COMMON_NAME
;
6189 CRYPT_ATTR_BLOB commonName
= { sizeof(encodedCommonName
),
6190 (LPBYTE
)encodedCommonName
};
6191 CRYPT_ATTRIBUTE attr
= { oid_common_name
, 1, &commonName
};
6193 SetLastError(0xdeadbeef);
6194 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
, &info
,
6195 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6196 if (!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
)
6198 skip("no PKCS7_SIGNER_INFO encode support\n");
6201 ok(!ret
&& (GetLastError() == E_INVALIDARG
||
6202 GetLastError() == OSS_LIMITED
/* Win9x */),
6203 "Expected E_INVALIDARG or OSS_LIMITED, got %08x\n", GetLastError());
6204 /* To be encoded, a signer must have an issuer at least, and the encoding
6205 * must include PKCS_7_ASN_ENCODING. (That isn't enough to be decoded,
6206 * see decoding tests.)
6208 info
.Issuer
.cbData
= sizeof(encodedCommonNameNoNull
);
6209 info
.Issuer
.pbData
= encodedCommonNameNoNull
;
6210 SetLastError(0xdeadbeef);
6211 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
, &info
,
6212 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6213 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6214 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6215 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6218 ok(ret
|| broken(GetLastError() == OSS_LIMITED
/* Win9x */),
6219 "CryptEncodeObjectEx failed: %x\n", GetLastError());
6222 ok(size
== sizeof(minimalPKCSSigner
), "Unexpected size %d\n", size
);
6223 if (size
== sizeof(minimalPKCSSigner
))
6224 ok(!memcmp(buf
, minimalPKCSSigner
, size
), "Unexpected value\n");
6226 ok(0, "Unexpected value\n");
6230 info
.SerialNumber
.cbData
= sizeof(serialNum
);
6231 info
.SerialNumber
.pbData
= (BYTE
*)serialNum
;
6232 SetLastError(0xdeadbeef);
6233 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
, &info
,
6234 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6235 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6236 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6237 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6240 ok(ret
|| broken(GetLastError() == OSS_LIMITED
/* Win9x */),
6241 "CryptEncodeObjectEx failed: %x\n", GetLastError());
6244 ok(size
== sizeof(PKCSSignerWithSerial
), "Unexpected size %d\n",
6246 if (size
== sizeof(PKCSSignerWithSerial
))
6247 ok(!memcmp(buf
, PKCSSignerWithSerial
, size
),
6248 "Unexpected value\n");
6250 ok(0, "Unexpected value\n");
6254 info
.HashAlgorithm
.pszObjId
= oid1
;
6255 SetLastError(0xdeadbeef);
6256 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
, &info
,
6257 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6258 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6259 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6260 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6263 ok(ret
|| broken(GetLastError() == OSS_LIMITED
/* Win9x */),
6264 "CryptEncodeObjectEx failed: %x\n", GetLastError());
6267 ok(size
== sizeof(PKCSSignerWithHashAlgo
), "Unexpected size %d\n",
6269 if (size
== sizeof(PKCSSignerWithHashAlgo
))
6270 ok(!memcmp(buf
, PKCSSignerWithHashAlgo
, size
),
6271 "Unexpected value\n");
6273 ok(0, "Unexpected value\n");
6277 info
.HashEncryptionAlgorithm
.pszObjId
= oid2
;
6278 SetLastError(0xdeadbeef);
6279 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
, &info
,
6280 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6281 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6282 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6283 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6286 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
6289 ok(size
== sizeof(PKCSSignerWithHashAndEncryptionAlgo
),
6290 "Unexpected size %d\n", size
);
6291 if (size
== sizeof(PKCSSignerWithHashAndEncryptionAlgo
))
6292 ok(!memcmp(buf
, PKCSSignerWithHashAndEncryptionAlgo
, size
),
6293 "Unexpected value\n");
6295 ok(0, "Unexpected value\n");
6299 info
.EncryptedHash
.cbData
= sizeof(hash
);
6300 info
.EncryptedHash
.pbData
= (BYTE
*)hash
;
6301 SetLastError(0xdeadbeef);
6302 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
, &info
,
6303 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6304 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6305 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6306 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6309 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
6312 ok(size
== sizeof(PKCSSignerWithHash
), "Unexpected size %d\n",
6314 if (size
== sizeof(PKCSSignerWithHash
))
6315 ok(!memcmp(buf
, PKCSSignerWithHash
, size
),
6316 "Unexpected value\n");
6318 ok(0, "Unexpected value\n");
6322 info
.AuthAttrs
.cAttr
= 1;
6323 info
.AuthAttrs
.rgAttr
= &attr
;
6324 SetLastError(0xdeadbeef);
6325 ret
= pCryptEncodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
, &info
,
6326 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6327 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6328 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6329 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6332 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
6335 ok(size
== sizeof(PKCSSignerWithAuthAttr
), "Unexpected size %d\n",
6337 if (size
== sizeof(PKCSSignerWithAuthAttr
))
6338 ok(!memcmp(buf
, PKCSSignerWithAuthAttr
, size
),
6339 "Unexpected value\n");
6341 ok(0, "Unexpected value\n");
6347 static void test_decodePKCSSignerInfo(DWORD dwEncoding
)
6352 CMSG_SIGNER_INFO
*info
;
6354 /* A PKCS signer can't be decoded without a serial number. */
6355 SetLastError(0xdeadbeef);
6356 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
,
6357 minimalPKCSSigner
, sizeof(minimalPKCSSigner
),
6358 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6359 ok(!ret
&& (GetLastError() == CRYPT_E_ASN1_CORRUPT
||
6360 GetLastError() == OSS_DATA_ERROR
/* Win9x */),
6361 "Expected CRYPT_E_ASN1_CORRUPT or OSS_DATA_ERROR, got %x\n",
6363 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
,
6364 PKCSSignerWithSerial
, sizeof(PKCSSignerWithSerial
),
6365 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6366 ok(ret
|| broken(GetLastError() == OSS_DATA_ERROR
),
6367 "CryptDecodeObjectEx failed: %x\n", GetLastError());
6370 info
= (CMSG_SIGNER_INFO
*)buf
;
6371 ok(info
->dwVersion
== 0, "Expected version 0, got %d\n",
6373 ok(info
->Issuer
.cbData
== sizeof(encodedCommonNameNoNull
),
6374 "Unexpected size %d\n", info
->Issuer
.cbData
);
6375 ok(!memcmp(info
->Issuer
.pbData
, encodedCommonNameNoNull
,
6376 info
->Issuer
.cbData
), "Unexpected value\n");
6377 ok(info
->SerialNumber
.cbData
== sizeof(serialNum
),
6378 "Unexpected size %d\n", info
->SerialNumber
.cbData
);
6379 ok(!memcmp(info
->SerialNumber
.pbData
, serialNum
, sizeof(serialNum
)),
6380 "Unexpected value\n");
6383 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
,
6384 PKCSSignerWithHashAlgo
, sizeof(PKCSSignerWithHashAlgo
),
6385 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6388 info
= (CMSG_SIGNER_INFO
*)buf
;
6389 ok(info
->dwVersion
== 0, "Expected version 0, got %d\n",
6391 ok(info
->Issuer
.cbData
== sizeof(encodedCommonNameNoNull
),
6392 "Unexpected size %d\n", info
->Issuer
.cbData
);
6393 ok(!memcmp(info
->Issuer
.pbData
, encodedCommonNameNoNull
,
6394 info
->Issuer
.cbData
), "Unexpected value\n");
6395 ok(info
->SerialNumber
.cbData
== sizeof(serialNum
),
6396 "Unexpected size %d\n", info
->SerialNumber
.cbData
);
6397 ok(!memcmp(info
->SerialNumber
.pbData
, serialNum
, sizeof(serialNum
)),
6398 "Unexpected value\n");
6399 ok(!strcmp(info
->HashAlgorithm
.pszObjId
, "1.2.3"),
6400 "Expected 1.2.3, got %s\n", info
->HashAlgorithm
.pszObjId
);
6403 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
,
6404 PKCSSignerWithHashAndEncryptionAlgo
,
6405 sizeof(PKCSSignerWithHashAndEncryptionAlgo
), CRYPT_DECODE_ALLOC_FLAG
,
6409 info
= (CMSG_SIGNER_INFO
*)buf
;
6410 ok(info
->dwVersion
== 0, "Expected version 0, got %d\n",
6412 ok(info
->Issuer
.cbData
== sizeof(encodedCommonNameNoNull
),
6413 "Unexpected size %d\n", info
->Issuer
.cbData
);
6414 ok(!memcmp(info
->Issuer
.pbData
, encodedCommonNameNoNull
,
6415 info
->Issuer
.cbData
), "Unexpected value\n");
6416 ok(info
->SerialNumber
.cbData
== sizeof(serialNum
),
6417 "Unexpected size %d\n", info
->SerialNumber
.cbData
);
6418 ok(!memcmp(info
->SerialNumber
.pbData
, serialNum
, sizeof(serialNum
)),
6419 "Unexpected value\n");
6420 ok(!strcmp(info
->HashAlgorithm
.pszObjId
, "1.2.3"),
6421 "Expected 1.2.3, got %s\n", info
->HashAlgorithm
.pszObjId
);
6422 ok(!strcmp(info
->HashEncryptionAlgorithm
.pszObjId
, "1.5.6"),
6423 "Expected 1.5.6, got %s\n", info
->HashEncryptionAlgorithm
.pszObjId
);
6426 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
,
6427 PKCSSignerWithHash
, sizeof(PKCSSignerWithHash
),
6428 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6431 info
= (CMSG_SIGNER_INFO
*)buf
;
6432 ok(info
->dwVersion
== 0, "Expected version 0, got %d\n",
6434 ok(info
->Issuer
.cbData
== sizeof(encodedCommonNameNoNull
),
6435 "Unexpected size %d\n", info
->Issuer
.cbData
);
6436 ok(!memcmp(info
->Issuer
.pbData
, encodedCommonNameNoNull
,
6437 info
->Issuer
.cbData
), "Unexpected value\n");
6438 ok(info
->SerialNumber
.cbData
== sizeof(serialNum
),
6439 "Unexpected size %d\n", info
->SerialNumber
.cbData
);
6440 ok(!memcmp(info
->SerialNumber
.pbData
, serialNum
, sizeof(serialNum
)),
6441 "Unexpected value\n");
6442 ok(!strcmp(info
->HashAlgorithm
.pszObjId
, "1.2.3"),
6443 "Expected 1.2.3, got %s\n", info
->HashAlgorithm
.pszObjId
);
6444 ok(!strcmp(info
->HashEncryptionAlgorithm
.pszObjId
, "1.5.6"),
6445 "Expected 1.5.6, got %s\n", info
->HashEncryptionAlgorithm
.pszObjId
);
6446 ok(info
->EncryptedHash
.cbData
== sizeof(hash
), "Unexpected size %d\n",
6447 info
->EncryptedHash
.cbData
);
6448 ok(!memcmp(info
->EncryptedHash
.pbData
, hash
, sizeof(hash
)),
6449 "Unexpected value\n");
6452 ret
= pCryptDecodeObjectEx(dwEncoding
, PKCS7_SIGNER_INFO
,
6453 PKCSSignerWithAuthAttr
, sizeof(PKCSSignerWithAuthAttr
),
6454 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6457 info
= (CMSG_SIGNER_INFO
*)buf
;
6458 ok(info
->AuthAttrs
.cAttr
== 1, "Expected 1 attribute, got %d\n",
6459 info
->AuthAttrs
.cAttr
);
6460 ok(!strcmp(info
->AuthAttrs
.rgAttr
[0].pszObjId
, szOID_COMMON_NAME
),
6461 "Expected %s, got %s\n", szOID_COMMON_NAME
,
6462 info
->AuthAttrs
.rgAttr
[0].pszObjId
);
6463 ok(info
->AuthAttrs
.rgAttr
[0].cValue
== 1, "Expected 1 value, got %d\n",
6464 info
->AuthAttrs
.rgAttr
[0].cValue
);
6465 ok(info
->AuthAttrs
.rgAttr
[0].rgValue
[0].cbData
==
6466 sizeof(encodedCommonName
), "Unexpected size %d\n",
6467 info
->AuthAttrs
.rgAttr
[0].rgValue
[0].cbData
);
6468 ok(!memcmp(info
->AuthAttrs
.rgAttr
[0].rgValue
[0].pbData
,
6469 encodedCommonName
, sizeof(encodedCommonName
)), "Unexpected value\n");
6474 static const BYTE CMSSignerWithKeyId
[] = {
6475 0x30,0x14,0x02,0x01,0x00,0x80,0x01,0x01,0x30,0x04,0x06,0x00,0x05,0x00,0x30,
6476 0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
6478 static void test_encodeCMSSignerInfo(DWORD dwEncoding
)
6483 CMSG_CMS_SIGNER_INFO info
= { 0 };
6484 static char oid1
[] = "1.2.3", oid2
[] = "1.5.6";
6486 SetLastError(0xdeadbeef);
6487 ret
= pCryptEncodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
, &info
,
6488 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6489 ok(!ret
, "Expected failure, got %d\n", ret
);
6490 if (!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
)
6492 skip("no CMS_SIGNER_INFO encode support\n");
6495 ok(GetLastError() == E_INVALIDARG
,
6496 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6497 info
.SignerId
.dwIdChoice
= CERT_ID_ISSUER_SERIAL_NUMBER
;
6498 SetLastError(0xdeadbeef);
6499 ret
= pCryptEncodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
, &info
,
6500 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6501 ok(!ret
, "Expected failure, got %d\n", ret
);
6502 if (!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
)
6504 skip("no CMS_SIGNER_INFO encode support\n");
6507 ok(GetLastError() == E_INVALIDARG
,
6508 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6509 /* To be encoded, a signer must have a valid cert ID, where a valid ID may
6510 * be a key id or a issuer serial number with at least the issuer set, and
6511 * the encoding must include PKCS_7_ASN_ENCODING.
6512 * (That isn't enough to be decoded, see decoding tests.)
6514 U(info
.SignerId
).IssuerSerialNumber
.Issuer
.cbData
=
6515 sizeof(encodedCommonNameNoNull
);
6516 U(info
.SignerId
).IssuerSerialNumber
.Issuer
.pbData
= encodedCommonNameNoNull
;
6517 SetLastError(0xdeadbeef);
6518 ret
= pCryptEncodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
, &info
,
6519 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6520 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6521 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6522 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6525 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
6528 ok(size
== sizeof(minimalPKCSSigner
), "Unexpected size %d\n", size
);
6529 ok(!memcmp(buf
, minimalPKCSSigner
, size
), "Unexpected value\n");
6533 U(info
.SignerId
).IssuerSerialNumber
.SerialNumber
.cbData
= sizeof(serialNum
);
6534 U(info
.SignerId
).IssuerSerialNumber
.SerialNumber
.pbData
= (BYTE
*)serialNum
;
6535 SetLastError(0xdeadbeef);
6536 ret
= pCryptEncodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
, &info
,
6537 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6538 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6539 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6540 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6543 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
6546 ok(size
== sizeof(PKCSSignerWithSerial
), "Unexpected size %d\n",
6548 ok(!memcmp(buf
, PKCSSignerWithSerial
, size
), "Unexpected value\n");
6552 info
.SignerId
.dwIdChoice
= CERT_ID_KEY_IDENTIFIER
;
6553 U(info
.SignerId
).KeyId
.cbData
= sizeof(serialNum
);
6554 U(info
.SignerId
).KeyId
.pbData
= (BYTE
*)serialNum
;
6555 SetLastError(0xdeadbeef);
6556 ret
= pCryptEncodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
, &info
,
6557 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6558 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6559 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6560 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6563 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
6566 ok(size
== sizeof(CMSSignerWithKeyId
), "Unexpected size %d\n",
6568 ok(!memcmp(buf
, CMSSignerWithKeyId
, size
), "Unexpected value\n");
6572 /* While a CERT_ID can have a hash type, that's not allowed in CMS, where
6573 * only the IssuerAndSerialNumber and SubjectKeyIdentifier types are allowed
6574 * (see RFC 3852, section 5.3.)
6576 info
.SignerId
.dwIdChoice
= CERT_ID_SHA1_HASH
;
6577 U(info
.SignerId
).HashId
.cbData
= sizeof(hash
);
6578 U(info
.SignerId
).HashId
.pbData
= (BYTE
*)hash
;
6579 SetLastError(0xdeadbeef);
6580 ret
= pCryptEncodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
, &info
,
6581 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6582 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6583 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6584 /* Now with a hash algo */
6585 info
.SignerId
.dwIdChoice
= CERT_ID_ISSUER_SERIAL_NUMBER
;
6586 U(info
.SignerId
).IssuerSerialNumber
.Issuer
.cbData
=
6587 sizeof(encodedCommonNameNoNull
);
6588 U(info
.SignerId
).IssuerSerialNumber
.Issuer
.pbData
= encodedCommonNameNoNull
;
6589 info
.HashAlgorithm
.pszObjId
= oid1
;
6590 SetLastError(0xdeadbeef);
6591 ret
= pCryptEncodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
, &info
,
6592 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6593 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6594 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6595 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6598 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
6601 ok(size
== sizeof(PKCSSignerWithHashAlgo
), "Unexpected size %d\n",
6603 ok(!memcmp(buf
, PKCSSignerWithHashAlgo
, size
),
6604 "Unexpected value\n");
6608 info
.HashEncryptionAlgorithm
.pszObjId
= oid2
;
6609 SetLastError(0xdeadbeef);
6610 ret
= pCryptEncodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
, &info
,
6611 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6612 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6613 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6614 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6617 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
6620 ok(size
== sizeof(PKCSSignerWithHashAndEncryptionAlgo
),
6621 "Unexpected size %d\n", size
);
6622 ok(!memcmp(buf
, PKCSSignerWithHashAndEncryptionAlgo
, size
),
6623 "Unexpected value\n");
6627 info
.EncryptedHash
.cbData
= sizeof(hash
);
6628 info
.EncryptedHash
.pbData
= (BYTE
*)hash
;
6629 SetLastError(0xdeadbeef);
6630 ret
= pCryptEncodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
, &info
,
6631 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6632 if (!(dwEncoding
& PKCS_7_ASN_ENCODING
))
6633 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6634 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6637 ok(ret
, "CryptEncodeObjectEx failed: %x\n", GetLastError());
6640 ok(size
== sizeof(PKCSSignerWithHash
), "Unexpected size %d\n",
6642 ok(!memcmp(buf
, PKCSSignerWithHash
, size
), "Unexpected value\n");
6648 static void test_decodeCMSSignerInfo(DWORD dwEncoding
)
6653 CMSG_CMS_SIGNER_INFO
*info
;
6654 static char oid1
[] = "1.2.3", oid2
[] = "1.5.6";
6656 /* A CMS signer can't be decoded without a serial number. */
6657 SetLastError(0xdeadbeef);
6658 ret
= pCryptDecodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
,
6659 minimalPKCSSigner
, sizeof(minimalPKCSSigner
),
6660 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6661 ok(!ret
, "expected failure\n");
6662 if (!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
)
6664 skip("no CMS_SIGNER_INFO decode support\n");
6667 ok(GetLastError() == CRYPT_E_ASN1_CORRUPT
,
6668 "Expected CRYPT_E_ASN1_CORRUPT, got %x\n", GetLastError());
6669 ret
= pCryptDecodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
,
6670 PKCSSignerWithSerial
, sizeof(PKCSSignerWithSerial
),
6671 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6672 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
6675 info
= (CMSG_CMS_SIGNER_INFO
*)buf
;
6676 ok(info
->dwVersion
== 0, "Expected version 0, got %d\n",
6678 ok(info
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
,
6679 "Expected CERT_ID_ISSUER_SERIAL_NUMBER, got %d\n",
6680 info
->SignerId
.dwIdChoice
);
6681 ok(U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
==
6682 sizeof(encodedCommonNameNoNull
), "Unexpected size %d\n",
6683 U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
);
6684 ok(!memcmp(U(info
->SignerId
).IssuerSerialNumber
.Issuer
.pbData
,
6685 encodedCommonNameNoNull
,
6686 U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
),
6687 "Unexpected value\n");
6688 ok(U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.cbData
==
6689 sizeof(serialNum
), "Unexpected size %d\n",
6690 U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.cbData
);
6691 ok(!memcmp(U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.pbData
,
6692 serialNum
, sizeof(serialNum
)), "Unexpected value\n");
6695 ret
= pCryptDecodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
,
6696 PKCSSignerWithHashAlgo
, sizeof(PKCSSignerWithHashAlgo
),
6697 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6698 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
6701 info
= (CMSG_CMS_SIGNER_INFO
*)buf
;
6702 ok(info
->dwVersion
== 0, "Expected version 0, got %d\n",
6704 ok(info
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
,
6705 "Expected CERT_ID_ISSUER_SERIAL_NUMBER, got %d\n",
6706 info
->SignerId
.dwIdChoice
);
6707 ok(U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
==
6708 sizeof(encodedCommonNameNoNull
), "Unexpected size %d\n",
6709 U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
);
6710 ok(!memcmp(U(info
->SignerId
).IssuerSerialNumber
.Issuer
.pbData
,
6711 encodedCommonNameNoNull
,
6712 U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
),
6713 "Unexpected value\n");
6714 ok(U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.cbData
==
6715 sizeof(serialNum
), "Unexpected size %d\n",
6716 U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.cbData
);
6717 ok(!memcmp(U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.pbData
,
6718 serialNum
, sizeof(serialNum
)), "Unexpected value\n");
6719 ok(!strcmp(info
->HashAlgorithm
.pszObjId
, oid1
),
6720 "Expected %s, got %s\n", oid1
, info
->HashAlgorithm
.pszObjId
);
6723 ret
= pCryptDecodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
,
6724 PKCSSignerWithHashAndEncryptionAlgo
,
6725 sizeof(PKCSSignerWithHashAndEncryptionAlgo
), CRYPT_DECODE_ALLOC_FLAG
,
6727 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
6730 info
= (CMSG_CMS_SIGNER_INFO
*)buf
;
6731 ok(info
->dwVersion
== 0, "Expected version 0, got %d\n",
6733 ok(info
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
,
6734 "Expected CERT_ID_ISSUER_SERIAL_NUMBER, got %d\n",
6735 info
->SignerId
.dwIdChoice
);
6736 ok(U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
==
6737 sizeof(encodedCommonNameNoNull
), "Unexpected size %d\n",
6738 U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
);
6739 ok(!memcmp(U(info
->SignerId
).IssuerSerialNumber
.Issuer
.pbData
,
6740 encodedCommonNameNoNull
,
6741 U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
),
6742 "Unexpected value\n");
6743 ok(U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.cbData
==
6744 sizeof(serialNum
), "Unexpected size %d\n",
6745 U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.cbData
);
6746 ok(!memcmp(U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.pbData
,
6747 serialNum
, sizeof(serialNum
)), "Unexpected value\n");
6748 ok(!strcmp(info
->HashAlgorithm
.pszObjId
, oid1
),
6749 "Expected %s, got %s\n", oid1
, info
->HashAlgorithm
.pszObjId
);
6750 ok(!strcmp(info
->HashEncryptionAlgorithm
.pszObjId
, oid2
),
6751 "Expected %s, got %s\n", oid2
, info
->HashEncryptionAlgorithm
.pszObjId
);
6754 ret
= pCryptDecodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
,
6755 PKCSSignerWithHash
, sizeof(PKCSSignerWithHash
),
6756 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6757 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
6760 info
= (CMSG_CMS_SIGNER_INFO
*)buf
;
6761 ok(info
->dwVersion
== 0, "Expected version 0, got %d\n",
6763 ok(info
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
,
6764 "Expected CERT_ID_ISSUER_SERIAL_NUMBER, got %d\n",
6765 info
->SignerId
.dwIdChoice
);
6766 ok(U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
==
6767 sizeof(encodedCommonNameNoNull
), "Unexpected size %d\n",
6768 U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
);
6769 ok(!memcmp(U(info
->SignerId
).IssuerSerialNumber
.Issuer
.pbData
,
6770 encodedCommonNameNoNull
,
6771 U(info
->SignerId
).IssuerSerialNumber
.Issuer
.cbData
),
6772 "Unexpected value\n");
6773 ok(U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.cbData
==
6774 sizeof(serialNum
), "Unexpected size %d\n",
6775 U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.cbData
);
6776 ok(!memcmp(U(info
->SignerId
).IssuerSerialNumber
.SerialNumber
.pbData
,
6777 serialNum
, sizeof(serialNum
)), "Unexpected value\n");
6778 ok(!strcmp(info
->HashAlgorithm
.pszObjId
, oid1
),
6779 "Expected %s, got %s\n", oid1
, info
->HashAlgorithm
.pszObjId
);
6780 ok(!strcmp(info
->HashEncryptionAlgorithm
.pszObjId
, oid2
),
6781 "Expected %s, got %s\n", oid2
, info
->HashEncryptionAlgorithm
.pszObjId
);
6782 ok(info
->EncryptedHash
.cbData
== sizeof(hash
), "Unexpected size %d\n",
6783 info
->EncryptedHash
.cbData
);
6784 ok(!memcmp(info
->EncryptedHash
.pbData
, hash
, sizeof(hash
)),
6785 "Unexpected value\n");
6788 ret
= pCryptDecodeObjectEx(dwEncoding
, CMS_SIGNER_INFO
,
6789 CMSSignerWithKeyId
, sizeof(CMSSignerWithKeyId
),
6790 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6791 ok(ret
, "CryptDecodeObjectEx failed: %x\n", GetLastError());
6794 info
= (CMSG_CMS_SIGNER_INFO
*)buf
;
6795 ok(info
->dwVersion
== 0, "Expected version 0, got %d\n",
6797 ok(info
->SignerId
.dwIdChoice
== CERT_ID_KEY_IDENTIFIER
,
6798 "Expected CERT_ID_KEY_IDENTIFIER, got %d\n",
6799 info
->SignerId
.dwIdChoice
);
6800 ok(U(info
->SignerId
).KeyId
.cbData
== sizeof(serialNum
),
6801 "Unexpected size %d\n", U(info
->SignerId
).KeyId
.cbData
);
6802 ok(!memcmp(U(info
->SignerId
).KeyId
.pbData
, serialNum
, sizeof(serialNum
)),
6803 "Unexpected value\n");
6808 static BYTE emptyDNSPermittedConstraints
[] = {
6809 0x30,0x06,0xa0,0x04,0x30,0x02,0x82,0x00 };
6810 static BYTE emptyDNSExcludedConstraints
[] = {
6811 0x30,0x06,0xa1,0x04,0x30,0x02,0x82,0x00 };
6812 static BYTE DNSExcludedConstraints
[] = {
6813 0x30,0x17,0xa1,0x15,0x30,0x13,0x82,0x11,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,
6814 0x77,0x69,0x6e,0x65,0x68,0x71,0x2e,0x6f,0x72,0x67 };
6815 static BYTE permittedAndExcludedConstraints
[] = {
6816 0x30,0x25,0xa0,0x0c,0x30,0x0a,0x87,0x08,0x30,0x06,0x87,0x04,0x7f,0x00,0x00,
6817 0x01,0xa1,0x15,0x30,0x13,0x82,0x11,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x77,
6818 0x69,0x6e,0x65,0x68,0x71,0x2e,0x6f,0x72,0x67 };
6819 static BYTE permittedAndExcludedWithMinConstraints
[] = {
6820 0x30,0x28,0xa0,0x0f,0x30,0x0d,0x87,0x08,0x30,0x06,0x87,0x04,0x7f,0x00,0x00,
6821 0x01,0x80,0x01,0x05,0xa1,0x15,0x30,0x13,0x82,0x11,0x68,0x74,0x74,0x70,0x3a,
6822 0x2f,0x2f,0x77,0x69,0x6e,0x65,0x68,0x71,0x2e,0x6f,0x72,0x67 };
6823 static BYTE permittedAndExcludedWithMinMaxConstraints
[] = {
6824 0x30,0x2b,0xa0,0x12,0x30,0x10,0x87,0x08,0x30,0x06,0x87,0x04,0x7f,0x00,0x00,
6825 0x01,0x80,0x01,0x05,0x81,0x01,0x03,0xa1,0x15,0x30,0x13,0x82,0x11,0x68,0x74,
6826 0x74,0x70,0x3a,0x2f,0x2f,0x77,0x69,0x6e,0x65,0x68,0x71,0x2e,0x6f,0x72,0x67 };
6828 static void test_encodeNameConstraints(DWORD dwEncoding
)
6831 CERT_NAME_CONSTRAINTS_INFO constraints
= { 0 };
6832 CERT_GENERAL_SUBTREE permitted
= { { 0 } };
6833 CERT_GENERAL_SUBTREE excluded
= { { 0 } };
6837 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME_CONSTRAINTS
, &constraints
,
6838 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6839 if (!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
)
6841 skip("no X509_NAME_CONSTRAINTS encode support\n");
6844 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
6847 ok(size
== sizeof(emptySequence
), "Unexpected size\n");
6848 ok(!memcmp(buf
, emptySequence
, size
), "Unexpected value\n");
6851 constraints
.cPermittedSubtree
= 1;
6852 constraints
.rgPermittedSubtree
= &permitted
;
6853 SetLastError(0xdeadbeef);
6854 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME_CONSTRAINTS
, &constraints
,
6855 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6856 ok(!ret
&& GetLastError() == E_INVALIDARG
,
6857 "Expected E_INVALIDARG, got %08x\n", GetLastError());
6858 permitted
.Base
.dwAltNameChoice
= CERT_ALT_NAME_DNS_NAME
;
6859 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME_CONSTRAINTS
, &constraints
,
6860 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6861 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
6864 ok(size
== sizeof(emptyDNSPermittedConstraints
), "Unexpected size\n");
6865 ok(!memcmp(buf
, emptyDNSPermittedConstraints
, size
),
6866 "Unexpected value\n");
6869 constraints
.cPermittedSubtree
= 0;
6870 constraints
.cExcludedSubtree
= 1;
6871 constraints
.rgExcludedSubtree
= &excluded
;
6872 excluded
.Base
.dwAltNameChoice
= CERT_ALT_NAME_DNS_NAME
;
6873 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME_CONSTRAINTS
, &constraints
,
6874 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6875 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
6878 ok(size
== sizeof(emptyDNSExcludedConstraints
), "Unexpected size\n");
6879 ok(!memcmp(buf
, emptyDNSExcludedConstraints
, size
),
6880 "Unexpected value\n");
6883 U(excluded
.Base
).pwszURL
= (LPWSTR
)url
;
6884 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME_CONSTRAINTS
, &constraints
,
6885 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6886 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
6889 ok(size
== sizeof(DNSExcludedConstraints
), "Unexpected size\n");
6890 ok(!memcmp(buf
, DNSExcludedConstraints
, size
),
6891 "Unexpected value\n");
6894 permitted
.Base
.dwAltNameChoice
= CERT_ALT_NAME_IP_ADDRESS
;
6895 U(permitted
.Base
).IPAddress
.cbData
= sizeof(encodedIPAddr
);
6896 U(permitted
.Base
).IPAddress
.pbData
= (LPBYTE
)encodedIPAddr
;
6897 constraints
.cPermittedSubtree
= 1;
6898 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME_CONSTRAINTS
, &constraints
,
6899 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6900 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
6903 ok(size
== sizeof(permittedAndExcludedConstraints
),
6904 "Unexpected size\n");
6905 ok(!memcmp(buf
, permittedAndExcludedConstraints
, size
),
6906 "Unexpected value\n");
6909 permitted
.dwMinimum
= 5;
6910 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME_CONSTRAINTS
, &constraints
,
6911 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6912 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
6915 ok(size
== sizeof(permittedAndExcludedWithMinConstraints
),
6916 "Unexpected size\n");
6917 ok(!memcmp(buf
, permittedAndExcludedWithMinConstraints
, size
),
6918 "Unexpected value\n");
6921 permitted
.fMaximum
= TRUE
;
6922 permitted
.dwMaximum
= 3;
6923 SetLastError(0xdeadbeef);
6924 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_NAME_CONSTRAINTS
, &constraints
,
6925 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
6926 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
6929 ok(size
== sizeof(permittedAndExcludedWithMinMaxConstraints
),
6930 "Unexpected size\n");
6931 ok(!memcmp(buf
, permittedAndExcludedWithMinMaxConstraints
, size
),
6932 "Unexpected value\n");
6937 struct EncodedNameConstraints
6939 CRYPT_DATA_BLOB encoded
;
6940 CERT_NAME_CONSTRAINTS_INFO constraints
;
6943 static CERT_GENERAL_SUBTREE emptyDNSSubtree
= {
6944 { CERT_ALT_NAME_DNS_NAME
, { 0 } }, 0 };
6945 static CERT_GENERAL_SUBTREE DNSSubtree
= {
6946 { CERT_ALT_NAME_DNS_NAME
, { 0 } }, 0 };
6947 static CERT_GENERAL_SUBTREE IPAddressSubtree
= {
6948 { CERT_ALT_NAME_IP_ADDRESS
, { 0 } }, 0 };
6949 static CERT_GENERAL_SUBTREE IPAddressWithMinSubtree
= {
6950 { CERT_ALT_NAME_IP_ADDRESS
, { 0 } }, 5, 0 };
6951 static CERT_GENERAL_SUBTREE IPAddressWithMinMaxSubtree
= {
6952 { CERT_ALT_NAME_IP_ADDRESS
, { 0 } }, 5, TRUE
, 3 };
6954 struct EncodedNameConstraints encodedNameConstraints
[] = {
6955 { { sizeof(emptySequence
), (LPBYTE
)emptySequence
}, { 0 } },
6956 { { sizeof(emptyDNSPermittedConstraints
), emptyDNSPermittedConstraints
},
6957 { 1, &emptyDNSSubtree
, 0, NULL
} },
6958 { { sizeof(emptyDNSExcludedConstraints
), emptyDNSExcludedConstraints
},
6959 { 0, NULL
, 1, &emptyDNSSubtree
} },
6960 { { sizeof(DNSExcludedConstraints
), DNSExcludedConstraints
},
6961 { 0, NULL
, 1, &DNSSubtree
} },
6962 { { sizeof(permittedAndExcludedConstraints
), permittedAndExcludedConstraints
},
6963 { 1, &IPAddressSubtree
, 1, &DNSSubtree
} },
6964 { { sizeof(permittedAndExcludedWithMinConstraints
),
6965 permittedAndExcludedWithMinConstraints
},
6966 { 1, &IPAddressWithMinSubtree
, 1, &DNSSubtree
} },
6967 { { sizeof(permittedAndExcludedWithMinMaxConstraints
),
6968 permittedAndExcludedWithMinMaxConstraints
},
6969 { 1, &IPAddressWithMinMaxSubtree
, 1, &DNSSubtree
} },
6972 static void test_decodeNameConstraints(DWORD dwEncoding
)
6976 CERT_NAME_CONSTRAINTS_INFO
*constraints
;
6978 U(DNSSubtree
.Base
).pwszURL
= (LPWSTR
)url
;
6979 U(IPAddressSubtree
.Base
).IPAddress
.cbData
= sizeof(encodedIPAddr
);
6980 U(IPAddressSubtree
.Base
).IPAddress
.pbData
= (LPBYTE
)encodedIPAddr
;
6981 U(IPAddressWithMinSubtree
.Base
).IPAddress
.cbData
= sizeof(encodedIPAddr
);
6982 U(IPAddressWithMinSubtree
.Base
).IPAddress
.pbData
= (LPBYTE
)encodedIPAddr
;
6983 U(IPAddressWithMinMaxSubtree
.Base
).IPAddress
.cbData
= sizeof(encodedIPAddr
);
6984 U(IPAddressWithMinMaxSubtree
.Base
).IPAddress
.pbData
= (LPBYTE
)encodedIPAddr
;
6986 i
< sizeof(encodedNameConstraints
) / sizeof(encodedNameConstraints
[0]);
6991 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_NAME_CONSTRAINTS
,
6992 encodedNameConstraints
[i
].encoded
.pbData
,
6993 encodedNameConstraints
[i
].encoded
.cbData
,
6994 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &constraints
, &size
);
6995 if (!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
)
6997 skip("no X509_NAME_CONSTRAINTS decode support\n");
7000 ok(ret
, "%d: CryptDecodeObjectEx failed: %08x\n", i
, GetLastError());
7005 if (constraints
->cPermittedSubtree
!=
7006 encodedNameConstraints
[i
].constraints
.cPermittedSubtree
)
7007 fprintf(stderr
, "%d: expected %d permitted, got %d\n", i
,
7008 encodedNameConstraints
[i
].constraints
.cPermittedSubtree
,
7009 constraints
->cPermittedSubtree
);
7010 if (constraints
->cPermittedSubtree
==
7011 encodedNameConstraints
[i
].constraints
.cPermittedSubtree
)
7013 for (j
= 0; j
< constraints
->cPermittedSubtree
; j
++)
7015 compareAltNameEntry(&constraints
->rgPermittedSubtree
[j
].Base
,
7016 &encodedNameConstraints
[i
].constraints
.rgPermittedSubtree
[j
].Base
);
7019 if (constraints
->cExcludedSubtree
!=
7020 encodedNameConstraints
[i
].constraints
.cExcludedSubtree
)
7021 fprintf(stderr
, "%d: expected %d excluded, got %d\n", i
,
7022 encodedNameConstraints
[i
].constraints
.cExcludedSubtree
,
7023 constraints
->cExcludedSubtree
);
7024 if (constraints
->cExcludedSubtree
==
7025 encodedNameConstraints
[i
].constraints
.cExcludedSubtree
)
7027 for (j
= 0; j
< constraints
->cExcludedSubtree
; j
++)
7029 compareAltNameEntry(&constraints
->rgExcludedSubtree
[j
].Base
,
7030 &encodedNameConstraints
[i
].constraints
.rgExcludedSubtree
[j
].Base
);
7033 LocalFree(constraints
);
7038 static WCHAR noticeText
[] = { 'T','h','i','s',' ','i','s',' ','a',' ',
7039 'n','o','t','i','c','e',0 };
7040 static const BYTE noticeWithDisplayText
[] = {
7041 0x30,0x22,0x1e,0x20,0x00,0x54,0x00,0x68,0x00,0x69,0x00,0x73,0x00,0x20,0x00,
7042 0x69,0x00,0x73,0x00,0x20,0x00,0x61,0x00,0x20,0x00,0x6e,0x00,0x6f,0x00,0x74,
7043 0x00,0x69,0x00,0x63,0x00,0x65
7045 static char org
[] = "Wine";
7046 static int noticeNumbers
[] = { 2,3 };
7047 static BYTE noticeWithReference
[] = {
7048 0x30,0x32,0x30,0x0e,0x16,0x04,0x57,0x69,0x6e,0x65,0x30,0x06,0x02,0x01,0x02,
7049 0x02,0x01,0x03,0x1e,0x20,0x00,0x54,0x00,0x68,0x00,0x69,0x00,0x73,0x00,0x20,
7050 0x00,0x69,0x00,0x73,0x00,0x20,0x00,0x61,0x00,0x20,0x00,0x6e,0x00,0x6f,0x00,
7051 0x74,0x00,0x69,0x00,0x63,0x00,0x65
7054 static void test_encodePolicyQualifierUserNotice(DWORD dwEncoding
)
7059 CERT_POLICY_QUALIFIER_USER_NOTICE notice
;
7060 CERT_POLICY_QUALIFIER_NOTICE_REFERENCE reference
;
7062 memset(¬ice
, 0, sizeof(notice
));
7063 ret
= pCryptEncodeObjectEx(dwEncoding
,
7064 X509_PKIX_POLICY_QUALIFIER_USERNOTICE
, ¬ice
, CRYPT_ENCODE_ALLOC_FLAG
,
7066 if (!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
)
7068 skip("no X509_PKIX_POLICY_QUALIFIER_USERNOTICE encode support\n");
7071 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
7074 ok(sizeof(emptySequence
) == size
, "unexpected size %d\n", size
);
7075 ok(!memcmp(buf
, emptySequence
, size
), "unexpected value\n");
7078 notice
.pszDisplayText
= noticeText
;
7079 ret
= pCryptEncodeObjectEx(dwEncoding
,
7080 X509_PKIX_POLICY_QUALIFIER_USERNOTICE
, ¬ice
, CRYPT_ENCODE_ALLOC_FLAG
,
7082 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
7085 ok(sizeof(noticeWithDisplayText
) == size
, "unexpected size %d\n", size
);
7086 ok(!memcmp(buf
, noticeWithDisplayText
, size
), "unexpected value\n");
7089 reference
.pszOrganization
= org
;
7090 reference
.cNoticeNumbers
= 2;
7091 reference
.rgNoticeNumbers
= noticeNumbers
;
7092 notice
.pNoticeReference
= &reference
;
7093 ret
= pCryptEncodeObjectEx(dwEncoding
,
7094 X509_PKIX_POLICY_QUALIFIER_USERNOTICE
, ¬ice
, CRYPT_ENCODE_ALLOC_FLAG
,
7096 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
7099 ok(sizeof(noticeWithReference
) == size
, "unexpected size %d\n", size
);
7100 ok(!memcmp(buf
, noticeWithReference
, size
), "unexpected value\n");
7105 static void test_decodePolicyQualifierUserNotice(DWORD dwEncoding
)
7108 CERT_POLICY_QUALIFIER_USER_NOTICE
*notice
;
7111 ret
= pCryptDecodeObjectEx(dwEncoding
,
7112 X509_PKIX_POLICY_QUALIFIER_USERNOTICE
,
7113 emptySequence
, sizeof(emptySequence
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
7115 if (!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
)
7117 skip("no X509_PKIX_POLICY_QUALIFIER_USERNOTICE decode support\n");
7120 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
7123 ok(notice
->pszDisplayText
== NULL
, "unexpected display text\n");
7124 ok(notice
->pNoticeReference
== NULL
, "unexpected notice reference\n");
7127 ret
= pCryptDecodeObjectEx(dwEncoding
,
7128 X509_PKIX_POLICY_QUALIFIER_USERNOTICE
,
7129 noticeWithDisplayText
, sizeof(noticeWithDisplayText
),
7130 CRYPT_DECODE_ALLOC_FLAG
, NULL
, ¬ice
, &size
);
7131 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
7134 ok(!lstrcmpW(notice
->pszDisplayText
, noticeText
),
7135 "unexpected display text\n");
7136 ok(notice
->pNoticeReference
== NULL
, "unexpected notice reference\n");
7139 ret
= pCryptDecodeObjectEx(dwEncoding
,
7140 X509_PKIX_POLICY_QUALIFIER_USERNOTICE
,
7141 noticeWithReference
, sizeof(noticeWithReference
),
7142 CRYPT_DECODE_ALLOC_FLAG
, NULL
, ¬ice
, &size
);
7143 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
7146 ok(!lstrcmpW(notice
->pszDisplayText
, noticeText
),
7147 "unexpected display text\n");
7148 ok(notice
->pNoticeReference
!= NULL
, "expected a notice reference\n");
7149 if (notice
->pNoticeReference
)
7151 ok(!strcmp(notice
->pNoticeReference
->pszOrganization
, org
),
7152 "unexpected organization %s\n",
7153 notice
->pNoticeReference
->pszOrganization
);
7154 ok(notice
->pNoticeReference
->cNoticeNumbers
== 2,
7155 "expected 2 notice numbers, got %d\n",
7156 notice
->pNoticeReference
->cNoticeNumbers
);
7157 ok(notice
->pNoticeReference
->rgNoticeNumbers
[0] == noticeNumbers
[0],
7158 "unexpected notice number %d\n",
7159 notice
->pNoticeReference
->rgNoticeNumbers
[0]);
7160 ok(notice
->pNoticeReference
->rgNoticeNumbers
[1] == noticeNumbers
[1],
7161 "unexpected notice number %d\n",
7162 notice
->pNoticeReference
->rgNoticeNumbers
[1]);
7168 static char oid_any_policy
[] = "2.5.29.32.0";
7169 static const BYTE policiesWithAnyPolicy
[] = {
7170 0x30,0x08,0x30,0x06,0x06,0x04,0x55,0x1d,0x20,0x00
7172 static char oid1
[] = "1.2.3";
7173 static char oid_user_notice
[] = "1.3.6.1.5.5.7.2.2";
7174 static const BYTE twoPolicies
[] = {
7175 0x30,0x50,0x30,0x06,0x06,0x04,0x55,0x1d,0x20,0x00,0x30,0x46,0x06,0x02,0x2a,
7176 0x03,0x30,0x40,0x30,0x3e,0x06,0x08,0x2b,0x06,0x01,0x05,0x05,0x07,0x02,0x02,
7177 0x30,0x32,0x30,0x0e,0x16,0x04,0x57,0x69,0x6e,0x65,0x30,0x06,0x02,0x01,0x02,
7178 0x02,0x01,0x03,0x1e,0x20,0x00,0x54,0x00,0x68,0x00,0x69,0x00,0x73,0x00,0x20,
7179 0x00,0x69,0x00,0x73,0x00,0x20,0x00,0x61,0x00,0x20,0x00,0x6e,0x00,0x6f,0x00,
7180 0x74,0x00,0x69,0x00,0x63,0x00,0x65
7183 static void test_encodeCertPolicies(DWORD dwEncoding
)
7186 CERT_POLICIES_INFO info
;
7187 CERT_POLICY_INFO policy
[2];
7188 CERT_POLICY_QUALIFIER_INFO qualifier
;
7192 memset(&info
, 0, sizeof(info
));
7193 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_POLICIES
, &info
,
7194 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
7195 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
7198 ok(sizeof(emptySequence
) == size
, "unexpected size %d\n", size
);
7199 ok(!memcmp(buf
, emptySequence
, size
), "unexpected value\n");
7202 memset(policy
, 0, sizeof(policy
));
7203 info
.cPolicyInfo
= 1;
7204 info
.rgPolicyInfo
= policy
;
7205 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_POLICIES
, &info
,
7206 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
7207 ok(!ret
&& (GetLastError() == E_INVALIDARG
||
7208 GetLastError() == OSS_LIMITED
/* Win9x/NT4 */),
7209 "expected E_INVALIDARG or OSS_LIMITED, got %08x\n", GetLastError());
7210 policy
[0].pszPolicyIdentifier
= oid_any_policy
;
7211 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_POLICIES
, &info
,
7212 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
7213 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
7216 ok(sizeof(policiesWithAnyPolicy
) == size
, "unexpected size %d\n", size
);
7217 ok(!memcmp(buf
, policiesWithAnyPolicy
, size
), "unexpected value\n");
7220 policy
[1].pszPolicyIdentifier
= oid1
;
7221 memset(&qualifier
, 0, sizeof(qualifier
));
7222 qualifier
.pszPolicyQualifierId
= oid_user_notice
;
7223 qualifier
.Qualifier
.cbData
= sizeof(noticeWithReference
);
7224 qualifier
.Qualifier
.pbData
= noticeWithReference
;
7225 policy
[1].cPolicyQualifier
= 1;
7226 policy
[1].rgPolicyQualifier
= &qualifier
;
7227 info
.cPolicyInfo
= 2;
7228 ret
= pCryptEncodeObjectEx(dwEncoding
, X509_CERT_POLICIES
, &info
,
7229 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &buf
, &size
);
7230 ok(ret
, "CryptEncodeObjectEx failed: %08x\n", GetLastError());
7233 ok(sizeof(twoPolicies
) == size
, "unexpected size %d\n", size
);
7234 ok(!memcmp(buf
, twoPolicies
, size
), "unexpected value\n");
7239 static void test_decodeCertPolicies(DWORD dwEncoding
)
7242 CERT_POLICIES_INFO
*info
;
7245 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_POLICIES
,
7246 emptySequence
, sizeof(emptySequence
), CRYPT_DECODE_ALLOC_FLAG
, NULL
,
7248 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
7251 ok(info
->cPolicyInfo
== 0, "unexpected policy info %d\n",
7255 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_POLICIES
,
7256 policiesWithAnyPolicy
, sizeof(policiesWithAnyPolicy
),
7257 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &info
, &size
);
7258 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
7261 ok(info
->cPolicyInfo
== 1, "unexpected policy info %d\n",
7263 ok(!strcmp(info
->rgPolicyInfo
[0].pszPolicyIdentifier
, oid_any_policy
),
7264 "unexpected policy id %s\n",
7265 info
->rgPolicyInfo
[0].pszPolicyIdentifier
);
7266 ok(info
->rgPolicyInfo
[0].cPolicyQualifier
== 0,
7267 "unexpected policy qualifier count %d\n",
7268 info
->rgPolicyInfo
[0].cPolicyQualifier
);
7271 ret
= pCryptDecodeObjectEx(dwEncoding
, X509_CERT_POLICIES
,
7272 twoPolicies
, sizeof(twoPolicies
),
7273 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &info
, &size
);
7274 ok(ret
, "CryptDecodeObjectEx failed: %08x\n", GetLastError());
7277 ok(info
->cPolicyInfo
== 2, "unexpected policy info %d\n",
7279 ok(!strcmp(info
->rgPolicyInfo
[0].pszPolicyIdentifier
, oid_any_policy
),
7280 "unexpected policy id %s\n",
7281 info
->rgPolicyInfo
[0].pszPolicyIdentifier
);
7282 ok(info
->rgPolicyInfo
[0].cPolicyQualifier
== 0,
7283 "unexpected policy qualifier count %d\n",
7284 info
->rgPolicyInfo
[0].cPolicyQualifier
);
7285 ok(!strcmp(info
->rgPolicyInfo
[1].pszPolicyIdentifier
, oid1
),
7286 "unexpected policy id %s\n",
7287 info
->rgPolicyInfo
[1].pszPolicyIdentifier
);
7288 ok(info
->rgPolicyInfo
[1].cPolicyQualifier
== 1,
7289 "unexpected policy qualifier count %d\n",
7290 info
->rgPolicyInfo
[1].cPolicyQualifier
);
7292 info
->rgPolicyInfo
[1].rgPolicyQualifier
[0].pszPolicyQualifierId
,
7293 oid_user_notice
), "unexpected policy qualifier id %s\n",
7294 info
->rgPolicyInfo
[1].rgPolicyQualifier
[0].pszPolicyQualifierId
);
7295 ok(info
->rgPolicyInfo
[1].rgPolicyQualifier
[0].Qualifier
.cbData
==
7296 sizeof(noticeWithReference
), "unexpected qualifier size %d\n",
7297 info
->rgPolicyInfo
[1].rgPolicyQualifier
[0].Qualifier
.cbData
);
7299 info
->rgPolicyInfo
[1].rgPolicyQualifier
[0].Qualifier
.pbData
,
7300 noticeWithReference
, sizeof(noticeWithReference
)),
7301 "unexpected qualifier value\n");
7306 /* Free *pInfo with HeapFree */
7307 static void testExportPublicKey(HCRYPTPROV csp
, PCERT_PUBLIC_KEY_INFO
*pInfo
)
7314 ret = CryptExportPublicKeyInfoEx(0, 0, 0, NULL, 0, NULL, NULL, NULL);
7316 ret
= CryptExportPublicKeyInfoEx(0, 0, 0, NULL
, 0, NULL
, NULL
, &size
);
7317 ok(!ret
&& GetLastError() == ERROR_INVALID_PARAMETER
,
7318 "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
7319 ret
= CryptExportPublicKeyInfoEx(0, AT_SIGNATURE
, 0, NULL
, 0, NULL
, NULL
,
7321 ok(!ret
&& GetLastError() == ERROR_INVALID_PARAMETER
,
7322 "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
7323 ret
= CryptExportPublicKeyInfoEx(0, 0, X509_ASN_ENCODING
, NULL
, 0, NULL
,
7325 ok(!ret
&& GetLastError() == ERROR_INVALID_PARAMETER
,
7326 "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
7327 ret
= CryptExportPublicKeyInfoEx(0, AT_SIGNATURE
, X509_ASN_ENCODING
, NULL
,
7328 0, NULL
, NULL
, &size
);
7329 ok(!ret
&& GetLastError() == ERROR_INVALID_PARAMETER
,
7330 "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
7331 /* Test with no key */
7332 ret
= CryptExportPublicKeyInfoEx(csp
, AT_SIGNATURE
, X509_ASN_ENCODING
, NULL
,
7333 0, NULL
, NULL
, &size
);
7334 ok(!ret
&& GetLastError() == NTE_NO_KEY
, "Expected NTE_NO_KEY, got %08x\n",
7336 ret
= CryptGenKey(csp
, AT_SIGNATURE
, 0, &key
);
7337 ok(ret
, "CryptGenKey failed: %08x\n", GetLastError());
7340 ret
= CryptExportPublicKeyInfoEx(csp
, AT_SIGNATURE
, X509_ASN_ENCODING
,
7341 NULL
, 0, NULL
, NULL
, &size
);
7342 ok(ret
, "CryptExportPublicKeyInfoEx failed: %08x\n", GetLastError());
7343 *pInfo
= HeapAlloc(GetProcessHeap(), 0, size
);
7346 ret
= CryptExportPublicKeyInfoEx(csp
, AT_SIGNATURE
,
7347 X509_ASN_ENCODING
, NULL
, 0, NULL
, *pInfo
, &size
);
7348 ok(ret
, "CryptExportPublicKeyInfoEx failed: %08x\n",
7352 /* By default (we passed NULL as the OID) the OID is
7355 ok(!strcmp((*pInfo
)->Algorithm
.pszObjId
, szOID_RSA_RSA
),
7356 "Expected %s, got %s\n", szOID_RSA_RSA
,
7357 (*pInfo
)->Algorithm
.pszObjId
);
7361 CryptDestroyKey(key
);
7364 static const BYTE expiredCert
[] = { 0x30, 0x82, 0x01, 0x33, 0x30, 0x81, 0xe2,
7365 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x10, 0xc4, 0xd7, 0x7f, 0x0e, 0x6f, 0xa6,
7366 0x8c, 0xaa, 0x47, 0x47, 0x40, 0xe7, 0xb7, 0x0b, 0x4a, 0x7f, 0x30, 0x09, 0x06,
7367 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1d, 0x05, 0x00, 0x30, 0x1f, 0x31, 0x1d, 0x30,
7368 0x1b, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x14, 0x61, 0x72, 0x69, 0x63, 0x40,
7369 0x63, 0x6f, 0x64, 0x65, 0x77, 0x65, 0x61, 0x76, 0x65, 0x72, 0x73, 0x2e, 0x63,
7370 0x6f, 0x6d, 0x30, 0x1e, 0x17, 0x0d, 0x36, 0x39, 0x30, 0x31, 0x30, 0x31, 0x30,
7371 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x17, 0x0d, 0x37, 0x30, 0x30, 0x31, 0x30,
7372 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x1f, 0x31, 0x1d, 0x30,
7373 0x1b, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x14, 0x61, 0x72, 0x69, 0x63, 0x40,
7374 0x63, 0x6f, 0x64, 0x65, 0x77, 0x65, 0x61, 0x76, 0x65, 0x72, 0x73, 0x2e, 0x63,
7375 0x6f, 0x6d, 0x30, 0x5c, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
7376 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x4b, 0x00, 0x30, 0x48, 0x02, 0x41,
7377 0x00, 0xa1, 0xaf, 0x4a, 0xea, 0xa7, 0x83, 0x57, 0xc0, 0x37, 0x33, 0x7e, 0x29,
7378 0x5e, 0x0d, 0xfc, 0x44, 0x74, 0x3a, 0x1d, 0xc3, 0x1b, 0x1d, 0x96, 0xed, 0x4e,
7379 0xf4, 0x1b, 0x98, 0xec, 0x69, 0x1b, 0x04, 0xea, 0x25, 0xcf, 0xb3, 0x2a, 0xf5,
7380 0xd9, 0x22, 0xd9, 0x8d, 0x08, 0x39, 0x81, 0xc6, 0xe0, 0x4f, 0x12, 0x37, 0x2a,
7381 0x3f, 0x80, 0xa6, 0x6c, 0x67, 0x43, 0x3a, 0xdd, 0x95, 0x0c, 0xbb, 0x2f, 0x6b,
7382 0x02, 0x03, 0x01, 0x00, 0x01, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02,
7383 0x1d, 0x05, 0x00, 0x03, 0x41, 0x00, 0x8f, 0xa2, 0x5b, 0xd6, 0xdf, 0x34, 0xd0,
7384 0xa2, 0xa7, 0x47, 0xf1, 0x13, 0x79, 0xd3, 0xf3, 0x39, 0xbd, 0x4e, 0x2b, 0xa3,
7385 0xf4, 0x63, 0x37, 0xac, 0x5a, 0x0c, 0x5e, 0x4d, 0x0d, 0x54, 0x87, 0x4f, 0x31,
7386 0xfb, 0xa0, 0xce, 0x8f, 0x9a, 0x2f, 0x4d, 0x48, 0xc6, 0x84, 0x8d, 0xf5, 0x70,
7387 0x74, 0x17, 0xa5, 0xf3, 0x66, 0x47, 0x06, 0xd6, 0x64, 0x45, 0xbc, 0x52, 0xef,
7388 0x49, 0xe5, 0xf9, 0x65, 0xf3 };
7390 static void testImportPublicKey(HCRYPTPROV csp
, PCERT_PUBLIC_KEY_INFO info
)
7394 PCCERT_CONTEXT context
;
7399 ret = CryptImportPublicKeyInfoEx(0, 0, NULL, 0, 0, NULL, NULL);
7400 ret = CryptImportPublicKeyInfoEx(0, 0, NULL, 0, 0, NULL, &key);
7401 ret = CryptImportPublicKeyInfoEx(0, 0, info, 0, 0, NULL, NULL);
7402 ret = CryptImportPublicKeyInfoEx(csp, X509_ASN_ENCODING, info, 0, 0, NULL,
7405 ret
= CryptImportPublicKeyInfoEx(0, 0, info
, 0, 0, NULL
, &key
);
7406 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
7407 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
7408 ret
= CryptImportPublicKeyInfoEx(csp
, 0, info
, 0, 0, NULL
, &key
);
7409 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
7410 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
7411 ret
= CryptImportPublicKeyInfoEx(0, X509_ASN_ENCODING
, info
, 0, 0, NULL
,
7413 ok(!ret
&& GetLastError() == ERROR_INVALID_PARAMETER
,
7414 "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
7416 /* Export key with standard algorithm (CALG_RSA_KEYX) */
7417 ret
= CryptImportPublicKeyInfoEx(csp
, X509_ASN_ENCODING
, info
, 0, 0, NULL
,
7419 ok(ret
, "CryptImportPublicKeyInfoEx failed: %08x\n", GetLastError());
7421 dwSize
= sizeof(ai
);
7422 CryptGetKeyParam(key
, KP_ALGID
, (LPVOID
)&ai
, &dwSize
, 0);
7423 ok(ret
, "CryptGetKeyParam failed: %08x\n", GetLastError());
7426 ok(dwSize
== sizeof(ai
), "CryptGetKeyParam returned size %d\n",dwSize
);
7427 ok(ai
== CALG_RSA_KEYX
, "Default ALG_ID is %04x (expected CALG_RSA_KEYX)\n", ai
);
7430 CryptDestroyKey(key
);
7432 /* Repeat with forced algorithm */
7433 ret
= CryptImportPublicKeyInfoEx(csp
, X509_ASN_ENCODING
, info
, CALG_RSA_SIGN
, 0, NULL
,
7435 ok(ret
, "CryptImportPublicKeyInfoEx failed: %08x\n", GetLastError());
7437 dwSize
= sizeof(ai
);
7438 CryptGetKeyParam(key
, KP_ALGID
, (LPVOID
)&ai
, &dwSize
, 0);
7439 ok(ret
, "CryptGetKeyParam failed: %08x\n", GetLastError());
7442 ok(dwSize
== sizeof(ai
), "CryptGetKeyParam returned size %d\n",dwSize
);
7443 ok(ai
== CALG_RSA_SIGN
, "ALG_ID is %04x (expected CALG_RSA_SIGN)\n", ai
);
7446 CryptDestroyKey(key
);
7448 /* Test importing a public key from a certificate context */
7449 context
= CertCreateCertificateContext(X509_ASN_ENCODING
, expiredCert
,
7450 sizeof(expiredCert
));
7451 ok(context
!= NULL
, "CertCreateCertificateContext failed: %08x\n",
7455 ok(!strcmp(szOID_RSA_RSA
,
7456 context
->pCertInfo
->SubjectPublicKeyInfo
.Algorithm
.pszObjId
),
7457 "Expected %s, got %s\n", szOID_RSA_RSA
,
7458 context
->pCertInfo
->SubjectPublicKeyInfo
.Algorithm
.pszObjId
);
7459 ret
= CryptImportPublicKeyInfoEx(csp
, X509_ASN_ENCODING
,
7460 &context
->pCertInfo
->SubjectPublicKeyInfo
, 0, 0, NULL
, &key
);
7461 ok(ret
, "CryptImportPublicKeyInfoEx failed: %08x\n", GetLastError());
7462 CryptDestroyKey(key
);
7463 CertFreeCertificateContext(context
);
7467 static const char cspName
[] = "WineCryptTemp";
7469 static void testPortPublicKeyInfo(void)
7473 PCERT_PUBLIC_KEY_INFO info
= NULL
;
7475 /* Just in case a previous run failed, delete this thing */
7476 CryptAcquireContextA(&csp
, cspName
, MS_DEF_PROV
, PROV_RSA_FULL
,
7477 CRYPT_DELETEKEYSET
);
7478 ret
= CryptAcquireContextA(&csp
, cspName
, MS_DEF_PROV
, PROV_RSA_FULL
,
7481 testExportPublicKey(csp
, &info
);
7482 testImportPublicKey(csp
, info
);
7484 HeapFree(GetProcessHeap(), 0, info
);
7485 CryptReleaseContext(csp
, 0);
7486 ret
= CryptAcquireContextA(&csp
, cspName
, MS_DEF_PROV
, PROV_RSA_FULL
,
7487 CRYPT_DELETEKEYSET
);
7492 static const DWORD encodings
[] = { X509_ASN_ENCODING
, PKCS_7_ASN_ENCODING
,
7493 X509_ASN_ENCODING
| PKCS_7_ASN_ENCODING
};
7497 hCrypt32
= GetModuleHandleA("crypt32.dll");
7498 pCryptDecodeObjectEx
= (void*)GetProcAddress(hCrypt32
, "CryptDecodeObjectEx");
7499 pCryptEncodeObjectEx
= (void*)GetProcAddress(hCrypt32
, "CryptEncodeObjectEx");
7500 if (!pCryptDecodeObjectEx
|| !pCryptEncodeObjectEx
)
7502 skip("CryptDecodeObjectEx() is not available\n");
7506 for (i
= 0; i
< sizeof(encodings
) / sizeof(encodings
[0]); i
++)
7508 test_encodeInt(encodings
[i
]);
7509 test_decodeInt(encodings
[i
]);
7510 test_encodeEnumerated(encodings
[i
]);
7511 test_decodeEnumerated(encodings
[i
]);
7512 test_encodeFiletime(encodings
[i
]);
7513 test_decodeFiletime(encodings
[i
]);
7514 test_encodeName(encodings
[i
]);
7515 test_decodeName(encodings
[i
]);
7516 test_encodeUnicodeName(encodings
[i
]);
7517 test_decodeUnicodeName(encodings
[i
]);
7518 test_encodeNameValue(encodings
[i
]);
7519 test_decodeNameValue(encodings
[i
]);
7520 test_encodeUnicodeNameValue(encodings
[i
]);
7521 test_decodeUnicodeNameValue(encodings
[i
]);
7522 test_encodeAltName(encodings
[i
]);
7523 test_decodeAltName(encodings
[i
]);
7524 test_encodeOctets(encodings
[i
]);
7525 test_decodeOctets(encodings
[i
]);
7526 test_encodeBits(encodings
[i
]);
7527 test_decodeBits(encodings
[i
]);
7528 test_encodeBasicConstraints(encodings
[i
]);
7529 test_decodeBasicConstraints(encodings
[i
]);
7530 test_encodeRsaPublicKey(encodings
[i
]);
7531 test_decodeRsaPublicKey(encodings
[i
]);
7532 test_encodeSequenceOfAny(encodings
[i
]);
7533 test_decodeSequenceOfAny(encodings
[i
]);
7534 test_encodeExtensions(encodings
[i
]);
7535 test_decodeExtensions(encodings
[i
]);
7536 test_encodePublicKeyInfo(encodings
[i
]);
7537 test_decodePublicKeyInfo(encodings
[i
]);
7538 test_encodeCertToBeSigned(encodings
[i
]);
7539 test_decodeCertToBeSigned(encodings
[i
]);
7540 test_encodeCert(encodings
[i
]);
7541 test_decodeCert(encodings
[i
]);
7542 test_encodeCRLDistPoints(encodings
[i
]);
7543 test_decodeCRLDistPoints(encodings
[i
]);
7544 test_encodeCRLIssuingDistPoint(encodings
[i
]);
7545 test_decodeCRLIssuingDistPoint(encodings
[i
]);
7546 test_encodeCRLToBeSigned(encodings
[i
]);
7547 test_decodeCRLToBeSigned(encodings
[i
]);
7548 test_encodeEnhancedKeyUsage(encodings
[i
]);
7549 test_decodeEnhancedKeyUsage(encodings
[i
]);
7550 test_encodeAuthorityKeyId(encodings
[i
]);
7551 test_decodeAuthorityKeyId(encodings
[i
]);
7552 test_encodeAuthorityKeyId2(encodings
[i
]);
7553 test_decodeAuthorityKeyId2(encodings
[i
]);
7554 test_encodeAuthorityInfoAccess(encodings
[i
]);
7555 test_decodeAuthorityInfoAccess(encodings
[i
]);
7556 test_encodeCTL(encodings
[i
]);
7557 test_decodeCTL(encodings
[i
]);
7558 test_encodePKCSContentInfo(encodings
[i
]);
7559 test_decodePKCSContentInfo(encodings
[i
]);
7560 test_encodePKCSAttribute(encodings
[i
]);
7561 test_decodePKCSAttribute(encodings
[i
]);
7562 test_encodePKCSAttributes(encodings
[i
]);
7563 test_decodePKCSAttributes(encodings
[i
]);
7564 test_encodePKCSSMimeCapabilities(encodings
[i
]);
7565 test_decodePKCSSMimeCapabilities(encodings
[i
]);
7566 test_encodePKCSSignerInfo(encodings
[i
]);
7567 test_decodePKCSSignerInfo(encodings
[i
]);
7568 test_encodeCMSSignerInfo(encodings
[i
]);
7569 test_decodeCMSSignerInfo(encodings
[i
]);
7570 test_encodeNameConstraints(encodings
[i
]);
7571 test_decodeNameConstraints(encodings
[i
]);
7572 test_encodePolicyQualifierUserNotice(encodings
[i
]);
7573 test_decodePolicyQualifierUserNotice(encodings
[i
]);
7574 test_encodeCertPolicies(encodings
[i
]);
7575 test_decodeCertPolicies(encodings
[i
]);
7577 testPortPublicKeyInfo();