projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
sync crypt32 with wine 1.1.11
[reactos.git] / reactos / dll / win32 / crypt32 / decode.c
1 /*
2 * Copyright 2005-2008 Juan Lang
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 *
18 * This file implements ASN.1 DER decoding of a limited set of types.
19 * It isn't a full ASN.1 implementation. Microsoft implements BER
20 * encoding of many of the basic types in msasn1.dll, but that interface isn't
21 * implemented, so I implement them here.
22 *
23 * References:
24 * "A Layman's Guide to a Subset of ASN.1, BER, and DER", by Burton Kaliski
25 * (available online, look for a PDF copy as the HTML versions tend to have
26 * translation errors.)
27 *
28 * RFC3280, http://www.faqs.org/rfcs/rfc3280.html
29 *
30 * MSDN, especially "Constants for CryptEncodeObject and CryptDecodeObject"
31 */
32
33 #include "config.h"
34 #include "wine/port.h"
35
36 #include <assert.h>
37 #include <stdarg.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40
41 #define NONAMELESSUNION
42
43 #include "windef.h"
44 #include "winbase.h"
45 #include "wincrypt.h"
46 #include "winnls.h"
47 #include "snmp.h"
48 #include "wine/debug.h"
49 #include "wine/exception.h"
50 #include "crypt32_private.h"
51
52 /* This is a bit arbitrary, but to set some limit: */
53 #define MAX_ENCODED_LEN 0x02000000
54
55 #define ASN_FLAGS_MASK 0xe0
56 #define ASN_TYPE_MASK 0x1f
57
58 WINE_DEFAULT_DEBUG_CHANNEL(cryptasn);
59 WINE_DECLARE_DEBUG_CHANNEL(crypt);
60
61 struct GenericArray
62 {
63 DWORD cItems;
64 BYTE *rgItems;
65 };
66
67 typedef BOOL (WINAPI *CryptDecodeObjectFunc)(DWORD, LPCSTR, const BYTE *,
68 DWORD, DWORD, void *, DWORD *);
69 typedef BOOL (WINAPI *CryptDecodeObjectExFunc)(DWORD, LPCSTR, const BYTE *,
70 DWORD, DWORD, PCRYPT_DECODE_PARA, void *, DWORD *);
71
72 /* Internal decoders don't do memory allocation or exception handling, and
73 * they report how many bytes they decoded.
74 */
75 typedef BOOL (*InternalDecodeFunc)(const BYTE *pbEncoded, DWORD cbEncoded,
76 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded);
77
78 static BOOL CRYPT_AsnDecodeChoiceOfTimeInternal(const BYTE *pbEncoded,
79 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
80 DWORD *pcbDecoded);
81 static BOOL CRYPT_AsnDecodePubKeyInfoInternal(const BYTE *pbEncoded,
82 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
83 DWORD *pcbDecoded);
84 /* Like CRYPT_AsnDecodeExtensions, except assumes rgExtension is set ahead of
85 * time, doesn't do memory allocation, and doesn't do exception handling.
86 */
87 static BOOL CRYPT_AsnDecodeExtensionsInternal(const BYTE *pbEncoded,
88 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
89 DWORD *pcbDecoded);
90 /* Assumes algo->Parameters.pbData is set ahead of time. */
91 static BOOL CRYPT_AsnDecodeAlgorithmId(const BYTE *pbEncoded, DWORD cbEncoded,
92 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded);
93 static BOOL CRYPT_AsnDecodeBool(const BYTE *pbEncoded, DWORD cbEncoded,
94 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded);
95 /* Assumes the CRYPT_DATA_BLOB's pbData member has been initialized */
96 static BOOL CRYPT_AsnDecodeOctetsInternal(const BYTE *pbEncoded,
97 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
98 DWORD *pcbDecoded);
99 /* Doesn't check the tag, assumes the caller does so */
100 static BOOL CRYPT_AsnDecodeBitsInternal(const BYTE *pbEncoded, DWORD cbEncoded,
101 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded);
102 static BOOL CRYPT_AsnDecodeIntInternal(const BYTE *pbEncoded, DWORD cbEncoded,
103 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded);
104 /* Like CRYPT_AsnDecodeInteger, but assumes the CRYPT_INTEGER_BLOB's pbData
105 * member has been initialized, doesn't do exception handling, and doesn't do
106 * memory allocation. Also doesn't check tag, assumes the caller has checked
107 * it.
108 */
109 static BOOL CRYPT_AsnDecodeIntegerInternal(const BYTE *pbEncoded,
110 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
111 DWORD *pcbDecoded);
112 /* Like CRYPT_AsnDecodeInteger, but unsigned. */
113 static BOOL CRYPT_AsnDecodeUnsignedIntegerInternal(const BYTE *pbEncoded,
114 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
115 DWORD *pcbDecoded);
116 static BOOL CRYPT_AsnDecodePKCSAttributesInternal(const BYTE *pbEncoded,
117 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
118 DWORD *pcbDecoded);
119
120 /* Gets the number of length bytes from the given (leading) length byte */
121 #define GET_LEN_BYTES(b) ((b) <= 0x80 ? 1 : 1 + ((b) & 0x7f))
122
123 /* Helper function to get the encoded length of the data starting at pbEncoded,
124 * where pbEncoded[0] is the tag. If the data are too short to contain a
125 * length or if the length is too large for cbEncoded, sets an appropriate
126 * error code and returns FALSE. If the encoded length is unknown due to
127 * indefinite length encoding, *len is set to CMSG_INDEFINITE_LENGTH.
128 */
129 static BOOL CRYPT_GetLengthIndefinite(const BYTE *pbEncoded, DWORD cbEncoded,
130 DWORD *len)
131 {
132 BOOL ret;
133
134 if (cbEncoded <= 1)
135 {
136 SetLastError(CRYPT_E_ASN1_CORRUPT);
137 ret = FALSE;
138 }
139 else if (pbEncoded[1] <= 0x7f)
140 {
141 if (pbEncoded[1] + 1 > cbEncoded)
142 {
143 SetLastError(CRYPT_E_ASN1_EOD);
144 ret = FALSE;
145 }
146 else
147 {
148 *len = pbEncoded[1];
149 ret = TRUE;
150 }
151 }
152 else if (pbEncoded[1] == 0x80)
153 {
154 *len = CMSG_INDEFINITE_LENGTH;
155 ret = TRUE;
156 }
157 else
158 {
159 BYTE lenLen = GET_LEN_BYTES(pbEncoded[1]);
160
161 if (lenLen > sizeof(DWORD) + 1)
162 {
163 SetLastError(CRYPT_E_ASN1_LARGE);
164 ret = FALSE;
165 }
166 else if (lenLen + 2 > cbEncoded)
167 {
168 SetLastError(CRYPT_E_ASN1_CORRUPT);
169 ret = FALSE;
170 }
171 else
172 {
173 DWORD out = 0;
174
175 pbEncoded += 2;
176 while (--lenLen)
177 {
178 out <<= 8;
179 out |= *pbEncoded++;
180 }
181 if (out + lenLen + 1 > cbEncoded)
182 {
183 SetLastError(CRYPT_E_ASN1_EOD);
184 ret = FALSE;
185 }
186 else
187 {
188 *len = out;
189 ret = TRUE;
190 }
191 }
192 }
193 return ret;
194 }
195
196 /* Like CRYPT_GetLengthIndefinite, but disallows indefinite-length encoding. */
197 static BOOL CRYPT_GetLen(const BYTE *pbEncoded, DWORD cbEncoded, DWORD *len)
198 {
199 BOOL ret;
200
201 if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, len)) &&
202 *len == CMSG_INDEFINITE_LENGTH)
203 {
204 SetLastError(CRYPT_E_ASN1_CORRUPT);
205 ret = FALSE;
206 }
207 return ret;
208 }
209
210 /* Helper function to check *pcbStructInfo, set it to the required size, and
211 * optionally to allocate memory. Assumes pvStructInfo is not NULL.
212 * If CRYPT_DECODE_ALLOC_FLAG is set in dwFlags, *pvStructInfo will be set to a
213 * pointer to the newly allocated memory.
214 */
215 static BOOL CRYPT_DecodeEnsureSpace(DWORD dwFlags,
216 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo,
217 DWORD bytesNeeded)
218 {
219 BOOL ret = TRUE;
220
221 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
222 {
223 if (pDecodePara && pDecodePara->pfnAlloc)
224 *(BYTE **)pvStructInfo = pDecodePara->pfnAlloc(bytesNeeded);
225 else
226 *(BYTE **)pvStructInfo = LocalAlloc(0, bytesNeeded);
227 if (!*(BYTE **)pvStructInfo)
228 ret = FALSE;
229 else
230 *pcbStructInfo = bytesNeeded;
231 }
232 else if (*pcbStructInfo < bytesNeeded)
233 {
234 *pcbStructInfo = bytesNeeded;
235 SetLastError(ERROR_MORE_DATA);
236 ret = FALSE;
237 }
238 else
239 *pcbStructInfo = bytesNeeded;
240 return ret;
241 }
242
243 static void CRYPT_FreeSpace(PCRYPT_DECODE_PARA pDecodePara, LPVOID pv)
244 {
245 if (pDecodePara && pDecodePara->pfnFree)
246 pDecodePara->pfnFree(pv);
247 else
248 LocalFree(pv);
249 }
250
251 /* Helper function to check *pcbStructInfo and set it to the required size.
252 * Assumes pvStructInfo is not NULL.
253 */
254 static BOOL CRYPT_DecodeCheckSpace(DWORD *pcbStructInfo, DWORD bytesNeeded)
255 {
256 BOOL ret;
257
258 if (*pcbStructInfo < bytesNeeded)
259 {
260 *pcbStructInfo = bytesNeeded;
261 SetLastError(ERROR_MORE_DATA);
262 ret = FALSE;
263 }
264 else
265 {
266 *pcbStructInfo = bytesNeeded;
267 ret = TRUE;
268 }
269 return ret;
270 }
271
272 /* tag:
273 * The expected tag of the item. If tag is 0, decodeFunc is called
274 * regardless of the tag value seen.
275 * offset:
276 * A sequence is decoded into a struct. The offset member is the
277 * offset of this item within that struct.
278 * decodeFunc:
279 * The decoder function to use. If this is NULL, then the member isn't
280 * decoded, but minSize space is reserved for it.
281 * minSize:
282 * The minimum amount of space occupied after decoding. You must set this.
283 * optional:
284 * If true, and the tag doesn't match the expected tag for this item,
285 * or the decodeFunc fails with CRYPT_E_ASN1_BADTAG, then minSize space is
286 * filled with 0 for this member.
287 * hasPointer, pointerOffset:
288 * If the item has dynamic data, set hasPointer to TRUE, pointerOffset to
289 * the offset within the struct of the data pointer (or to the
290 * first data pointer, if more than one exist).
291 * size:
292 * Used by CRYPT_AsnDecodeSequence, not for your use.
293 */
294 struct AsnDecodeSequenceItem
295 {
296 BYTE tag;
297 DWORD offset;
298 InternalDecodeFunc decodeFunc;
299 DWORD minSize;
300 BOOL optional;
301 BOOL hasPointer;
302 DWORD pointerOffset;
303 DWORD size;
304 };
305
306 /* Decodes the items in a sequence, where the items are described in items,
307 * the encoded data are in pbEncoded with length cbEncoded. Decodes into
308 * pvStructInfo. nextData is a pointer to the memory location at which the
309 * first decoded item with a dynamic pointer should point.
310 * Upon decoding, *cbDecoded is the total number of bytes decoded.
311 * Each item decoder is never called with CRYPT_DECODE_ALLOC_FLAG set.
312 */
313 static BOOL CRYPT_AsnDecodeSequenceItems(struct AsnDecodeSequenceItem items[],
314 DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
315 void *pvStructInfo, BYTE *nextData, DWORD *cbDecoded)
316 {
317 BOOL ret;
318 DWORD i, decoded = 0;
319 const BYTE *ptr = pbEncoded;
320
321 TRACE("%p, %d, %p, %d, %08x, %p, %p, %p\n", items, cItem, pbEncoded,
322 cbEncoded, dwFlags, pvStructInfo, nextData, cbDecoded);
323
324 for (i = 0, ret = TRUE; ret && i < cItem; i++)
325 {
326 if (cbEncoded - (ptr - pbEncoded) != 0)
327 {
328 DWORD itemLen;
329
330 if ((ret = CRYPT_GetLengthIndefinite(ptr,
331 cbEncoded - (ptr - pbEncoded), &itemLen)))
332 {
333 BYTE itemLenBytes = GET_LEN_BYTES(ptr[1]);
334
335 if (ptr[0] == items[i].tag || !items[i].tag)
336 {
337 DWORD itemEncodedLen;
338
339 if (itemLen == CMSG_INDEFINITE_LENGTH)
340 itemEncodedLen = cbEncoded - (ptr - pbEncoded);
341 else
342 itemEncodedLen = 1 + itemLenBytes + itemLen;
343 if (nextData && pvStructInfo && items[i].hasPointer)
344 {
345 TRACE("Setting next pointer to %p\n",
346 nextData);
347 *(BYTE **)((BYTE *)pvStructInfo +
348 items[i].pointerOffset) = nextData;
349 }
350 if (items[i].decodeFunc)
351 {
352 DWORD itemDecoded;
353
354 if (pvStructInfo)
355 TRACE("decoding item %d\n", i);
356 else
357 TRACE("sizing item %d\n", i);
358 ret = items[i].decodeFunc(ptr, itemEncodedLen,
359 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
360 pvStructInfo ? (BYTE *)pvStructInfo + items[i].offset
361 : NULL, &items[i].size, &itemDecoded);
362 if (ret)
363 {
364 /* Account for alignment padding */
365 items[i].size = ALIGN_DWORD_PTR(items[i].size);
366 TRACE("item %d size: %d\n", i, items[i].size);
367 if (nextData && items[i].hasPointer &&
368 items[i].size > items[i].minSize)
369 nextData += items[i].size - items[i].minSize;
370 if (itemDecoded > itemEncodedLen)
371 {
372 WARN("decoded length %d exceeds encoded %d\n",
373 itemDecoded, itemEncodedLen);
374 SetLastError(CRYPT_E_ASN1_CORRUPT);
375 ret = FALSE;
376 }
377 else
378 {
379 ptr += itemDecoded;
380 decoded += itemDecoded;
381 TRACE("item %d: decoded %d bytes\n", i,
382 itemDecoded);
383 }
384 }
385 else if (items[i].optional &&
386 GetLastError() == CRYPT_E_ASN1_BADTAG)
387 {
388 TRACE("skipping optional item %d\n", i);
389 items[i].size = items[i].minSize;
390 SetLastError(NOERROR);
391 ret = TRUE;
392 }
393 else
394 TRACE("item %d failed: %08x\n", i,
395 GetLastError());
396 }
397 else if (itemLen == CMSG_INDEFINITE_LENGTH)
398 {
399 ERR("can't use indefinite length encoding without a decoder\n");
400 SetLastError(CRYPT_E_ASN1_CORRUPT);
401 ret = FALSE;
402 }
403 else
404 {
405 TRACE("item %d: decoded %d bytes\n", i, itemEncodedLen);
406 ptr += itemEncodedLen;
407 decoded += itemEncodedLen;
408 items[i].size = items[i].minSize;
409 }
410 }
411 else if (items[i].optional)
412 {
413 TRACE("skipping optional item %d\n", i);
414 items[i].size = items[i].minSize;
415 }
416 else
417 {
418 TRACE("item %d: tag %02x doesn't match expected %02x\n",
419 i, ptr[0], items[i].tag);
420 SetLastError(CRYPT_E_ASN1_BADTAG);
421 ret = FALSE;
422 }
423 }
424 }
425 else if (items[i].optional)
426 {
427 TRACE("missing optional item %d, skipping\n", i);
428 items[i].size = items[i].minSize;
429 }
430 else
431 {
432 TRACE("not enough bytes for item %d, failing\n", i);
433 SetLastError(CRYPT_E_ASN1_CORRUPT);
434 ret = FALSE;
435 }
436 }
437 if (cbDecoded)
438 *cbDecoded = decoded;
439 TRACE("returning %d\n", ret);
440 return ret;
441 }
442
443 /* This decodes an arbitrary sequence into a contiguous block of memory
444 * (basically, a struct.) Each element being decoded is described by a struct
445 * AsnDecodeSequenceItem, see above.
446 * startingPointer is an optional pointer to the first place where dynamic
447 * data will be stored. If you know the starting offset, you may pass it
448 * here. Otherwise, pass NULL, and one will be inferred from the items.
449 */
450 static BOOL CRYPT_AsnDecodeSequence(struct AsnDecodeSequenceItem items[],
451 DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
452 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo,
453 DWORD *pcbDecoded, void *startingPointer)
454 {
455 BOOL ret;
456
457 TRACE("%p, %d, %p, %d, %08x, %p, %p, %d, %p\n", items, cItem, pbEncoded,
458 cbEncoded, dwFlags, pDecodePara, pvStructInfo, *pcbStructInfo,
459 startingPointer);
460
461 if (!cbEncoded)
462 {
463 SetLastError(CRYPT_E_ASN1_EOD);
464 return FALSE;
465 }
466 if (pbEncoded[0] == ASN_SEQUENCE)
467 {
468 DWORD dataLen;
469
470 if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
471 {
472 DWORD lenBytes = GET_LEN_BYTES(pbEncoded[1]), cbDecoded;
473 const BYTE *ptr = pbEncoded + 1 + lenBytes;
474 BOOL indefinite = FALSE;
475
476 cbEncoded -= 1 + lenBytes;
477 if (dataLen == CMSG_INDEFINITE_LENGTH)
478 {
479 dataLen = cbEncoded;
480 indefinite = TRUE;
481 }
482 else if (cbEncoded < dataLen)
483 {
484 TRACE("dataLen %d exceeds cbEncoded %d, failing\n", dataLen,
485 cbEncoded);
486 SetLastError(CRYPT_E_ASN1_CORRUPT);
487 ret = FALSE;
488 }
489 if (ret)
490 {
491 ret = CRYPT_AsnDecodeSequenceItems(items, cItem,
492 ptr, dataLen, dwFlags, NULL, NULL, &cbDecoded);
493 if (ret && dataLen == CMSG_INDEFINITE_LENGTH)
494 {
495 if (cbDecoded > cbEncoded - 2)
496 {
497 /* Not enough space for 0 TLV */
498 SetLastError(CRYPT_E_ASN1_CORRUPT);
499 ret = FALSE;
500 }
501 else if (*(ptr + cbDecoded) != 0 ||
502 *(ptr + cbDecoded + 1) != 0)
503 {
504 TRACE("expected 0 TLV\n");
505 SetLastError(CRYPT_E_ASN1_CORRUPT);
506 ret = FALSE;
507 }
508 else
509 cbDecoded += 2;
510 }
511 }
512 if (ret && !indefinite && cbDecoded != dataLen)
513 {
514 TRACE("expected %d decoded, got %d, failing\n", dataLen,
515 cbDecoded);
516 SetLastError(CRYPT_E_ASN1_CORRUPT);
517 ret = FALSE;
518 }
519 if (ret)
520 {
521 DWORD i, bytesNeeded = 0, structSize = 0;
522
523 for (i = 0; i < cItem; i++)
524 {
525 bytesNeeded += items[i].size;
526 structSize += items[i].minSize;
527 }
528 if (pcbDecoded)
529 *pcbDecoded = 1 + lenBytes + cbDecoded;
530 if (!pvStructInfo)
531 *pcbStructInfo = bytesNeeded;
532 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags,
533 pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
534 {
535 BYTE *nextData;
536
537 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
538 pvStructInfo = *(BYTE **)pvStructInfo;
539 if (startingPointer)
540 nextData = (BYTE *)startingPointer;
541 else
542 nextData = (BYTE *)pvStructInfo + structSize;
543 memset(pvStructInfo, 0, structSize);
544 ret = CRYPT_AsnDecodeSequenceItems(items, cItem,
545 ptr, dataLen, dwFlags, pvStructInfo, nextData,
546 &cbDecoded);
547 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
548 CRYPT_FreeSpace(pDecodePara, pvStructInfo);
549 }
550 }
551 }
552 }
553 else
554 {
555 SetLastError(CRYPT_E_ASN1_BADTAG);
556 ret = FALSE;
557 }
558 TRACE("returning %d (%08x)\n", ret, GetLastError());
559 return ret;
560 }
561
562 /* tag:
563 * The expected tag of the entire encoded array (usually a variant
564 * of ASN_SETOF or ASN_SEQUENCEOF.) If tag is 0, decodeFunc is called
565 * regardless of the tag seen.
566 * decodeFunc:
567 * used to decode each item in the array
568 * itemSize:
569 * is the minimum size of each decoded item
570 * hasPointer:
571 * indicates whether each item has a dynamic pointer
572 * pointerOffset:
573 * indicates the offset within itemSize at which the pointer exists
574 */
575 struct AsnArrayDescriptor
576 {
577 BYTE tag;
578 InternalDecodeFunc decodeFunc;
579 DWORD itemSize;
580 BOOL hasPointer;
581 DWORD pointerOffset;
582 };
583
584 struct AsnArrayItemSize
585 {
586 DWORD encodedLen;
587 DWORD size;
588 };
589
590 /* Decodes an array of like types into a struct GenericArray.
591 * The layout and decoding of the array are described by a struct
592 * AsnArrayDescriptor.
593 */
594 static BOOL CRYPT_AsnDecodeArray(const struct AsnArrayDescriptor *arrayDesc,
595 const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
596 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo,
597 DWORD *pcbDecoded, void *startingPointer)
598 {
599 BOOL ret = TRUE;
600
601 TRACE("%p, %p, %d, %08x, %p, %p, %d, %p\n", arrayDesc, pbEncoded,
602 cbEncoded, dwFlags, pDecodePara, pvStructInfo, *pcbStructInfo,
603 startingPointer);
604
605 if (!arrayDesc->tag || pbEncoded[0] == arrayDesc->tag)
606 {
607 DWORD dataLen;
608
609 if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
610 {
611 DWORD bytesNeeded, cItems = 0, decoded;
612 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
613 /* There can be arbitrarily many items, but there is often only one.
614 */
615 struct AsnArrayItemSize itemSize = { 0 }, *itemSizes = &itemSize;
616
617 decoded = 1 + lenBytes;
618 bytesNeeded = sizeof(struct GenericArray);
619 if (dataLen)
620 {
621 const BYTE *ptr;
622 BOOL doneDecoding = FALSE;
623
624 for (ptr = pbEncoded + 1 + lenBytes; ret && !doneDecoding; )
625 {
626 if (dataLen == CMSG_INDEFINITE_LENGTH)
627 {
628 if (ptr[0] == 0)
629 {
630 doneDecoding = TRUE;
631 if (ptr[1] != 0)
632 {
633 SetLastError(CRYPT_E_ASN1_CORRUPT);
634 ret = FALSE;
635 }
636 else
637 decoded += 2;
638 }
639 }
640 else if (ptr - pbEncoded - 1 - lenBytes >= dataLen)
641 doneDecoding = TRUE;
642 if (!doneDecoding)
643 {
644 DWORD itemEncoded, itemDataLen, itemDecoded, size = 0;
645
646 /* Each item decoded may not tolerate extraneous bytes,
647 * so get the length of the next element if known.
648 */
649 if ((ret = CRYPT_GetLengthIndefinite(ptr,
650 cbEncoded - (ptr - pbEncoded), &itemDataLen)))
651 {
652 if (itemDataLen == CMSG_INDEFINITE_LENGTH)
653 itemEncoded = cbEncoded - (ptr - pbEncoded);
654 else
655 itemEncoded = 1 + GET_LEN_BYTES(ptr[1]) +
656 itemDataLen;
657 }
658 if (ret)
659 ret = arrayDesc->decodeFunc(ptr, itemEncoded,
660 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &size,
661 &itemDecoded);
662 if (ret)
663 {
664 cItems++;
665 if (itemSizes != &itemSize)
666 itemSizes = CryptMemRealloc(itemSizes,
667 cItems * sizeof(struct AsnArrayItemSize));
668 else if (cItems > 1)
669 {
670 itemSizes =
671 CryptMemAlloc(
672 cItems * sizeof(struct AsnArrayItemSize));
673 if (itemSizes)
674 memcpy(itemSizes, &itemSize,
675 sizeof(itemSize));
676 }
677 if (itemSizes)
678 {
679 decoded += itemDecoded;
680 itemSizes[cItems - 1].encodedLen = itemEncoded;
681 itemSizes[cItems - 1].size = size;
682 bytesNeeded += size;
683 ptr += itemEncoded;
684 }
685 else
686 ret = FALSE;
687 }
688 }
689 }
690 }
691 if (ret)
692 {
693 if (pcbDecoded)
694 *pcbDecoded = decoded;
695 if (!pvStructInfo)
696 *pcbStructInfo = bytesNeeded;
697 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags,
698 pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
699 {
700 DWORD i;
701 BYTE *nextData;
702 const BYTE *ptr;
703 struct GenericArray *array;
704
705 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
706 pvStructInfo = *(BYTE **)pvStructInfo;
707 array = (struct GenericArray *)pvStructInfo;
708 array->cItems = cItems;
709 if (startingPointer)
710 array->rgItems = startingPointer;
711 else
712 array->rgItems = (BYTE *)array +
713 sizeof(struct GenericArray);
714 nextData = array->rgItems +
715 array->cItems * arrayDesc->itemSize;
716 for (i = 0, ptr = pbEncoded + 1 + lenBytes; ret &&
717 i < cItems && ptr - pbEncoded - 1 - lenBytes <
718 dataLen; i++)
719 {
720 DWORD itemDecoded;
721
722 if (arrayDesc->hasPointer)
723 *(BYTE **)(array->rgItems + i * arrayDesc->itemSize
724 + arrayDesc->pointerOffset) = nextData;
725 ret = arrayDesc->decodeFunc(ptr,
726 itemSizes[i].encodedLen,
727 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
728 array->rgItems + i * arrayDesc->itemSize,
729 &itemSizes[i].size, &itemDecoded);
730 if (ret)
731 {
732 nextData += itemSizes[i].size - arrayDesc->itemSize;
733 ptr += itemDecoded;
734 }
735 }
736 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
737 CRYPT_FreeSpace(pDecodePara, pvStructInfo);
738 }
739 }
740 if (itemSizes != &itemSize)
741 CryptMemFree(itemSizes);
742 }
743 }
744 else
745 {
746 SetLastError(CRYPT_E_ASN1_BADTAG);
747 ret = FALSE;
748 }
749 return ret;
750 }
751
752 /* Decodes a DER-encoded BLOB into a CRYPT_DER_BLOB struct pointed to by
753 * pvStructInfo. The BLOB must be non-empty, otherwise the last error is set
754 * to CRYPT_E_ASN1_CORRUPT.
755 * Warning: assumes the CRYPT_DER_BLOB pointed to by pvStructInfo has pbData
756 * set!
757 */
758 static BOOL CRYPT_AsnDecodeDerBlob(const BYTE *pbEncoded, DWORD cbEncoded,
759 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
760 {
761 BOOL ret;
762 DWORD dataLen;
763
764 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
765 {
766 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
767 DWORD bytesNeeded = sizeof(CRYPT_DER_BLOB);
768
769 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
770 bytesNeeded += 1 + lenBytes + dataLen;
771
772 if (pcbDecoded)
773 *pcbDecoded = 1 + lenBytes + dataLen;
774 if (!pvStructInfo)
775 *pcbStructInfo = bytesNeeded;
776 else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo, bytesNeeded)))
777 {
778 CRYPT_DER_BLOB *blob;
779
780 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
781 pvStructInfo = *(BYTE **)pvStructInfo;
782 blob = (CRYPT_DER_BLOB *)pvStructInfo;
783 blob->cbData = 1 + lenBytes + dataLen;
784 if (blob->cbData)
785 {
786 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
787 blob->pbData = (BYTE *)pbEncoded;
788 else
789 {
790 assert(blob->pbData);
791 memcpy(blob->pbData, pbEncoded, blob->cbData);
792 }
793 }
794 else
795 {
796 SetLastError(CRYPT_E_ASN1_CORRUPT);
797 ret = FALSE;
798 }
799 }
800 }
801 return ret;
802 }
803
804 /* Like CRYPT_AsnDecodeBitsInternal, but swaps the bytes */
805 static BOOL CRYPT_AsnDecodeBitsSwapBytes(const BYTE *pbEncoded,
806 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
807 DWORD *pcbDecoded)
808 {
809 BOOL ret;
810
811 TRACE("(%p, %d, 0x%08x, %p, %d, %p)\n", pbEncoded, cbEncoded, dwFlags,
812 pvStructInfo, *pcbStructInfo, pcbDecoded);
813
814 /* Can't use the CRYPT_DECODE_NOCOPY_FLAG, because we modify the bytes in-
815 * place.
816 */
817 ret = CRYPT_AsnDecodeBitsInternal(pbEncoded, cbEncoded,
818 dwFlags & ~CRYPT_DECODE_NOCOPY_FLAG, pvStructInfo, pcbStructInfo,
819 pcbDecoded);
820 if (ret && pvStructInfo)
821 {
822 CRYPT_BIT_BLOB *blob = (CRYPT_BIT_BLOB *)pvStructInfo;
823
824 if (blob->cbData)
825 {
826 DWORD i;
827 BYTE temp;
828
829 for (i = 0; i < blob->cbData / 2; i++)
830 {
831 temp = blob->pbData[i];
832 blob->pbData[i] = blob->pbData[blob->cbData - i - 1];
833 blob->pbData[blob->cbData - i - 1] = temp;
834 }
835 }
836 }
837 TRACE("returning %d (%08x)\n", ret, GetLastError());
838 return ret;
839 }
840
841 static BOOL WINAPI CRYPT_AsnDecodeCertSignedContent(DWORD dwCertEncodingType,
842 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
843 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
844 {
845 BOOL ret = TRUE;
846
847 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
848 pDecodePara, pvStructInfo, *pcbStructInfo);
849
850 __TRY
851 {
852 struct AsnDecodeSequenceItem items[] = {
853 { 0, offsetof(CERT_SIGNED_CONTENT_INFO, ToBeSigned),
854 CRYPT_AsnDecodeDerBlob, sizeof(CRYPT_DER_BLOB), FALSE, TRUE,
855 offsetof(CERT_SIGNED_CONTENT_INFO, ToBeSigned.pbData), 0 },
856 { ASN_SEQUENCEOF, offsetof(CERT_SIGNED_CONTENT_INFO,
857 SignatureAlgorithm), CRYPT_AsnDecodeAlgorithmId,
858 sizeof(CRYPT_ALGORITHM_IDENTIFIER), FALSE, TRUE,
859 offsetof(CERT_SIGNED_CONTENT_INFO, SignatureAlgorithm.pszObjId), 0 },
860 { ASN_BITSTRING, offsetof(CERT_SIGNED_CONTENT_INFO, Signature),
861 CRYPT_AsnDecodeBitsSwapBytes, sizeof(CRYPT_BIT_BLOB), FALSE, TRUE,
862 offsetof(CERT_SIGNED_CONTENT_INFO, Signature.pbData), 0 },
863 };
864
865 if (dwFlags & CRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG)
866 items[2].decodeFunc = CRYPT_AsnDecodeBitsInternal;
867 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
868 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
869 pcbStructInfo, NULL, NULL);
870 }
871 __EXCEPT_PAGE_FAULT
872 {
873 SetLastError(STATUS_ACCESS_VIOLATION);
874 ret = FALSE;
875 }
876 __ENDTRY
877
878 TRACE("Returning %d (%08x)\n", ret, GetLastError());
879 return ret;
880 }
881
882 static BOOL CRYPT_AsnDecodeCertVersion(const BYTE *pbEncoded, DWORD cbEncoded,
883 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
884 {
885 BOOL ret;
886 DWORD dataLen;
887
888 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
889 {
890 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
891
892 ret = CRYPT_AsnDecodeIntInternal(pbEncoded + 1 + lenBytes, dataLen,
893 dwFlags, pvStructInfo, pcbStructInfo, NULL);
894 if (pcbDecoded)
895 *pcbDecoded = 1 + lenBytes + dataLen;
896 }
897 return ret;
898 }
899
900 static BOOL CRYPT_AsnDecodeValidity(const BYTE *pbEncoded, DWORD cbEncoded,
901 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
902 {
903 BOOL ret;
904
905 struct AsnDecodeSequenceItem items[] = {
906 { 0, offsetof(CERT_PRIVATE_KEY_VALIDITY, NotBefore),
907 CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE, 0 },
908 { 0, offsetof(CERT_PRIVATE_KEY_VALIDITY, NotAfter),
909 CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE, 0 },
910 };
911
912 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
913 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
914 pcbDecoded, NULL);
915 return ret;
916 }
917
918 static BOOL CRYPT_AsnDecodeCertExtensions(const BYTE *pbEncoded,
919 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
920 DWORD *pcbDecoded)
921 {
922 BOOL ret;
923 DWORD dataLen;
924
925 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
926 {
927 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
928
929 ret = CRYPT_AsnDecodeExtensionsInternal(pbEncoded + 1 + lenBytes,
930 dataLen, dwFlags, pvStructInfo, pcbStructInfo, NULL);
931 if (ret && pcbDecoded)
932 *pcbDecoded = 1 + lenBytes + dataLen;
933 }
934 return ret;
935 }
936
937 static BOOL CRYPT_AsnDecodeCertInfo(DWORD dwCertEncodingType,
938 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
939 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
940 {
941 BOOL ret = TRUE;
942 struct AsnDecodeSequenceItem items[] = {
943 { ASN_CONTEXT | ASN_CONSTRUCTOR, offsetof(CERT_INFO, dwVersion),
944 CRYPT_AsnDecodeCertVersion, sizeof(DWORD), TRUE, FALSE, 0, 0 },
945 { ASN_INTEGER, offsetof(CERT_INFO, SerialNumber),
946 CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), FALSE,
947 TRUE, offsetof(CERT_INFO, SerialNumber.pbData), 0 },
948 { ASN_SEQUENCEOF, offsetof(CERT_INFO, SignatureAlgorithm),
949 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
950 FALSE, TRUE, offsetof(CERT_INFO, SignatureAlgorithm.pszObjId), 0 },
951 { 0, offsetof(CERT_INFO, Issuer), CRYPT_AsnDecodeDerBlob,
952 sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CERT_INFO,
953 Issuer.pbData) },
954 { ASN_SEQUENCEOF, offsetof(CERT_INFO, NotBefore),
955 CRYPT_AsnDecodeValidity, sizeof(CERT_PRIVATE_KEY_VALIDITY), FALSE,
956 FALSE, 0 },
957 { 0, offsetof(CERT_INFO, Subject), CRYPT_AsnDecodeDerBlob,
958 sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CERT_INFO,
959 Subject.pbData) },
960 { ASN_SEQUENCEOF, offsetof(CERT_INFO, SubjectPublicKeyInfo),
961 CRYPT_AsnDecodePubKeyInfoInternal, sizeof(CERT_PUBLIC_KEY_INFO),
962 FALSE, TRUE, offsetof(CERT_INFO,
963 SubjectPublicKeyInfo.Algorithm.Parameters.pbData), 0 },
964 { ASN_BITSTRING, offsetof(CERT_INFO, IssuerUniqueId),
965 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
966 offsetof(CERT_INFO, IssuerUniqueId.pbData), 0 },
967 { ASN_BITSTRING, offsetof(CERT_INFO, SubjectUniqueId),
968 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
969 offsetof(CERT_INFO, SubjectUniqueId.pbData), 0 },
970 { ASN_CONTEXT | ASN_CONSTRUCTOR | 3, offsetof(CERT_INFO, cExtension),
971 CRYPT_AsnDecodeCertExtensions, sizeof(CERT_EXTENSIONS), TRUE, TRUE,
972 offsetof(CERT_INFO, rgExtension), 0 },
973 };
974
975 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
976 pDecodePara, pvStructInfo, *pcbStructInfo);
977
978 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
979 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo,
980 NULL, NULL);
981 if (ret && pvStructInfo)
982 {
983 CERT_INFO *info;
984
985 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
986 info = *(CERT_INFO **)pvStructInfo;
987 else
988 info = (CERT_INFO *)pvStructInfo;
989 if (!info->SerialNumber.cbData || !info->Issuer.cbData ||
990 !info->Subject.cbData)
991 {
992 SetLastError(CRYPT_E_ASN1_CORRUPT);
993 /* Don't need to deallocate, because it should have failed on the
994 * first pass (and no memory was allocated.)
995 */
996 ret = FALSE;
997 }
998 }
999
1000 TRACE("Returning %d (%08x)\n", ret, GetLastError());
1001 return ret;
1002 }
1003
1004 static BOOL WINAPI CRYPT_AsnDecodeCert(DWORD dwCertEncodingType,
1005 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1006 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1007 {
1008 BOOL ret = FALSE;
1009
1010 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1011 pDecodePara, pvStructInfo, *pcbStructInfo);
1012
1013 __TRY
1014 {
1015 DWORD size = 0;
1016
1017 /* Unless told not to, first try to decode it as a signed cert. */
1018 if (!(dwFlags & CRYPT_DECODE_TO_BE_SIGNED_FLAG))
1019 {
1020 PCERT_SIGNED_CONTENT_INFO signedCert = NULL;
1021
1022 ret = CRYPT_AsnDecodeCertSignedContent(dwCertEncodingType,
1023 X509_CERT, pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL,
1024 (BYTE *)&signedCert, &size);
1025 if (ret)
1026 {
1027 size = 0;
1028 ret = CRYPT_AsnDecodeCertInfo(dwCertEncodingType,
1029 X509_CERT_TO_BE_SIGNED, signedCert->ToBeSigned.pbData,
1030 signedCert->ToBeSigned.cbData, dwFlags, pDecodePara,
1031 pvStructInfo, pcbStructInfo);
1032 LocalFree(signedCert);
1033 }
1034 }
1035 /* Failing that, try it as an unsigned cert */
1036 if (!ret)
1037 {
1038 size = 0;
1039 ret = CRYPT_AsnDecodeCertInfo(dwCertEncodingType,
1040 X509_CERT_TO_BE_SIGNED, pbEncoded, cbEncoded, dwFlags,
1041 pDecodePara, pvStructInfo, pcbStructInfo);
1042 }
1043 }
1044 __EXCEPT_PAGE_FAULT
1045 {
1046 SetLastError(STATUS_ACCESS_VIOLATION);
1047 }
1048 __ENDTRY
1049
1050 TRACE("Returning %d (%08x)\n", ret, GetLastError());
1051 return ret;
1052 }
1053
1054 static BOOL CRYPT_AsnDecodeCRLEntry(const BYTE *pbEncoded, DWORD cbEncoded,
1055 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1056 {
1057 BOOL ret;
1058 struct AsnDecodeSequenceItem items[] = {
1059 { ASN_INTEGER, offsetof(CRL_ENTRY, SerialNumber),
1060 CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), FALSE, TRUE,
1061 offsetof(CRL_ENTRY, SerialNumber.pbData), 0 },
1062 { 0, offsetof(CRL_ENTRY, RevocationDate),
1063 CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE, 0 },
1064 { ASN_SEQUENCEOF, offsetof(CRL_ENTRY, cExtension),
1065 CRYPT_AsnDecodeExtensionsInternal, sizeof(CERT_EXTENSIONS), TRUE, TRUE,
1066 offsetof(CRL_ENTRY, rgExtension), 0 },
1067 };
1068 PCRL_ENTRY entry = (PCRL_ENTRY)pvStructInfo;
1069
1070 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, entry,
1071 *pcbStructInfo);
1072
1073 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
1074 pbEncoded, cbEncoded, dwFlags, NULL, entry, pcbStructInfo, pcbDecoded,
1075 entry ? entry->SerialNumber.pbData : NULL);
1076 if (ret && entry && !entry->SerialNumber.cbData)
1077 {
1078 WARN("empty CRL entry serial number\n");
1079 SetLastError(CRYPT_E_ASN1_CORRUPT);
1080 ret = FALSE;
1081 }
1082 return ret;
1083 }
1084
1085 /* Warning: assumes pvStructInfo is a struct GenericArray whose rgItems has
1086 * been set prior to calling.
1087 */
1088 static BOOL CRYPT_AsnDecodeCRLEntries(const BYTE *pbEncoded, DWORD cbEncoded,
1089 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1090 {
1091 BOOL ret;
1092 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1093 CRYPT_AsnDecodeCRLEntry, sizeof(CRL_ENTRY), TRUE,
1094 offsetof(CRL_ENTRY, SerialNumber.pbData) };
1095 struct GenericArray *entries = (struct GenericArray *)pvStructInfo;
1096
1097 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
1098 pvStructInfo, *pcbStructInfo, pcbDecoded);
1099
1100 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1101 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
1102 entries ? entries->rgItems : NULL);
1103 TRACE("Returning %d (%08x)\n", ret, GetLastError());
1104 return ret;
1105 }
1106
1107 static BOOL CRYPT_AsnDecodeCRLInfo(DWORD dwCertEncodingType,
1108 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1109 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1110 {
1111 struct AsnDecodeSequenceItem items[] = {
1112 { ASN_INTEGER, offsetof(CRL_INFO, dwVersion),
1113 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), TRUE, FALSE, 0, 0 },
1114 { ASN_SEQUENCEOF, offsetof(CRL_INFO, SignatureAlgorithm),
1115 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
1116 FALSE, TRUE, offsetof(CRL_INFO, SignatureAlgorithm.pszObjId), 0 },
1117 { 0, offsetof(CRL_INFO, Issuer), CRYPT_AsnDecodeDerBlob,
1118 sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CRL_INFO,
1119 Issuer.pbData) },
1120 { 0, offsetof(CRL_INFO, ThisUpdate), CRYPT_AsnDecodeChoiceOfTimeInternal,
1121 sizeof(FILETIME), FALSE, FALSE, 0 },
1122 { 0, offsetof(CRL_INFO, NextUpdate), CRYPT_AsnDecodeChoiceOfTimeInternal,
1123 sizeof(FILETIME), TRUE, FALSE, 0 },
1124 { ASN_SEQUENCEOF, offsetof(CRL_INFO, cCRLEntry),
1125 CRYPT_AsnDecodeCRLEntries, sizeof(struct GenericArray), TRUE, TRUE,
1126 offsetof(CRL_INFO, rgCRLEntry), 0 },
1127 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CRL_INFO, cExtension),
1128 CRYPT_AsnDecodeCertExtensions, sizeof(CERT_EXTENSIONS), TRUE, TRUE,
1129 offsetof(CRL_INFO, rgExtension), 0 },
1130 };
1131 BOOL ret = TRUE;
1132
1133 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1134 pDecodePara, pvStructInfo, *pcbStructInfo);
1135
1136 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
1137 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo,
1138 NULL, NULL);
1139
1140 TRACE("Returning %d (%08x)\n", ret, GetLastError());
1141 return ret;
1142 }
1143
1144 static BOOL WINAPI CRYPT_AsnDecodeCRL(DWORD dwCertEncodingType,
1145 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1146 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1147 {
1148 BOOL ret = FALSE;
1149
1150 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1151 pDecodePara, pvStructInfo, *pcbStructInfo);
1152
1153 __TRY
1154 {
1155 DWORD size = 0;
1156
1157 /* Unless told not to, first try to decode it as a signed crl. */
1158 if (!(dwFlags & CRYPT_DECODE_TO_BE_SIGNED_FLAG))
1159 {
1160 PCERT_SIGNED_CONTENT_INFO signedCrl = NULL;
1161
1162 ret = CRYPT_AsnDecodeCertSignedContent(dwCertEncodingType,
1163 X509_CERT, pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL,
1164 (BYTE *)&signedCrl, &size);
1165 if (ret)
1166 {
1167 size = 0;
1168 ret = CRYPT_AsnDecodeCRLInfo(dwCertEncodingType,
1169 X509_CERT_CRL_TO_BE_SIGNED, signedCrl->ToBeSigned.pbData,
1170 signedCrl->ToBeSigned.cbData, dwFlags, pDecodePara,
1171 pvStructInfo, pcbStructInfo);
1172 LocalFree(signedCrl);
1173 }
1174 }
1175 /* Failing that, try it as an unsigned crl */
1176 if (!ret)
1177 {
1178 size = 0;
1179 ret = CRYPT_AsnDecodeCRLInfo(dwCertEncodingType,
1180 X509_CERT_CRL_TO_BE_SIGNED, pbEncoded, cbEncoded,
1181 dwFlags, pDecodePara, pvStructInfo, pcbStructInfo);
1182 }
1183 }
1184 __EXCEPT_PAGE_FAULT
1185 {
1186 SetLastError(STATUS_ACCESS_VIOLATION);
1187 }
1188 __ENDTRY
1189
1190 TRACE("Returning %d (%08x)\n", ret, GetLastError());
1191 return ret;
1192 }
1193
1194 static BOOL CRYPT_AsnDecodeOidIgnoreTag(const BYTE *pbEncoded, DWORD cbEncoded,
1195 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1196 {
1197 BOOL ret = TRUE;
1198 DWORD dataLen;
1199
1200 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1201 pvStructInfo, *pcbStructInfo);
1202
1203 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1204 {
1205 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1206 DWORD bytesNeeded = sizeof(LPSTR);
1207
1208 if (dataLen)
1209 {
1210 /* The largest possible string for the first two components
1211 * is 2.175 (= 2 * 40 + 175 = 255), so this is big enough.
1212 */
1213 char firstTwo[6];
1214 const BYTE *ptr;
1215
1216 snprintf(firstTwo, sizeof(firstTwo), "%d.%d",
1217 pbEncoded[1 + lenBytes] / 40,
1218 pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] / 40)
1219 * 40);
1220 bytesNeeded += strlen(firstTwo) + 1;
1221 for (ptr = pbEncoded + 2 + lenBytes; ret &&
1222 ptr - pbEncoded - 1 - lenBytes < dataLen; )
1223 {
1224 /* large enough for ".4000000" */
1225 char str[9];
1226 int val = 0;
1227
1228 while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1229 (*ptr & 0x80))
1230 {
1231 val <<= 7;
1232 val |= *ptr & 0x7f;
1233 ptr++;
1234 }
1235 if (ptr - pbEncoded - 1 - lenBytes >= dataLen ||
1236 (*ptr & 0x80))
1237 {
1238 SetLastError(CRYPT_E_ASN1_CORRUPT);
1239 ret = FALSE;
1240 }
1241 else
1242 {
1243 val <<= 7;
1244 val |= *ptr++;
1245 snprintf(str, sizeof(str), ".%d", val);
1246 bytesNeeded += strlen(str);
1247 }
1248 }
1249 }
1250 if (pcbDecoded)
1251 *pcbDecoded = 1 + lenBytes + dataLen;
1252 if (!pvStructInfo)
1253 *pcbStructInfo = bytesNeeded;
1254 else if (*pcbStructInfo < bytesNeeded)
1255 {
1256 *pcbStructInfo = bytesNeeded;
1257 SetLastError(ERROR_MORE_DATA);
1258 ret = FALSE;
1259 }
1260 else
1261 {
1262 if (dataLen)
1263 {
1264 const BYTE *ptr;
1265 LPSTR pszObjId = *(LPSTR *)pvStructInfo;
1266
1267 *pszObjId = 0;
1268 sprintf(pszObjId, "%d.%d", pbEncoded[1 + lenBytes] / 40,
1269 pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] /
1270 40) * 40);
1271 pszObjId += strlen(pszObjId);
1272 for (ptr = pbEncoded + 2 + lenBytes; ret &&
1273 ptr - pbEncoded - 1 - lenBytes < dataLen; )
1274 {
1275 int val = 0;
1276
1277 while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1278 (*ptr & 0x80))
1279 {
1280 val <<= 7;
1281 val |= *ptr & 0x7f;
1282 ptr++;
1283 }
1284 val <<= 7;
1285 val |= *ptr++;
1286 sprintf(pszObjId, ".%d", val);
1287 pszObjId += strlen(pszObjId);
1288 }
1289 }
1290 else
1291 *(LPSTR *)pvStructInfo = NULL;
1292 *pcbStructInfo = bytesNeeded;
1293 }
1294 }
1295 return ret;
1296 }
1297
1298 static BOOL CRYPT_AsnDecodeOidInternal(const BYTE *pbEncoded, DWORD cbEncoded,
1299 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1300 {
1301 BOOL ret;
1302
1303 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1304 pvStructInfo, *pcbStructInfo);
1305
1306 if (pbEncoded[0] == ASN_OBJECTIDENTIFIER)
1307 ret = CRYPT_AsnDecodeOidIgnoreTag(pbEncoded, cbEncoded, dwFlags,
1308 pvStructInfo, pcbStructInfo, pcbDecoded);
1309 else
1310 {
1311 SetLastError(CRYPT_E_ASN1_BADTAG);
1312 ret = FALSE;
1313 }
1314 return ret;
1315 }
1316
1317 /* Warning: assumes pvStructInfo is a CERT_EXTENSION whose pszObjId is set
1318 * ahead of time!
1319 */
1320 static BOOL CRYPT_AsnDecodeExtension(const BYTE *pbEncoded, DWORD cbEncoded,
1321 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1322 {
1323 struct AsnDecodeSequenceItem items[] = {
1324 { ASN_OBJECTIDENTIFIER, offsetof(CERT_EXTENSION, pszObjId),
1325 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
1326 offsetof(CERT_EXTENSION, pszObjId), 0 },
1327 { ASN_BOOL, offsetof(CERT_EXTENSION, fCritical), CRYPT_AsnDecodeBool,
1328 sizeof(BOOL), TRUE, FALSE, 0, 0 },
1329 { ASN_OCTETSTRING, offsetof(CERT_EXTENSION, Value),
1330 CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_OBJID_BLOB), FALSE, TRUE,
1331 offsetof(CERT_EXTENSION, Value.pbData) },
1332 };
1333 BOOL ret = TRUE;
1334 PCERT_EXTENSION ext = (PCERT_EXTENSION)pvStructInfo;
1335
1336 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, ext,
1337 *pcbStructInfo);
1338
1339 if (ext)
1340 TRACE("ext->pszObjId is %p\n", ext->pszObjId);
1341 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
1342 pbEncoded, cbEncoded, dwFlags, NULL, ext, pcbStructInfo,
1343 pcbDecoded, ext ? ext->pszObjId : NULL);
1344 if (ext)
1345 TRACE("ext->pszObjId is %p (%s)\n", ext->pszObjId,
1346 debugstr_a(ext->pszObjId));
1347 TRACE("returning %d (%08x)\n", ret, GetLastError());
1348 return ret;
1349 }
1350
1351 static BOOL CRYPT_AsnDecodeExtensionsInternal(const BYTE *pbEncoded,
1352 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1353 DWORD *pcbDecoded)
1354 {
1355 BOOL ret = TRUE;
1356 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1357 CRYPT_AsnDecodeExtension, sizeof(CERT_EXTENSION), TRUE,
1358 offsetof(CERT_EXTENSION, pszObjId) };
1359 PCERT_EXTENSIONS exts = (PCERT_EXTENSIONS)pvStructInfo;
1360
1361 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
1362 pvStructInfo, *pcbStructInfo, pcbDecoded);
1363
1364 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1365 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
1366 exts ? exts->rgExtension : NULL);
1367 return ret;
1368 }
1369
1370 static BOOL WINAPI CRYPT_AsnDecodeExtensions(DWORD dwCertEncodingType,
1371 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1372 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1373 {
1374 BOOL ret = TRUE;
1375
1376 __TRY
1377 {
1378 ret = CRYPT_AsnDecodeExtensionsInternal(pbEncoded, cbEncoded,
1379 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
1380 if (ret && pvStructInfo)
1381 {
1382 ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
1383 pcbStructInfo, *pcbStructInfo);
1384 if (ret)
1385 {
1386 CERT_EXTENSIONS *exts;
1387
1388 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
1389 pvStructInfo = *(BYTE **)pvStructInfo;
1390 exts = (CERT_EXTENSIONS *)pvStructInfo;
1391 exts->rgExtension = (CERT_EXTENSION *)((BYTE *)exts +
1392 sizeof(CERT_EXTENSIONS));
1393 ret = CRYPT_AsnDecodeExtensionsInternal(pbEncoded, cbEncoded,
1394 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
1395 pcbStructInfo, NULL);
1396 }
1397 }
1398 }
1399 __EXCEPT_PAGE_FAULT
1400 {
1401 SetLastError(STATUS_ACCESS_VIOLATION);
1402 ret = FALSE;
1403 }
1404 __ENDTRY
1405 return ret;
1406 }
1407
1408 /* Warning: this assumes the address of value->Value.pbData is already set, in
1409 * order to avoid overwriting memory. (In some cases, it may change it, if it
1410 * doesn't copy anything to memory.) Be sure to set it correctly!
1411 */
1412 static BOOL CRYPT_AsnDecodeNameValueInternal(const BYTE *pbEncoded,
1413 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1414 DWORD *pcbDecoded)
1415 {
1416 BOOL ret = TRUE;
1417 DWORD dataLen;
1418 CERT_NAME_VALUE *value = (CERT_NAME_VALUE *)pvStructInfo;
1419
1420 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1421 {
1422 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1423 DWORD bytesNeeded = sizeof(CERT_NAME_VALUE), valueType;
1424
1425 switch (pbEncoded[0])
1426 {
1427 case ASN_OCTETSTRING:
1428 valueType = CERT_RDN_OCTET_STRING;
1429 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1430 bytesNeeded += dataLen;
1431 break;
1432 case ASN_NUMERICSTRING:
1433 valueType = CERT_RDN_NUMERIC_STRING;
1434 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1435 bytesNeeded += dataLen;
1436 break;
1437 case ASN_PRINTABLESTRING:
1438 valueType = CERT_RDN_PRINTABLE_STRING;
1439 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1440 bytesNeeded += dataLen;
1441 break;
1442 case ASN_IA5STRING:
1443 valueType = CERT_RDN_IA5_STRING;
1444 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1445 bytesNeeded += dataLen;
1446 break;
1447 case ASN_T61STRING:
1448 valueType = CERT_RDN_T61_STRING;
1449 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1450 bytesNeeded += dataLen;
1451 break;
1452 case ASN_VIDEOTEXSTRING:
1453 valueType = CERT_RDN_VIDEOTEX_STRING;
1454 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1455 bytesNeeded += dataLen;
1456 break;
1457 case ASN_GRAPHICSTRING:
1458 valueType = CERT_RDN_GRAPHIC_STRING;
1459 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1460 bytesNeeded += dataLen;
1461 break;
1462 case ASN_VISIBLESTRING:
1463 valueType = CERT_RDN_VISIBLE_STRING;
1464 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1465 bytesNeeded += dataLen;
1466 break;
1467 case ASN_GENERALSTRING:
1468 valueType = CERT_RDN_GENERAL_STRING;
1469 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1470 bytesNeeded += dataLen;
1471 break;
1472 case ASN_UNIVERSALSTRING:
1473 FIXME("ASN_UNIVERSALSTRING: unimplemented\n");
1474 SetLastError(CRYPT_E_ASN1_BADTAG);
1475 return FALSE;
1476 case ASN_BMPSTRING:
1477 valueType = CERT_RDN_BMP_STRING;
1478 bytesNeeded += dataLen;
1479 break;
1480 case ASN_UTF8STRING:
1481 valueType = CERT_RDN_UTF8_STRING;
1482 bytesNeeded += MultiByteToWideChar(CP_UTF8, 0,
1483 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen, NULL, 0) * 2;
1484 break;
1485 default:
1486 SetLastError(CRYPT_E_ASN1_BADTAG);
1487 return FALSE;
1488 }
1489
1490 if (pcbDecoded)
1491 *pcbDecoded = 1 + lenBytes + dataLen;
1492 if (!value)
1493 *pcbStructInfo = bytesNeeded;
1494 else if (*pcbStructInfo < bytesNeeded)
1495 {
1496 *pcbStructInfo = bytesNeeded;
1497 SetLastError(ERROR_MORE_DATA);
1498 ret = FALSE;
1499 }
1500 else
1501 {
1502 *pcbStructInfo = bytesNeeded;
1503 value->dwValueType = valueType;
1504 if (dataLen)
1505 {
1506 DWORD i;
1507
1508 assert(value->Value.pbData);
1509 switch (pbEncoded[0])
1510 {
1511 case ASN_OCTETSTRING:
1512 case ASN_NUMERICSTRING:
1513 case ASN_PRINTABLESTRING:
1514 case ASN_IA5STRING:
1515 case ASN_T61STRING:
1516 case ASN_VIDEOTEXSTRING:
1517 case ASN_GRAPHICSTRING:
1518 case ASN_VISIBLESTRING:
1519 case ASN_GENERALSTRING:
1520 value->Value.cbData = dataLen;
1521 if (dataLen)
1522 {
1523 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1524 memcpy(value->Value.pbData,
1525 pbEncoded + 1 + lenBytes, dataLen);
1526 else
1527 value->Value.pbData = (LPBYTE)pbEncoded + 1 +
1528 lenBytes;
1529 }
1530 break;
1531 case ASN_BMPSTRING:
1532 {
1533 LPWSTR str = (LPWSTR)value->Value.pbData;
1534
1535 value->Value.cbData = dataLen;
1536 for (i = 0; i < dataLen / 2; i++)
1537 str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
1538 pbEncoded[1 + lenBytes + 2 * i + 1];
1539 break;
1540 }
1541 case ASN_UTF8STRING:
1542 {
1543 LPWSTR str = (LPWSTR)value->Value.pbData;
1544
1545 value->Value.cbData = MultiByteToWideChar(CP_UTF8, 0,
1546 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen,
1547 str, bytesNeeded - sizeof(CERT_NAME_VALUE)) * 2;
1548 break;
1549 }
1550 }
1551 }
1552 else
1553 {
1554 value->Value.cbData = 0;
1555 value->Value.pbData = NULL;
1556 }
1557 }
1558 }
1559 return ret;
1560 }
1561
1562 static BOOL WINAPI CRYPT_AsnDecodeNameValue(DWORD dwCertEncodingType,
1563 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1564 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1565 {
1566 BOOL ret = TRUE;
1567
1568 __TRY
1569 {
1570 ret = CRYPT_AsnDecodeNameValueInternal(pbEncoded, cbEncoded,
1571 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
1572 if (ret && pvStructInfo)
1573 {
1574 ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
1575 pcbStructInfo, *pcbStructInfo);
1576 if (ret)
1577 {
1578 CERT_NAME_VALUE *value;
1579
1580 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
1581 pvStructInfo = *(BYTE **)pvStructInfo;
1582 value = (CERT_NAME_VALUE *)pvStructInfo;
1583 value->Value.pbData = ((BYTE *)value + sizeof(CERT_NAME_VALUE));
1584 ret = CRYPT_AsnDecodeNameValueInternal( pbEncoded, cbEncoded,
1585 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
1586 pcbStructInfo, NULL);
1587 }
1588 }
1589 }
1590 __EXCEPT_PAGE_FAULT
1591 {
1592 SetLastError(STATUS_ACCESS_VIOLATION);
1593 ret = FALSE;
1594 }
1595 __ENDTRY
1596 return ret;
1597 }
1598
1599 static BOOL CRYPT_AsnDecodeUnicodeNameValueInternal(const BYTE *pbEncoded,
1600 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1601 DWORD *pcbDecoded)
1602 {
1603 BOOL ret = TRUE;
1604 DWORD dataLen;
1605 CERT_NAME_VALUE *value = (CERT_NAME_VALUE *)pvStructInfo;
1606
1607 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1608 {
1609 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1610 DWORD bytesNeeded = sizeof(CERT_NAME_VALUE), valueType;
1611
1612 switch (pbEncoded[0])
1613 {
1614 case ASN_NUMERICSTRING:
1615 valueType = CERT_RDN_NUMERIC_STRING;
1616 if (dataLen)
1617 bytesNeeded += (dataLen + 1) * 2;
1618 break;
1619 case ASN_PRINTABLESTRING:
1620 valueType = CERT_RDN_PRINTABLE_STRING;
1621 if (dataLen)
1622 bytesNeeded += (dataLen + 1) * 2;
1623 break;
1624 case ASN_IA5STRING:
1625 valueType = CERT_RDN_IA5_STRING;
1626 if (dataLen)
1627 bytesNeeded += (dataLen + 1) * 2;
1628 break;
1629 case ASN_T61STRING:
1630 valueType = CERT_RDN_T61_STRING;
1631 if (dataLen)
1632 bytesNeeded += (dataLen + 1) * 2;
1633 break;
1634 case ASN_VIDEOTEXSTRING:
1635 valueType = CERT_RDN_VIDEOTEX_STRING;
1636 if (dataLen)
1637 bytesNeeded += (dataLen + 1) * 2;
1638 break;
1639 case ASN_GRAPHICSTRING:
1640 valueType = CERT_RDN_GRAPHIC_STRING;
1641 if (dataLen)
1642 bytesNeeded += (dataLen + 1) * 2;
1643 break;
1644 case ASN_VISIBLESTRING:
1645 valueType = CERT_RDN_VISIBLE_STRING;
1646 if (dataLen)
1647 bytesNeeded += (dataLen + 1) * 2;
1648 break;
1649 case ASN_GENERALSTRING:
1650 valueType = CERT_RDN_GENERAL_STRING;
1651 if (dataLen)
1652 bytesNeeded += (dataLen + 1) * 2;
1653 break;
1654 case ASN_UNIVERSALSTRING:
1655 valueType = CERT_RDN_UNIVERSAL_STRING;
1656 if (dataLen)
1657 bytesNeeded += dataLen / 2 + sizeof(WCHAR);
1658 break;
1659 case ASN_BMPSTRING:
1660 valueType = CERT_RDN_BMP_STRING;
1661 if (dataLen)
1662 bytesNeeded += dataLen + sizeof(WCHAR);
1663 break;
1664 case ASN_UTF8STRING:
1665 valueType = CERT_RDN_UTF8_STRING;
1666 if (dataLen)
1667 bytesNeeded += (MultiByteToWideChar(CP_UTF8, 0,
1668 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen, NULL, 0) + 1) * 2;
1669 break;
1670 default:
1671 SetLastError(CRYPT_E_ASN1_BADTAG);
1672 return FALSE;
1673 }
1674
1675 if (pcbDecoded)
1676 *pcbDecoded = 1 + lenBytes + dataLen;
1677 if (!value)
1678 *pcbStructInfo = bytesNeeded;
1679 else if (*pcbStructInfo < bytesNeeded)
1680 {
1681 *pcbStructInfo = bytesNeeded;
1682 SetLastError(ERROR_MORE_DATA);
1683 ret = FALSE;
1684 }
1685 else
1686 {
1687 *pcbStructInfo = bytesNeeded;
1688 value->dwValueType = valueType;
1689 if (dataLen)
1690 {
1691 DWORD i;
1692 LPWSTR str = (LPWSTR)value->Value.pbData;
1693
1694 assert(value->Value.pbData);
1695 switch (pbEncoded[0])
1696 {
1697 case ASN_NUMERICSTRING:
1698 case ASN_PRINTABLESTRING:
1699 case ASN_IA5STRING:
1700 case ASN_T61STRING:
1701 case ASN_VIDEOTEXSTRING:
1702 case ASN_GRAPHICSTRING:
1703 case ASN_VISIBLESTRING:
1704 case ASN_GENERALSTRING:
1705 value->Value.cbData = dataLen * 2;
1706 for (i = 0; i < dataLen; i++)
1707 str[i] = pbEncoded[1 + lenBytes + i];
1708 str[i] = 0;
1709 break;
1710 case ASN_UNIVERSALSTRING:
1711 value->Value.cbData = dataLen / 2;
1712 for (i = 0; i < dataLen / 4; i++)
1713 str[i] = (pbEncoded[1 + lenBytes + 2 * i + 2] << 8)
1714 | pbEncoded[1 + lenBytes + 2 * i + 3];
1715 str[i] = 0;
1716 break;
1717 case ASN_BMPSTRING:
1718 value->Value.cbData = dataLen;
1719 for (i = 0; i < dataLen / 2; i++)
1720 str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
1721 pbEncoded[1 + lenBytes + 2 * i + 1];
1722 str[i] = 0;
1723 break;
1724 case ASN_UTF8STRING:
1725 value->Value.cbData = MultiByteToWideChar(CP_UTF8, 0,
1726 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen,
1727 str, bytesNeeded - sizeof(CERT_NAME_VALUE)) * 2;
1728 value->Value.pbData[value->Value.cbData / sizeof(WCHAR)]
1729 = 0;
1730 value->Value.cbData += sizeof(WCHAR);
1731 break;
1732 }
1733 }
1734 else
1735 {
1736 value->Value.cbData = 0;
1737 value->Value.pbData = NULL;
1738 }
1739 }
1740 }
1741 return ret;
1742 }
1743
1744 static BOOL WINAPI CRYPT_AsnDecodeUnicodeNameValue(DWORD dwCertEncodingType,
1745 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1746 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1747 {
1748 BOOL ret = TRUE;
1749
1750 __TRY
1751 {
1752 ret = CRYPT_AsnDecodeUnicodeNameValueInternal(pbEncoded, cbEncoded,
1753 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
1754 if (ret && pvStructInfo)
1755 {
1756 ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
1757 pcbStructInfo, *pcbStructInfo);
1758 if (ret)
1759 {
1760 CERT_NAME_VALUE *value;
1761
1762 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
1763 pvStructInfo = *(BYTE **)pvStructInfo;
1764 value = (CERT_NAME_VALUE *)pvStructInfo;
1765 value->Value.pbData = ((BYTE *)value + sizeof(CERT_NAME_VALUE));
1766 ret = CRYPT_AsnDecodeUnicodeNameValueInternal(pbEncoded,
1767 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
1768 pcbStructInfo, NULL);
1769 }
1770 }
1771 }
1772 __EXCEPT_PAGE_FAULT
1773 {
1774 SetLastError(STATUS_ACCESS_VIOLATION);
1775 ret = FALSE;
1776 }
1777 __ENDTRY
1778 return ret;
1779 }
1780
1781 static BOOL CRYPT_AsnDecodeRdnAttr(const BYTE *pbEncoded, DWORD cbEncoded,
1782 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1783 {
1784 BOOL ret;
1785 struct AsnDecodeSequenceItem items[] = {
1786 { ASN_OBJECTIDENTIFIER, offsetof(CERT_RDN_ATTR, pszObjId),
1787 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
1788 offsetof(CERT_RDN_ATTR, pszObjId), 0 },
1789 { 0, offsetof(CERT_RDN_ATTR, dwValueType),
1790 CRYPT_AsnDecodeNameValueInternal, sizeof(CERT_NAME_VALUE),
1791 FALSE, TRUE, offsetof(CERT_RDN_ATTR, Value.pbData), 0 },
1792 };
1793 CERT_RDN_ATTR *attr = (CERT_RDN_ATTR *)pvStructInfo;
1794
1795 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1796 pvStructInfo, *pcbStructInfo);
1797
1798 if (attr)
1799 TRACE("attr->pszObjId is %p\n", attr->pszObjId);
1800 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
1801 pbEncoded, cbEncoded, dwFlags, NULL, attr, pcbStructInfo, pcbDecoded,
1802 attr ? attr->pszObjId : NULL);
1803 if (attr)
1804 {
1805 TRACE("attr->pszObjId is %p (%s)\n", attr->pszObjId,
1806 debugstr_a(attr->pszObjId));
1807 TRACE("attr->dwValueType is %d\n", attr->dwValueType);
1808 }
1809 TRACE("returning %d (%08x)\n", ret, GetLastError());
1810 return ret;
1811 }
1812
1813 static BOOL CRYPT_AsnDecodeRdn(const BYTE *pbEncoded, DWORD cbEncoded,
1814 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1815 {
1816 BOOL ret = TRUE;
1817 struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
1818 CRYPT_AsnDecodeRdnAttr, sizeof(CERT_RDN_ATTR), TRUE,
1819 offsetof(CERT_RDN_ATTR, pszObjId) };
1820 PCERT_RDN rdn = (PCERT_RDN)pvStructInfo;
1821
1822 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1823 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
1824 rdn ? rdn->rgRDNAttr : NULL);
1825 return ret;
1826 }
1827
1828 static BOOL WINAPI CRYPT_AsnDecodeName(DWORD dwCertEncodingType,
1829 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1830 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1831 {
1832 BOOL ret = TRUE;
1833
1834 __TRY
1835 {
1836 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1837 CRYPT_AsnDecodeRdn, sizeof(CERT_RDN), TRUE,
1838 offsetof(CERT_RDN, rgRDNAttr) };
1839
1840 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1841 pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
1842 }
1843 __EXCEPT_PAGE_FAULT
1844 {
1845 SetLastError(STATUS_ACCESS_VIOLATION);
1846 ret = FALSE;
1847 }
1848 __ENDTRY
1849 return ret;
1850 }
1851
1852 static BOOL CRYPT_AsnDecodeUnicodeRdnAttr(const BYTE *pbEncoded,
1853 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1854 DWORD *pcbDecoded)
1855 {
1856 BOOL ret;
1857 struct AsnDecodeSequenceItem items[] = {
1858 { ASN_OBJECTIDENTIFIER, offsetof(CERT_RDN_ATTR, pszObjId),
1859 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
1860 offsetof(CERT_RDN_ATTR, pszObjId), 0 },
1861 { 0, offsetof(CERT_RDN_ATTR, dwValueType),
1862 CRYPT_AsnDecodeUnicodeNameValueInternal, sizeof(CERT_NAME_VALUE),
1863 FALSE, TRUE, offsetof(CERT_RDN_ATTR, Value.pbData), 0 },
1864 };
1865 CERT_RDN_ATTR *attr = (CERT_RDN_ATTR *)pvStructInfo;
1866
1867 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1868 pvStructInfo, *pcbStructInfo);
1869
1870 if (attr)
1871 TRACE("attr->pszObjId is %p\n", attr->pszObjId);
1872 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
1873 pbEncoded, cbEncoded, dwFlags, NULL, attr, pcbStructInfo, pcbDecoded,
1874 attr ? attr->pszObjId : NULL);
1875 if (attr)
1876 {
1877 TRACE("attr->pszObjId is %p (%s)\n", attr->pszObjId,
1878 debugstr_a(attr->pszObjId));
1879 TRACE("attr->dwValueType is %d\n", attr->dwValueType);
1880 }
1881 TRACE("returning %d (%08x)\n", ret, GetLastError());
1882 return ret;
1883 }
1884
1885 static BOOL CRYPT_AsnDecodeUnicodeRdn(const BYTE *pbEncoded, DWORD cbEncoded,
1886 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1887 {
1888 BOOL ret = TRUE;
1889 struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
1890 CRYPT_AsnDecodeUnicodeRdnAttr, sizeof(CERT_RDN_ATTR), TRUE,
1891 offsetof(CERT_RDN_ATTR, pszObjId) };
1892 PCERT_RDN rdn = (PCERT_RDN)pvStructInfo;
1893
1894 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1895 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
1896 rdn ? rdn->rgRDNAttr : NULL);
1897 return ret;
1898 }
1899
1900 static BOOL WINAPI CRYPT_AsnDecodeUnicodeName(DWORD dwCertEncodingType,
1901 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1902 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1903 {
1904 BOOL ret = TRUE;
1905
1906 __TRY
1907 {
1908 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1909 CRYPT_AsnDecodeUnicodeRdn, sizeof(CERT_RDN), TRUE,
1910 offsetof(CERT_RDN, rgRDNAttr) };
1911
1912 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1913 pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
1914 }
1915 __EXCEPT_PAGE_FAULT
1916 {
1917 SetLastError(STATUS_ACCESS_VIOLATION);
1918 ret = FALSE;
1919 }
1920 __ENDTRY
1921 return ret;
1922 }
1923
1924 static BOOL CRYPT_FindEncodedLen(const BYTE *pbEncoded, DWORD cbEncoded,
1925 DWORD *pcbDecoded)
1926 {
1927 BOOL ret = TRUE, done = FALSE;
1928 DWORD indefiniteNestingLevels = 0, decoded = 0;
1929
1930 TRACE("(%p, %d)\n", pbEncoded, cbEncoded);
1931
1932 do {
1933 DWORD dataLen;
1934
1935 if (!cbEncoded)
1936 done = TRUE;
1937 else if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded,
1938 &dataLen)))
1939 {
1940 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1941
1942 if (dataLen == CMSG_INDEFINITE_LENGTH)
1943 {
1944 indefiniteNestingLevels++;
1945 pbEncoded += 1 + lenBytes;
1946 cbEncoded -= 1 + lenBytes;
1947 decoded += 1 + lenBytes;
1948 TRACE("indefiniteNestingLevels = %d\n",
1949 indefiniteNestingLevels);
1950 }
1951 else
1952 {
1953 if (pbEncoded[0] == 0 && pbEncoded[1] == 0 &&
1954 indefiniteNestingLevels)
1955 {
1956 indefiniteNestingLevels--;
1957 TRACE("indefiniteNestingLevels = %d\n",
1958 indefiniteNestingLevels);
1959 }
1960 pbEncoded += 1 + lenBytes + dataLen;
1961 cbEncoded -= 1 + lenBytes + dataLen;
1962 decoded += 1 + lenBytes + dataLen;
1963 if (!indefiniteNestingLevels)
1964 done = TRUE;
1965 }
1966 }
1967 } while (ret && !done);
1968 /* If we haven't found all 0 TLVs, we haven't found the end */
1969 if (ret && indefiniteNestingLevels)
1970 {
1971 SetLastError(CRYPT_E_ASN1_EOD);
1972 ret = FALSE;
1973 }
1974 if (ret)
1975 *pcbDecoded = decoded;
1976 TRACE("returning %d (%d)\n", ret, ret ? *pcbDecoded : 0);
1977 return ret;
1978 }
1979
1980 static BOOL CRYPT_AsnDecodeCopyBytes(const BYTE *pbEncoded,
1981 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1982 DWORD *pcbDecoded)
1983 {
1984 BOOL ret = TRUE;
1985 DWORD bytesNeeded = sizeof(CRYPT_OBJID_BLOB), encodedLen = 0;
1986
1987 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1988 pvStructInfo, *pcbStructInfo);
1989
1990 if ((ret = CRYPT_FindEncodedLen(pbEncoded, cbEncoded, &encodedLen)))
1991 {
1992 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1993 bytesNeeded += encodedLen;
1994 if (!pvStructInfo)
1995 *pcbStructInfo = bytesNeeded;
1996 else if (*pcbStructInfo < bytesNeeded)
1997 {
1998 SetLastError(ERROR_MORE_DATA);
1999 *pcbStructInfo = bytesNeeded;
2000 ret = FALSE;
2001 }
2002 else
2003 {
2004 PCRYPT_OBJID_BLOB blob = (PCRYPT_OBJID_BLOB)pvStructInfo;
2005
2006 *pcbStructInfo = bytesNeeded;
2007 blob->cbData = encodedLen;
2008 if (encodedLen)
2009 {
2010 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
2011 blob->pbData = (LPBYTE)pbEncoded;
2012 else
2013 {
2014 assert(blob->pbData);
2015 memcpy(blob->pbData, pbEncoded, blob->cbData);
2016 }
2017 }
2018 else
2019 blob->pbData = NULL;
2020 }
2021 if (pcbDecoded)
2022 *pcbDecoded = encodedLen;
2023 }
2024 return ret;
2025 }
2026
2027 static BOOL CRYPT_DecodeDERArray(const BYTE *pbEncoded, DWORD cbEncoded,
2028 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2029 {
2030 BOOL ret;
2031 struct AsnArrayDescriptor arrayDesc = { 0, CRYPT_AsnDecodeCopyBytes,
2032 sizeof(CRYPT_DER_BLOB), TRUE, offsetof(CRYPT_DER_BLOB, pbData) };
2033 struct GenericArray *array = (struct GenericArray *)pvStructInfo;
2034
2035 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
2036 pvStructInfo, *pcbStructInfo, pcbDecoded);
2037
2038 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2039 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2040 array ? array->rgItems : NULL);
2041 return ret;
2042 }
2043
2044 static BOOL CRYPT_AsnDecodeCTLUsage(const BYTE *pbEncoded, DWORD cbEncoded,
2045 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2046 {
2047 BOOL ret;
2048 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2049 CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), TRUE, 0 };
2050 CTL_USAGE *usage = (CTL_USAGE *)pvStructInfo;
2051
2052 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2053 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2054 usage ? usage->rgpszUsageIdentifier : NULL);
2055 return ret;
2056 }
2057
2058 static BOOL CRYPT_AsnDecodeCTLEntry(const BYTE *pbEncoded, DWORD cbEncoded,
2059 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2060 {
2061 struct AsnDecodeSequenceItem items[] = {
2062 { ASN_OCTETSTRING, offsetof(CTL_ENTRY, SubjectIdentifier),
2063 CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_DATA_BLOB), FALSE, TRUE,
2064 offsetof(CTL_ENTRY, SubjectIdentifier.pbData), 0 },
2065 { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CTL_ENTRY, cAttribute),
2066 CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES), FALSE,
2067 TRUE, offsetof(CTL_ENTRY, rgAttribute), 0 },
2068 };
2069 BOOL ret = TRUE;
2070 CTL_ENTRY *entry = (CTL_ENTRY *)pvStructInfo;
2071
2072 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, entry,
2073 *pcbStructInfo);
2074
2075 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2076 pbEncoded, cbEncoded, dwFlags, NULL, entry, pcbStructInfo,
2077 pcbDecoded, entry ? entry->SubjectIdentifier.pbData : NULL);
2078 return ret;
2079 }
2080
2081 static BOOL CRYPT_AsnDecodeCTLEntries(const BYTE *pbEncoded, DWORD cbEncoded,
2082 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2083 {
2084 BOOL ret;
2085 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2086 CRYPT_AsnDecodeCTLEntry, sizeof(CTL_ENTRY), TRUE,
2087 offsetof(CTL_ENTRY, SubjectIdentifier.pbData) };
2088 struct GenericArray *entries = (struct GenericArray *)pvStructInfo;
2089
2090 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
2091 pvStructInfo, *pcbStructInfo, pcbDecoded);
2092
2093 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2094 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2095 entries ? entries->rgItems : NULL);
2096 return ret;
2097 }
2098
2099 static BOOL WINAPI CRYPT_AsnDecodeCTL(DWORD dwCertEncodingType,
2100 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2101 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
2102 {
2103 BOOL ret = FALSE;
2104
2105 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2106 pDecodePara, pvStructInfo, *pcbStructInfo);
2107
2108 __TRY
2109 {
2110 struct AsnDecodeSequenceItem items[] = {
2111 { ASN_INTEGER, offsetof(CTL_INFO, dwVersion),
2112 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), TRUE, FALSE, 0, 0 },
2113 { ASN_SEQUENCEOF, offsetof(CTL_INFO, SubjectUsage),
2114 CRYPT_AsnDecodeCTLUsage, sizeof(CTL_USAGE), FALSE, TRUE,
2115 offsetof(CTL_INFO, SubjectUsage.rgpszUsageIdentifier), 0 },
2116 { ASN_OCTETSTRING, offsetof(CTL_INFO, ListIdentifier),
2117 CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_DATA_BLOB), TRUE,
2118 TRUE, offsetof(CTL_INFO, ListIdentifier.pbData), 0 },
2119 { ASN_INTEGER, offsetof(CTL_INFO, SequenceNumber),
2120 CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
2121 TRUE, TRUE, offsetof(CTL_INFO, SequenceNumber.pbData), 0 },
2122 { 0, offsetof(CTL_INFO, ThisUpdate),
2123 CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE,
2124 0 },
2125 { 0, offsetof(CTL_INFO, NextUpdate),
2126 CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), TRUE, FALSE,
2127 0 },
2128 { ASN_SEQUENCEOF, offsetof(CTL_INFO, SubjectAlgorithm),
2129 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
2130 FALSE, TRUE, offsetof(CTL_INFO, SubjectAlgorithm.pszObjId), 0 },
2131 { ASN_SEQUENCEOF, offsetof(CTL_INFO, cCTLEntry),
2132 CRYPT_AsnDecodeCTLEntries, sizeof(struct GenericArray),
2133 TRUE, TRUE, offsetof(CTL_INFO, rgCTLEntry), 0 },
2134 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CTL_INFO, cExtension),
2135 CRYPT_AsnDecodeCertExtensions, sizeof(CERT_EXTENSIONS), TRUE, TRUE,
2136 offsetof(CTL_INFO, rgExtension), 0 },
2137 };
2138
2139 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2140 pDecodePara, pvStructInfo, *pcbStructInfo);
2141
2142 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2143 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
2144 pcbStructInfo, NULL, NULL);
2145 }
2146 __EXCEPT_PAGE_FAULT
2147 {
2148 SetLastError(STATUS_ACCESS_VIOLATION);
2149 }
2150 __ENDTRY
2151 return ret;
2152 }
2153
2154 static BOOL CRYPT_AsnDecodeSMIMECapability(const BYTE *pbEncoded,
2155 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2156 DWORD *pcbDecoded)
2157 {
2158 BOOL ret;
2159 struct AsnDecodeSequenceItem items[] = {
2160 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_SMIME_CAPABILITY, pszObjId),
2161 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2162 offsetof(CRYPT_SMIME_CAPABILITY, pszObjId), 0 },
2163 { 0, offsetof(CRYPT_SMIME_CAPABILITY, Parameters),
2164 CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
2165 offsetof(CRYPT_SMIME_CAPABILITY, Parameters.pbData), 0 },
2166 };
2167 PCRYPT_SMIME_CAPABILITY capability = (PCRYPT_SMIME_CAPABILITY)pvStructInfo;
2168
2169 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2170 pvStructInfo, *pcbStructInfo);
2171
2172 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2173 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2174 pcbDecoded, capability ? capability->pszObjId : NULL);
2175 TRACE("returning %d\n", ret);
2176 return ret;
2177 }
2178
2179 static BOOL CRYPT_AsnDecodeSMIMECapabilitiesInternal(const BYTE *pbEncoded,
2180 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2181 DWORD *pcbDecoded)
2182 {
2183 struct AsnArrayDescriptor arrayDesc = { 0,
2184 CRYPT_AsnDecodeSMIMECapability, sizeof(CRYPT_SMIME_CAPABILITY), TRUE,
2185 offsetof(CRYPT_SMIME_CAPABILITY, pszObjId) };
2186 PCRYPT_SMIME_CAPABILITIES capabilities =
2187 (PCRYPT_SMIME_CAPABILITIES)pvStructInfo;
2188 BOOL ret;
2189
2190 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2191 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2192 capabilities ? capabilities->rgCapability : NULL);
2193 return ret;
2194 }
2195
2196 static BOOL WINAPI CRYPT_AsnDecodeSMIMECapabilities(DWORD dwCertEncodingType,
2197 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2198 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
2199 {
2200 BOOL ret = FALSE;
2201
2202 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2203 pDecodePara, pvStructInfo, *pcbStructInfo);
2204
2205 __TRY
2206 {
2207 DWORD bytesNeeded;
2208
2209 if (!cbEncoded)
2210 SetLastError(CRYPT_E_ASN1_EOD);
2211 else if (pbEncoded[0] != ASN_SEQUENCEOF)
2212 SetLastError(CRYPT_E_ASN1_CORRUPT);
2213 else if ((ret = CRYPT_AsnDecodeSMIMECapabilitiesInternal(pbEncoded,
2214 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded,
2215 NULL)))
2216 {
2217 if (!pvStructInfo)
2218 *pcbStructInfo = bytesNeeded;
2219 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2220 pvStructInfo, pcbStructInfo, bytesNeeded)))
2221 {
2222 PCRYPT_SMIME_CAPABILITIES capabilities;
2223
2224 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2225 pvStructInfo = *(BYTE **)pvStructInfo;
2226 capabilities = (PCRYPT_SMIME_CAPABILITIES)pvStructInfo;
2227 capabilities->rgCapability =
2228 (PCRYPT_SMIME_CAPABILITY)((BYTE *)pvStructInfo +
2229 sizeof(CRYPT_SMIME_CAPABILITIES));
2230 ret = CRYPT_AsnDecodeSMIMECapabilitiesInternal(pbEncoded,
2231 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
2232 &bytesNeeded, NULL);
2233 }
2234 }
2235 }
2236 __EXCEPT_PAGE_FAULT
2237 {
2238 SetLastError(STATUS_ACCESS_VIOLATION);
2239 }
2240 __ENDTRY
2241 TRACE("returning %d\n", ret);
2242 return ret;
2243 }
2244
2245 static BOOL CRYPT_AsnDecodeIA5String(const BYTE *pbEncoded,
2246 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2247 DWORD *pcbDecoded)
2248 {
2249 BOOL ret = TRUE;
2250 DWORD dataLen;
2251 LPSTR *pStr = pvStructInfo;
2252
2253 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2254 {
2255 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2256 DWORD bytesNeeded = sizeof(LPSTR) + sizeof(char);
2257
2258 if (pbEncoded[0] != ASN_IA5STRING)
2259 {
2260 SetLastError(CRYPT_E_ASN1_CORRUPT);
2261 ret = FALSE;
2262 }
2263 else
2264 {
2265 bytesNeeded += dataLen;
2266 if (pcbDecoded)
2267 *pcbDecoded = 1 + lenBytes + dataLen;
2268 if (!pvStructInfo)
2269 *pcbStructInfo = bytesNeeded;
2270 else if (*pcbStructInfo < bytesNeeded)
2271 {
2272 *pcbStructInfo = bytesNeeded;
2273 SetLastError(ERROR_MORE_DATA);
2274 ret = FALSE;
2275 }
2276 else
2277 {
2278 *pcbStructInfo = bytesNeeded;
2279 if (dataLen)
2280 {
2281 LPSTR str = *pStr;
2282
2283 assert(str);
2284 memcpy(str, pbEncoded + 1 + lenBytes, dataLen);
2285 str[dataLen] = 0;
2286 }
2287 else
2288 *pStr = NULL;
2289 }
2290 }
2291 }
2292 return ret;
2293 }
2294
2295 static BOOL CRYPT_AsnDecodeIntArray(const BYTE *pbEncoded,
2296 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2297 DWORD *pcbDecoded)
2298 {
2299 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2300 CRYPT_AsnDecodeIntInternal, sizeof(int), FALSE, 0 };
2301 struct GenericArray *array = pvStructInfo;
2302 BOOL ret;
2303
2304 TRACE("(%p, %d, %08x, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
2305 pvStructInfo, pvStructInfo ? *pcbDecoded : 0);
2306
2307 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2308 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2309 array ? array->rgItems : NULL);
2310 TRACE("returning %d\n", ret);
2311 return ret;
2312 }
2313
2314 static BOOL CRYPT_AsnDecodeNoticeReference(const BYTE *pbEncoded,
2315 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2316 DWORD *pcbDecoded)
2317 {
2318 BOOL ret;
2319 struct AsnDecodeSequenceItem items[] = {
2320 { ASN_IA5STRING, offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
2321 pszOrganization), CRYPT_AsnDecodeIA5String, sizeof(LPSTR), FALSE, TRUE,
2322 offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, pszOrganization), 0 },
2323 { ASN_SEQUENCEOF, offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
2324 cNoticeNumbers), CRYPT_AsnDecodeIntArray, sizeof(struct GenericArray),
2325 FALSE, TRUE, offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
2326 rgNoticeNumbers), 0 },
2327 };
2328 DWORD bytesNeeded;
2329
2330 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2331 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
2332
2333 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2334 pbEncoded, cbEncoded, dwFlags, NULL, NULL, &bytesNeeded, pcbDecoded,
2335 NULL);
2336 if (ret)
2337 {
2338 /* The caller is expecting a pointer to a
2339 * CERT_POLICY_QUALIFIER_NOTICE_REFERENCE to be decoded, whereas
2340 * CRYPT_AsnDecodeSequence is decoding a
2341 * CERT_POLICY_QUALIFIER_NOTICE_REFERENCE. Increment the bytes
2342 * needed, and decode again if the requisite space is available.
2343 */
2344 bytesNeeded += sizeof(PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE);
2345 if (!pvStructInfo)
2346 *pcbStructInfo = bytesNeeded;
2347 else if (*pcbStructInfo < bytesNeeded)
2348 {
2349 *pcbStructInfo = bytesNeeded;
2350 SetLastError(ERROR_MORE_DATA);
2351 ret = FALSE;
2352 }
2353 else
2354 {
2355 PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE noticeRef;
2356
2357 *pcbStructInfo = bytesNeeded;
2358 /* The pointer (pvStructInfo) passed in points to the first dynamic
2359 * pointer, so use it as the pointer to the
2360 * CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, and create the
2361 * appropriate offset for the first dynamic pointer within the
2362 * notice reference by pointing to the first memory location past
2363 * the CERT_POLICY_QUALIFIER_NOTICE_REFERENCE.
2364 */
2365 noticeRef =
2366 *(PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE *)pvStructInfo;
2367 noticeRef->pszOrganization = (LPSTR)((LPBYTE)noticeRef +
2368 sizeof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE));
2369 ret = CRYPT_AsnDecodeSequence(items,
2370 sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2371 NULL, noticeRef, &bytesNeeded, pcbDecoded,
2372 noticeRef->pszOrganization);
2373 }
2374 }
2375 TRACE("returning %d\n", ret);
2376 return ret;
2377 }
2378
2379 static BOOL CRYPT_AsnDecodeUnicodeString(const BYTE *pbEncoded,
2380 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2381 DWORD *pcbDecoded)
2382 {
2383 BOOL ret = TRUE;
2384 DWORD dataLen;
2385
2386 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2387 {
2388 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2389 DWORD bytesNeeded = sizeof(LPWSTR);
2390
2391 switch (pbEncoded[0])
2392 {
2393 case ASN_NUMERICSTRING:
2394 if (dataLen)
2395 bytesNeeded += (dataLen + 1) * 2;
2396 break;
2397 case ASN_PRINTABLESTRING:
2398 if (dataLen)
2399 bytesNeeded += (dataLen + 1) * 2;
2400 break;
2401 case ASN_IA5STRING:
2402 if (dataLen)
2403 bytesNeeded += (dataLen + 1) * 2;
2404 break;
2405 case ASN_T61STRING:
2406 if (dataLen)
2407 bytesNeeded += (dataLen + 1) * 2;
2408 break;
2409 case ASN_VIDEOTEXSTRING:
2410 if (dataLen)
2411 bytesNeeded += (dataLen + 1) * 2;
2412 break;
2413 case ASN_GRAPHICSTRING:
2414 if (dataLen)
2415 bytesNeeded += (dataLen + 1) * 2;
2416 break;
2417 case ASN_VISIBLESTRING:
2418 if (dataLen)
2419 bytesNeeded += (dataLen + 1) * 2;
2420 break;
2421 case ASN_GENERALSTRING:
2422 if (dataLen)
2423 bytesNeeded += (dataLen + 1) * 2;
2424 break;
2425 case ASN_UNIVERSALSTRING:
2426 if (dataLen)
2427 bytesNeeded += dataLen / 2 + sizeof(WCHAR);
2428 break;
2429 case ASN_BMPSTRING:
2430 if (dataLen)
2431 bytesNeeded += dataLen + sizeof(WCHAR);
2432 break;
2433 case ASN_UTF8STRING:
2434 if (dataLen)
2435 bytesNeeded += (MultiByteToWideChar(CP_UTF8, 0,
2436 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen, NULL, 0) + 1) * 2;
2437 break;
2438 default:
2439 SetLastError(CRYPT_E_ASN1_BADTAG);
2440 return FALSE;
2441 }
2442
2443 if (pcbDecoded)
2444 *pcbDecoded = 1 + lenBytes + dataLen;
2445 if (!pvStructInfo)
2446 *pcbStructInfo = bytesNeeded;
2447 else if (*pcbStructInfo < bytesNeeded)
2448 {
2449 *pcbStructInfo = bytesNeeded;
2450 SetLastError(ERROR_MORE_DATA);
2451 ret = FALSE;
2452 }
2453 else
2454 {
2455 LPWSTR *pStr = pvStructInfo;
2456
2457 *pcbStructInfo = bytesNeeded;
2458 if (dataLen)
2459 {
2460 DWORD i;
2461 LPWSTR str = *(LPWSTR *)pStr;
2462
2463 assert(str);
2464 switch (pbEncoded[0])
2465 {
2466 case ASN_NUMERICSTRING:
2467 case ASN_PRINTABLESTRING:
2468 case ASN_IA5STRING:
2469 case ASN_T61STRING:
2470 case ASN_VIDEOTEXSTRING:
2471 case ASN_GRAPHICSTRING:
2472 case ASN_VISIBLESTRING:
2473 case ASN_GENERALSTRING:
2474 for (i = 0; i < dataLen; i++)
2475 str[i] = pbEncoded[1 + lenBytes + i];
2476 str[i] = 0;
2477 break;
2478 case ASN_UNIVERSALSTRING:
2479 for (i = 0; i < dataLen / 4; i++)
2480 str[i] = (pbEncoded[1 + lenBytes + 2 * i + 2] << 8)
2481 | pbEncoded[1 + lenBytes + 2 * i + 3];
2482 str[i] = 0;
2483 break;
2484 case ASN_BMPSTRING:
2485 for (i = 0; i < dataLen / 2; i++)
2486 str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
2487 pbEncoded[1 + lenBytes + 2 * i + 1];
2488 str[i] = 0;
2489 break;
2490 case ASN_UTF8STRING:
2491 {
2492 int len = MultiByteToWideChar(CP_UTF8, 0,
2493 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen,
2494 str, bytesNeeded - sizeof(CERT_NAME_VALUE)) * 2;
2495 str[len] = 0;
2496 break;
2497 }
2498 }
2499 }
2500 else
2501 *pStr = NULL;
2502 }
2503 }
2504 return ret;
2505 }
2506
2507 static BOOL CRYPT_AsnDecodePolicyQualifierUserNoticeInternal(
2508 const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo,
2509 DWORD *pcbStructInfo, DWORD *pcbDecoded)
2510 {
2511 BOOL ret;
2512 struct AsnDecodeSequenceItem items[] = {
2513 { ASN_SEQUENCE, offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE,
2514 pNoticeReference), CRYPT_AsnDecodeNoticeReference,
2515 sizeof(PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE), TRUE, TRUE,
2516 offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE, pNoticeReference), 0 },
2517 { 0, offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE, pszDisplayText),
2518 CRYPT_AsnDecodeUnicodeString, sizeof(LPWSTR), TRUE, TRUE,
2519 offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE, pszDisplayText), 0 },
2520 };
2521 PCERT_POLICY_QUALIFIER_USER_NOTICE notice = pvStructInfo;
2522
2523 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2524 pvStructInfo, *pcbStructInfo);
2525
2526 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2527 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2528 pcbDecoded, notice ? notice->pNoticeReference : NULL);
2529 TRACE("returning %d\n", ret);
2530 return ret;
2531 }
2532
2533 static BOOL WINAPI CRYPT_AsnDecodePolicyQualifierUserNotice(
2534 DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded,
2535 DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
2536 void *pvStructInfo, DWORD *pcbStructInfo)
2537 {
2538 BOOL ret = FALSE;
2539
2540 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2541 pDecodePara, pvStructInfo, *pcbStructInfo);
2542
2543 __TRY
2544 {
2545 DWORD bytesNeeded;
2546
2547 ret = CRYPT_AsnDecodePolicyQualifierUserNoticeInternal(pbEncoded,
2548 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded,
2549 NULL);
2550 if (ret)
2551 {
2552 if (!pvStructInfo)
2553 *pcbStructInfo = bytesNeeded;
2554 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2555 pvStructInfo, pcbStructInfo, bytesNeeded)))
2556 {
2557 PCERT_POLICY_QUALIFIER_USER_NOTICE notice;
2558
2559 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2560 pvStructInfo = *(BYTE **)pvStructInfo;
2561 notice = pvStructInfo;
2562 notice->pNoticeReference =
2563 (PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE)
2564 ((BYTE *)pvStructInfo +
2565 sizeof(CERT_POLICY_QUALIFIER_USER_NOTICE));
2566 ret = CRYPT_AsnDecodePolicyQualifierUserNoticeInternal(
2567 pbEncoded, cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
2568 pvStructInfo, &bytesNeeded, NULL);
2569 }
2570 }
2571 }
2572 __EXCEPT_PAGE_FAULT
2573 {
2574 SetLastError(STATUS_ACCESS_VIOLATION);
2575 }
2576 __ENDTRY
2577 TRACE("returning %d\n", ret);
2578 return ret;
2579 }
2580
2581 static BOOL CRYPT_AsnDecodePKCSAttributeInternal(const BYTE *pbEncoded,
2582 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2583 DWORD *pcbDecoded)
2584 {
2585 BOOL ret;
2586 struct AsnDecodeSequenceItem items[] = {
2587 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ATTRIBUTE, pszObjId),
2588 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2589 offsetof(CRYPT_ATTRIBUTE, pszObjId), 0 },
2590 { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CRYPT_ATTRIBUTE, cValue),
2591 CRYPT_DecodeDERArray, sizeof(struct GenericArray), FALSE, TRUE,
2592 offsetof(CRYPT_ATTRIBUTE, rgValue), 0 },
2593 };
2594 PCRYPT_ATTRIBUTE attr = (PCRYPT_ATTRIBUTE)pvStructInfo;
2595
2596 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2597 pvStructInfo, *pcbStructInfo);
2598
2599 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2600 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2601 pcbDecoded, attr ? attr->pszObjId : NULL);
2602 TRACE("returning %d\n", ret);
2603 return ret;
2604 }
2605
2606 static BOOL WINAPI CRYPT_AsnDecodePKCSAttribute(DWORD dwCertEncodingType,
2607 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2608 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
2609 {
2610 BOOL ret = FALSE;
2611
2612 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2613 pDecodePara, pvStructInfo, *pcbStructInfo);
2614
2615 __TRY
2616 {
2617 DWORD bytesNeeded;
2618
2619 ret = CRYPT_AsnDecodePKCSAttributeInternal(pbEncoded, cbEncoded,
2620 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
2621 if (ret)
2622 {
2623 if (!pvStructInfo)
2624 *pcbStructInfo = bytesNeeded;
2625 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2626 pvStructInfo, pcbStructInfo, bytesNeeded)))
2627 {
2628 PCRYPT_ATTRIBUTE attr;
2629
2630 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2631 pvStructInfo = *(BYTE **)pvStructInfo;
2632 attr = (PCRYPT_ATTRIBUTE)pvStructInfo;
2633 attr->pszObjId = (LPSTR)((BYTE *)pvStructInfo +
2634 sizeof(CRYPT_ATTRIBUTE));
2635 ret = CRYPT_AsnDecodePKCSAttributeInternal(pbEncoded, cbEncoded,
2636 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo, &bytesNeeded,
2637 NULL);
2638 }
2639 }
2640 }
2641 __EXCEPT_PAGE_FAULT
2642 {
2643 SetLastError(STATUS_ACCESS_VIOLATION);
2644 }
2645 __ENDTRY
2646 TRACE("returning %d\n", ret);
2647 return ret;
2648 }
2649
2650 static BOOL CRYPT_AsnDecodePKCSAttributesInternal(const BYTE *pbEncoded,
2651 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2652 DWORD *pcbDecoded)
2653 {
2654 struct AsnArrayDescriptor arrayDesc = { 0,
2655 CRYPT_AsnDecodePKCSAttributeInternal, sizeof(CRYPT_ATTRIBUTE), TRUE,
2656 offsetof(CRYPT_ATTRIBUTE, pszObjId) };
2657 PCRYPT_ATTRIBUTES attrs = (PCRYPT_ATTRIBUTES)pvStructInfo;
2658 BOOL ret;
2659
2660 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2661 NULL, pvStructInfo, pcbStructInfo, pcbDecoded, attrs ? attrs->rgAttr :
2662 NULL);
2663 return ret;
2664 }
2665
2666 static BOOL WINAPI CRYPT_AsnDecodePKCSAttributes(DWORD dwCertEncodingType,
2667 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2668 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
2669 {
2670 BOOL ret = FALSE;
2671
2672 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2673 pDecodePara, pvStructInfo, *pcbStructInfo);
2674
2675 __TRY
2676 {
2677 DWORD bytesNeeded;
2678
2679 if (!cbEncoded)
2680 SetLastError(CRYPT_E_ASN1_EOD);
2681 else if (pbEncoded[0] != (ASN_CONSTRUCTOR | ASN_SETOF))
2682 SetLastError(CRYPT_E_ASN1_CORRUPT);
2683 else if ((ret = CRYPT_AsnDecodePKCSAttributesInternal(pbEncoded,
2684 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded,
2685 NULL)))
2686 {
2687 if (!pvStructInfo)
2688 *pcbStructInfo = bytesNeeded;
2689 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2690 pvStructInfo, pcbStructInfo, bytesNeeded)))
2691 {
2692 PCRYPT_ATTRIBUTES attrs;
2693
2694 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2695 pvStructInfo = *(BYTE **)pvStructInfo;
2696 attrs = (PCRYPT_ATTRIBUTES)pvStructInfo;
2697 attrs->rgAttr = (PCRYPT_ATTRIBUTE)((BYTE *)pvStructInfo +
2698 sizeof(CRYPT_ATTRIBUTES));
2699 ret = CRYPT_AsnDecodePKCSAttributesInternal(pbEncoded,
2700 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
2701 &bytesNeeded, NULL);
2702 }
2703 }
2704 }
2705 __EXCEPT_PAGE_FAULT
2706 {
2707 SetLastError(STATUS_ACCESS_VIOLATION);
2708 }
2709 __ENDTRY
2710 TRACE("returning %d\n", ret);
2711 return ret;
2712 }
2713
2714 static BOOL CRYPT_AsnDecodeAlgorithmId(const BYTE *pbEncoded, DWORD cbEncoded,
2715 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2716 {
2717 CRYPT_ALGORITHM_IDENTIFIER *algo =
2718 (CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
2719 BOOL ret = TRUE;
2720 struct AsnDecodeSequenceItem items[] = {
2721 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId),
2722 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2723 offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId), 0 },
2724 { 0, offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters),
2725 CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
2726 offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters.pbData), 0 },
2727 };
2728
2729 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
2730 pvStructInfo, *pcbStructInfo, pcbDecoded);
2731
2732 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2733 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2734 pcbDecoded, algo ? algo->pszObjId : NULL);
2735 if (ret && pvStructInfo)
2736 {
2737 TRACE("pszObjId is %p (%s)\n", algo->pszObjId,
2738 debugstr_a(algo->pszObjId));
2739 }
2740 return ret;
2741 }
2742
2743 static BOOL CRYPT_AsnDecodePubKeyInfoInternal(const BYTE *pbEncoded,
2744 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2745 DWORD *pcbDecoded)
2746 {
2747 BOOL ret = TRUE;
2748 struct AsnDecodeSequenceItem items[] = {
2749 { ASN_SEQUENCEOF, offsetof(CERT_PUBLIC_KEY_INFO, Algorithm),
2750 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
2751 FALSE, TRUE, offsetof(CERT_PUBLIC_KEY_INFO,
2752 Algorithm.pszObjId) },
2753 { ASN_BITSTRING, offsetof(CERT_PUBLIC_KEY_INFO, PublicKey),
2754 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), FALSE, TRUE,
2755 offsetof(CERT_PUBLIC_KEY_INFO, PublicKey.pbData) },
2756 };
2757 PCERT_PUBLIC_KEY_INFO info = (PCERT_PUBLIC_KEY_INFO)pvStructInfo;
2758
2759 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2760 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2761 pcbDecoded, info ? info->Algorithm.Parameters.pbData : NULL);
2762 return ret;
2763 }
2764
2765 static BOOL WINAPI CRYPT_AsnDecodePubKeyInfo(DWORD dwCertEncodingType,
2766 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2767 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
2768 {
2769 BOOL ret = TRUE;
2770
2771 __TRY
2772 {
2773 DWORD bytesNeeded;
2774
2775 if ((ret = CRYPT_AsnDecodePubKeyInfoInternal(pbEncoded, cbEncoded,
2776 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
2777 {
2778 if (!pvStructInfo)
2779 *pcbStructInfo = bytesNeeded;
2780 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2781 pvStructInfo, pcbStructInfo, bytesNeeded)))
2782 {
2783 PCERT_PUBLIC_KEY_INFO info;
2784
2785 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2786 pvStructInfo = *(BYTE **)pvStructInfo;
2787 info = (PCERT_PUBLIC_KEY_INFO)pvStructInfo;
2788 info->Algorithm.Parameters.pbData = (BYTE *)pvStructInfo +
2789 sizeof(CERT_PUBLIC_KEY_INFO);
2790 ret = CRYPT_AsnDecodePubKeyInfoInternal(pbEncoded, cbEncoded,
2791 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
2792 &bytesNeeded, NULL);
2793 }
2794 }
2795 }
2796 __EXCEPT_PAGE_FAULT
2797 {
2798 SetLastError(STATUS_ACCESS_VIOLATION);
2799 ret = FALSE;
2800 }
2801 __ENDTRY
2802 return ret;
2803 }
2804
2805 static BOOL CRYPT_AsnDecodeBool(const BYTE *pbEncoded, DWORD cbEncoded,
2806 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2807 {
2808 BOOL ret;
2809
2810 if (cbEncoded < 3)
2811 {
2812 SetLastError(CRYPT_E_ASN1_CORRUPT);
2813 return FALSE;
2814 }
2815 if (GET_LEN_BYTES(pbEncoded[1]) > 1)
2816 {
2817 SetLastError(CRYPT_E_ASN1_CORRUPT);
2818 return FALSE;
2819 }
2820 if (pbEncoded[1] > 1)
2821 {
2822 SetLastError(CRYPT_E_ASN1_CORRUPT);
2823 return FALSE;
2824 }
2825 if (pcbDecoded)
2826 *pcbDecoded = 3;
2827 if (!pvStructInfo)
2828 {
2829 *pcbStructInfo = sizeof(BOOL);
2830 ret = TRUE;
2831 }
2832 else if (*pcbStructInfo < sizeof(BOOL))
2833 {
2834 *pcbStructInfo = sizeof(BOOL);
2835 SetLastError(ERROR_MORE_DATA);
2836 ret = FALSE;
2837 }
2838 else
2839 {
2840 *pcbStructInfo = sizeof(BOOL);
2841 *(BOOL *)pvStructInfo = pbEncoded[2] ? TRUE : FALSE;
2842 ret = TRUE;
2843 }
2844 TRACE("returning %d (%08x)\n", ret, GetLastError());
2845 return ret;
2846 }
2847
2848 static BOOL CRYPT_AsnDecodeAltNameEntry(const BYTE *pbEncoded, DWORD cbEncoded,
2849 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2850 {
2851 PCERT_ALT_NAME_ENTRY entry = (PCERT_ALT_NAME_ENTRY)pvStructInfo;
2852 DWORD dataLen, lenBytes, bytesNeeded = sizeof(CERT_ALT_NAME_ENTRY);
2853 BOOL ret;
2854
2855 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2856 pvStructInfo, *pcbStructInfo);
2857
2858 if (cbEncoded < 2)
2859 {
2860 SetLastError(CRYPT_E_ASN1_CORRUPT);
2861 return FALSE;
2862 }
2863 lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2864 if (1 + lenBytes > cbEncoded)
2865 {
2866 SetLastError(CRYPT_E_ASN1_CORRUPT);
2867 return FALSE;
2868 }
2869 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2870 {
2871 switch (pbEncoded[0] & ASN_TYPE_MASK)
2872 {
2873 case 1: /* rfc822Name */
2874 case 2: /* dNSName */
2875 case 6: /* uniformResourceIdentifier */
2876 bytesNeeded += (dataLen + 1) * sizeof(WCHAR);
2877 break;
2878 case 4: /* directoryName */
2879 case 7: /* iPAddress */
2880 bytesNeeded += dataLen;
2881 break;
2882 case 8: /* registeredID */
2883 ret = CRYPT_AsnDecodeOidIgnoreTag(pbEncoded, cbEncoded, 0, NULL,
2884 &dataLen, NULL);
2885 if (ret)
2886 {
2887 /* FIXME: ugly, shouldn't need to know internals of OID decode
2888 * function to use it.
2889 */
2890 bytesNeeded += dataLen - sizeof(LPSTR);
2891 }
2892 break;
2893 case 0: /* otherName */
2894 FIXME("%d: stub\n", pbEncoded[0] & ASN_TYPE_MASK);
2895 SetLastError(CRYPT_E_ASN1_BADTAG);
2896 ret = FALSE;
2897 break;
2898 case 3: /* x400Address, unimplemented */
2899 case 5: /* ediPartyName, unimplemented */
2900 TRACE("type %d unimplemented\n", pbEncoded[0] & ASN_TYPE_MASK);
2901 SetLastError(CRYPT_E_ASN1_BADTAG);
2902 ret = FALSE;
2903 break;
2904 default:
2905 TRACE("type %d bad\n", pbEncoded[0] & ASN_TYPE_MASK);
2906 SetLastError(CRYPT_E_ASN1_CORRUPT);
2907 ret = FALSE;
2908 }
2909 if (ret)
2910 {
2911 if (pcbDecoded)
2912 *pcbDecoded = 1 + lenBytes + dataLen;
2913 if (!entry)
2914 *pcbStructInfo = bytesNeeded;
2915 else if (*pcbStructInfo < bytesNeeded)
2916 {
2917 *pcbStructInfo = bytesNeeded;
2918 SetLastError(ERROR_MORE_DATA);
2919 ret = FALSE;
2920 }
2921 else
2922 {
2923 *pcbStructInfo = bytesNeeded;
2924 /* MS used values one greater than the asn1 ones.. sigh */
2925 entry->dwAltNameChoice = (pbEncoded[0] & ASN_TYPE_MASK) + 1;
2926 switch (pbEncoded[0] & ASN_TYPE_MASK)
2927 {
2928 case 1: /* rfc822Name */
2929 case 2: /* dNSName */
2930 case 6: /* uniformResourceIdentifier */
2931 {
2932 DWORD i;
2933
2934 for (i = 0; i < dataLen; i++)
2935 entry->u.pwszURL[i] =
2936 (WCHAR)pbEncoded[1 + lenBytes + i];
2937 entry->u.pwszURL[i] = 0;
2938 TRACE("URL is %p (%s)\n", entry->u.pwszURL,
2939 debugstr_w(entry->u.pwszURL));
2940 break;
2941 }
2942 case 4: /* directoryName */
2943 /* The data are memory-equivalent with the IPAddress case,
2944 * fall-through
2945 */
2946 case 7: /* iPAddress */
2947 /* The next data pointer is in the pwszURL spot, that is,
2948 * the first 4 bytes. Need to move it to the next spot.
2949 */
2950 entry->u.IPAddress.pbData = (LPBYTE)entry->u.pwszURL;
2951 entry->u.IPAddress.cbData = dataLen;
2952 memcpy(entry->u.IPAddress.pbData, pbEncoded + 1 + lenBytes,
2953 dataLen);
2954 break;
2955 case 8: /* registeredID */
2956 ret = CRYPT_AsnDecodeOidIgnoreTag(pbEncoded, cbEncoded, 0,
2957 &entry->u.pszRegisteredID, &dataLen, NULL);
2958 break;
2959 }
2960 }
2961 }
2962 }
2963 return ret;
2964 }
2965
2966 static BOOL CRYPT_AsnDecodeAltNameInternal(const BYTE *pbEncoded,
2967 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2968 DWORD *pcbDecoded)
2969 {
2970 BOOL ret = TRUE;
2971 struct AsnArrayDescriptor arrayDesc = { 0,
2972 CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), TRUE,
2973 offsetof(CERT_ALT_NAME_ENTRY, u.pwszURL) };
2974 PCERT_ALT_NAME_INFO info = (PCERT_ALT_NAME_INFO)pvStructInfo;
2975
2976 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
2977 pvStructInfo, *pcbStructInfo, pcbDecoded);
2978
2979 if (info)
2980 TRACE("info->rgAltEntry is %p\n", info->rgAltEntry);
2981 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2982 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2983 info ? info->rgAltEntry : NULL);
2984 return ret;
2985 }
2986
2987 /* Like CRYPT_AsnDecodeIntegerInternal, but swaps the bytes */
2988 static BOOL CRYPT_AsnDecodeIntegerSwapBytes(const BYTE *pbEncoded,
2989 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2990 DWORD *pcbDecoded)
2991 {
2992 BOOL ret;
2993
2994 TRACE("(%p, %d, 0x%08x, %p, %d, %p)\n", pbEncoded, cbEncoded, dwFlags,
2995 pvStructInfo, *pcbStructInfo, pcbDecoded);
2996
2997 /* Can't use the CRYPT_DECODE_NOCOPY_FLAG, because we modify the bytes in-
2998 * place.
2999 */
3000 ret = CRYPT_AsnDecodeIntegerInternal(pbEncoded, cbEncoded,
3001 dwFlags & ~CRYPT_DECODE_NOCOPY_FLAG, pvStructInfo, pcbStructInfo,
3002 pcbDecoded);
3003 if (ret && pvStructInfo)
3004 {
3005 CRYPT_DATA_BLOB *blob = (CRYPT_DATA_BLOB *)pvStructInfo;
3006
3007 if (blob->cbData)
3008 {
3009 DWORD i;
3010 BYTE temp;
3011
3012 for (i = 0; i < blob->cbData / 2; i++)
3013 {
3014 temp = blob->pbData[i];
3015 blob->pbData[i] = blob->pbData[blob->cbData - i - 1];
3016 blob->pbData[blob->cbData - i - 1] = temp;
3017 }
3018 }
3019 }
3020 TRACE("returning %d (%08x)\n", ret, GetLastError());
3021 return ret;
3022 }
3023
3024 static BOOL WINAPI CRYPT_AsnDecodeAuthorityKeyId(DWORD dwCertEncodingType,
3025 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3026 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3027 {
3028 BOOL ret;
3029
3030 __TRY
3031 {
3032 struct AsnDecodeSequenceItem items[] = {
3033 { ASN_CONTEXT | 0, offsetof(CERT_AUTHORITY_KEY_ID_INFO, KeyId),
3034 CRYPT_AsnDecodeIntegerSwapBytes, sizeof(CRYPT_DATA_BLOB),
3035 TRUE, TRUE, offsetof(CERT_AUTHORITY_KEY_ID_INFO, KeyId.pbData), 0 },
3036 { ASN_CONTEXT | ASN_CONSTRUCTOR| 1,
3037 offsetof(CERT_AUTHORITY_KEY_ID_INFO, CertIssuer),
3038 CRYPT_AsnDecodeOctetsInternal, sizeof(CERT_NAME_BLOB), TRUE, TRUE,
3039 offsetof(CERT_AUTHORITY_KEY_ID_INFO, CertIssuer.pbData), 0 },
3040 { ASN_CONTEXT | 2, offsetof(CERT_AUTHORITY_KEY_ID_INFO,
3041 CertSerialNumber), CRYPT_AsnDecodeIntegerInternal,
3042 sizeof(CRYPT_INTEGER_BLOB), TRUE, TRUE,
3043 offsetof(CERT_AUTHORITY_KEY_ID_INFO, CertSerialNumber.pbData), 0 },
3044 };
3045
3046 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3047 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3048 pcbStructInfo, NULL, NULL);
3049 }
3050 __EXCEPT_PAGE_FAULT
3051 {
3052 SetLastError(STATUS_ACCESS_VIOLATION);
3053 ret = FALSE;
3054 }
3055 __ENDTRY
3056 return ret;
3057 }
3058
3059 static BOOL WINAPI CRYPT_AsnDecodeAuthorityKeyId2(DWORD dwCertEncodingType,
3060 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3061 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3062 {
3063 BOOL ret;
3064
3065 __TRY
3066 {
3067 struct AsnDecodeSequenceItem items[] = {
3068 { ASN_CONTEXT | 0, offsetof(CERT_AUTHORITY_KEY_ID2_INFO, KeyId),
3069 CRYPT_AsnDecodeIntegerSwapBytes, sizeof(CRYPT_DATA_BLOB),
3070 TRUE, TRUE, offsetof(CERT_AUTHORITY_KEY_ID2_INFO, KeyId.pbData), 0 },
3071 { ASN_CONTEXT | ASN_CONSTRUCTOR| 1,
3072 offsetof(CERT_AUTHORITY_KEY_ID2_INFO, AuthorityCertIssuer),
3073 CRYPT_AsnDecodeAltNameInternal, sizeof(CERT_ALT_NAME_INFO), TRUE,
3074 TRUE, offsetof(CERT_AUTHORITY_KEY_ID2_INFO,
3075 AuthorityCertIssuer.rgAltEntry), 0 },
3076 { ASN_CONTEXT | 2, offsetof(CERT_AUTHORITY_KEY_ID2_INFO,
3077 AuthorityCertSerialNumber), CRYPT_AsnDecodeIntegerInternal,
3078 sizeof(CRYPT_INTEGER_BLOB), TRUE, TRUE,
3079 offsetof(CERT_AUTHORITY_KEY_ID2_INFO,
3080 AuthorityCertSerialNumber.pbData), 0 },
3081 };
3082
3083 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3084 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3085 pcbStructInfo, NULL, NULL);
3086 }
3087 __EXCEPT_PAGE_FAULT
3088 {
3089 SetLastError(STATUS_ACCESS_VIOLATION);
3090 ret = FALSE;
3091 }
3092 __ENDTRY
3093 return ret;
3094 }
3095
3096 static BOOL CRYPT_AsnDecodeAccessDescription(const BYTE *pbEncoded,
3097 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3098 DWORD *pcbDecoded)
3099 {
3100 struct AsnDecodeSequenceItem items[] = {
3101 { 0, offsetof(CERT_ACCESS_DESCRIPTION, pszAccessMethod),
3102 CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), FALSE, TRUE,
3103 offsetof(CERT_ACCESS_DESCRIPTION, pszAccessMethod), 0 },
3104 { 0, offsetof(CERT_ACCESS_DESCRIPTION, AccessLocation),
3105 CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), FALSE,
3106 TRUE, offsetof(CERT_ACCESS_DESCRIPTION, AccessLocation.u.pwszURL), 0 },
3107 };
3108 CERT_ACCESS_DESCRIPTION *descr = (CERT_ACCESS_DESCRIPTION *)pvStructInfo;
3109
3110 return CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3111 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3112 pcbDecoded, descr ? descr->pszAccessMethod : NULL);
3113 }
3114
3115 static BOOL WINAPI CRYPT_AsnDecodeAuthorityInfoAccess(DWORD dwCertEncodingType,
3116 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3117 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3118 {
3119 BOOL ret;
3120
3121 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3122 pDecodePara, pvStructInfo, *pcbStructInfo);
3123
3124 __TRY
3125 {
3126 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3127 CRYPT_AsnDecodeAccessDescription, sizeof(CERT_ACCESS_DESCRIPTION),
3128 TRUE, offsetof(CERT_ACCESS_DESCRIPTION, pszAccessMethod) };
3129
3130 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
3131 pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
3132 }
3133 __EXCEPT_PAGE_FAULT
3134 {
3135 SetLastError(STATUS_ACCESS_VIOLATION);
3136 ret = FALSE;
3137 }
3138 __ENDTRY
3139 return ret;
3140 }
3141
3142 static BOOL CRYPT_AsnDecodePKCSContent(const BYTE *pbEncoded, DWORD cbEncoded,
3143 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
3144 {
3145 BOOL ret;
3146 DWORD dataLen;
3147
3148 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
3149 pvStructInfo, *pcbStructInfo, pcbDecoded);
3150
3151 /* The caller has already checked the tag, no need to check it again.
3152 * Check the outer length is valid:
3153 */
3154 if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
3155 {
3156 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
3157 DWORD innerLen;
3158
3159 pbEncoded += 1 + lenBytes;
3160 cbEncoded -= 1 + lenBytes;
3161 if (dataLen == CMSG_INDEFINITE_LENGTH)
3162 cbEncoded -= 2; /* space for 0 TLV */
3163 /* Check the inner length is valid: */
3164 if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &innerLen)))
3165 {
3166 DWORD decodedLen;
3167
3168 ret = CRYPT_AsnDecodeCopyBytes(pbEncoded, cbEncoded, dwFlags,
3169 pvStructInfo, pcbStructInfo, &decodedLen);
3170 if (dataLen == CMSG_INDEFINITE_LENGTH)
3171 {
3172 if (*(pbEncoded + decodedLen) != 0 ||
3173 *(pbEncoded + decodedLen + 1) != 0)
3174 {
3175 TRACE("expected 0 TLV, got {%02x,%02x}\n",
3176 *(pbEncoded + decodedLen),
3177 *(pbEncoded + decodedLen + 1));
3178 SetLastError(CRYPT_E_ASN1_CORRUPT);
3179 ret = FALSE;
3180 }
3181 else
3182 decodedLen += 2;
3183 }
3184 if (ret && pcbDecoded)
3185 {
3186 *pcbDecoded = 1 + lenBytes + decodedLen;
3187 TRACE("decoded %d bytes\n", *pcbDecoded);
3188 }
3189 }
3190 }
3191 return ret;
3192 }
3193
3194 static BOOL CRYPT_AsnDecodePKCSContentInfoInternal(const BYTE *pbEncoded,
3195 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3196 DWORD *pcbDecoded)
3197 {
3198 CRYPT_CONTENT_INFO *info = (CRYPT_CONTENT_INFO *)pvStructInfo;
3199 struct AsnDecodeSequenceItem items[] = {
3200 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_CONTENT_INFO, pszObjId),
3201 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
3202 offsetof(CRYPT_CONTENT_INFO, pszObjId), 0 },
3203 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0,
3204 offsetof(CRYPT_CONTENT_INFO, Content), CRYPT_AsnDecodePKCSContent,
3205 sizeof(CRYPT_DER_BLOB), TRUE, TRUE,
3206 offsetof(CRYPT_CONTENT_INFO, Content.pbData), 0 },
3207 };
3208 BOOL ret;
3209
3210 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
3211 pvStructInfo, *pcbStructInfo, pcbDecoded);
3212
3213 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3214 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3215 pcbDecoded, info ? info->pszObjId : NULL);
3216 return ret;
3217 }
3218
3219 static BOOL WINAPI CRYPT_AsnDecodePKCSContentInfo(DWORD dwCertEncodingType,
3220 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3221 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3222 {
3223 BOOL ret = FALSE;
3224
3225 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3226 pDecodePara, pvStructInfo, *pcbStructInfo);
3227
3228 __TRY
3229 {
3230 ret = CRYPT_AsnDecodePKCSContentInfoInternal(pbEncoded, cbEncoded,
3231 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
3232 if (ret && pvStructInfo)
3233 {
3234 ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
3235 pcbStructInfo, *pcbStructInfo);
3236 if (ret)
3237 {
3238 CRYPT_CONTENT_INFO *info;
3239
3240 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3241 pvStructInfo = *(BYTE **)pvStructInfo;
3242 info = (CRYPT_CONTENT_INFO *)pvStructInfo;
3243 info->pszObjId = (LPSTR)((BYTE *)info +
3244 sizeof(CRYPT_CONTENT_INFO));
3245 ret = CRYPT_AsnDecodePKCSContentInfoInternal(pbEncoded,
3246 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3247 pcbStructInfo, NULL);
3248 }
3249 }
3250 }
3251 __EXCEPT_PAGE_FAULT
3252 {
3253 SetLastError(STATUS_ACCESS_VIOLATION);
3254 }
3255 __ENDTRY
3256 return ret;
3257 }
3258
3259 BOOL CRYPT_AsnDecodePKCSDigestedData(const BYTE *pbEncoded, DWORD cbEncoded,
3260 DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
3261 CRYPT_DIGESTED_DATA *digestedData, DWORD *pcbDigestedData)
3262 {
3263 BOOL ret;
3264 struct AsnDecodeSequenceItem items[] = {
3265 { ASN_INTEGER, offsetof(CRYPT_DIGESTED_DATA, version),
3266 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
3267 { ASN_SEQUENCEOF, offsetof(CRYPT_DIGESTED_DATA, DigestAlgorithm),
3268 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
3269 FALSE, TRUE, offsetof(CRYPT_DIGESTED_DATA, DigestAlgorithm.pszObjId),
3270 0 },
3271 { ASN_SEQUENCEOF, offsetof(CRYPT_DIGESTED_DATA, ContentInfo),
3272 CRYPT_AsnDecodePKCSContentInfoInternal,
3273 sizeof(CRYPT_CONTENT_INFO), FALSE, TRUE, offsetof(CRYPT_DIGESTED_DATA,
3274 ContentInfo.pszObjId), 0 },
3275 { ASN_OCTETSTRING, offsetof(CRYPT_DIGESTED_DATA, hash),
3276 CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_HASH_BLOB), FALSE, TRUE,
3277 offsetof(CRYPT_DIGESTED_DATA, hash.pbData), 0 },
3278 };
3279
3280 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3281 pbEncoded, cbEncoded, dwFlags, pDecodePara, digestedData, pcbDigestedData,
3282 NULL, NULL);
3283 return ret;
3284 }
3285
3286 static BOOL WINAPI CRYPT_AsnDecodeAltName(DWORD dwCertEncodingType,
3287 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3288 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3289 {
3290 BOOL ret = TRUE;
3291
3292 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3293 pDecodePara, pvStructInfo, *pcbStructInfo);
3294
3295 __TRY
3296 {
3297 DWORD bytesNeeded;
3298
3299 if ((ret = CRYPT_AsnDecodeAltNameInternal(pbEncoded, cbEncoded,
3300 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
3301 {
3302 if (!pvStructInfo)
3303 *pcbStructInfo = bytesNeeded;
3304 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3305 pvStructInfo, pcbStructInfo, bytesNeeded)))
3306 {
3307 CERT_ALT_NAME_INFO *name;
3308
3309 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3310 pvStructInfo = *(BYTE **)pvStructInfo;
3311 name = (CERT_ALT_NAME_INFO *)pvStructInfo;
3312 name->rgAltEntry = (PCERT_ALT_NAME_ENTRY)
3313 ((BYTE *)pvStructInfo + sizeof(CERT_ALT_NAME_INFO));
3314 ret = CRYPT_AsnDecodeAltNameInternal(pbEncoded, cbEncoded,
3315 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3316 &bytesNeeded, NULL);
3317 }
3318 }
3319 }
3320 __EXCEPT_PAGE_FAULT
3321 {
3322 SetLastError(STATUS_ACCESS_VIOLATION);
3323 ret = FALSE;
3324 }
3325 __ENDTRY
3326 return ret;
3327 }
3328
3329 struct PATH_LEN_CONSTRAINT
3330 {
3331 BOOL fPathLenConstraint;
3332 DWORD dwPathLenConstraint;
3333 };
3334
3335 static BOOL CRYPT_AsnDecodePathLenConstraint(const BYTE *pbEncoded,
3336 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3337 DWORD *pcbDecoded)
3338 {
3339 BOOL ret = TRUE;
3340 DWORD bytesNeeded = sizeof(struct PATH_LEN_CONSTRAINT), size;
3341
3342 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
3343 pvStructInfo, *pcbStructInfo, pcbDecoded);
3344
3345 if (!pvStructInfo)
3346 {
3347 ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags, NULL,
3348 &size, pcbDecoded);
3349 *pcbStructInfo = bytesNeeded;
3350 }
3351 else if (*pcbStructInfo < bytesNeeded)
3352 {
3353 SetLastError(ERROR_MORE_DATA);
3354 *pcbStructInfo = bytesNeeded;
3355 ret = FALSE;
3356 }
3357 else
3358 {
3359 struct PATH_LEN_CONSTRAINT *constraint =
3360 (struct PATH_LEN_CONSTRAINT *)pvStructInfo;
3361
3362 *pcbStructInfo = bytesNeeded;
3363 size = sizeof(constraint->dwPathLenConstraint);
3364 ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags,
3365 &constraint->dwPathLenConstraint, &size, pcbDecoded);
3366 if (ret)
3367 constraint->fPathLenConstraint = TRUE;
3368 TRACE("got an int, dwPathLenConstraint is %d\n",
3369 constraint->dwPathLenConstraint);
3370 }
3371 TRACE("returning %d (%08x)\n", ret, GetLastError());
3372 return ret;
3373 }
3374
3375 static BOOL CRYPT_AsnDecodeSubtreeConstraints(const BYTE *pbEncoded,
3376 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3377 DWORD *pcbDecoded)
3378 {
3379 BOOL ret;
3380 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3381 CRYPT_AsnDecodeCopyBytes, sizeof(CERT_NAME_BLOB), TRUE,
3382 offsetof(CERT_NAME_BLOB, pbData) };
3383 struct GenericArray *entries = (struct GenericArray *)pvStructInfo;
3384
3385 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
3386 pvStructInfo, *pcbStructInfo, pcbDecoded);
3387
3388 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
3389 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
3390 entries ? entries->rgItems : NULL);
3391 TRACE("Returning %d (%08x)\n", ret, GetLastError());
3392 return ret;
3393 }
3394
3395 static BOOL WINAPI CRYPT_AsnDecodeBasicConstraints(DWORD dwCertEncodingType,
3396 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3397 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3398 {
3399 BOOL ret;
3400
3401 __TRY
3402 {
3403 struct AsnDecodeSequenceItem items[] = {
3404 { ASN_BITSTRING, offsetof(CERT_BASIC_CONSTRAINTS_INFO, SubjectType),
3405 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), FALSE, TRUE,
3406 offsetof(CERT_BASIC_CONSTRAINTS_INFO, SubjectType.pbData), 0 },
3407 { ASN_INTEGER, offsetof(CERT_BASIC_CONSTRAINTS_INFO,
3408 fPathLenConstraint), CRYPT_AsnDecodePathLenConstraint,
3409 sizeof(struct PATH_LEN_CONSTRAINT), TRUE, FALSE, 0, 0 },
3410 { ASN_SEQUENCEOF, offsetof(CERT_BASIC_CONSTRAINTS_INFO,
3411 cSubtreesConstraint), CRYPT_AsnDecodeSubtreeConstraints,
3412 sizeof(struct GenericArray), TRUE, TRUE,
3413 offsetof(CERT_BASIC_CONSTRAINTS_INFO, rgSubtreesConstraint), 0 },
3414 };
3415
3416 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3417 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3418 pcbStructInfo, NULL, NULL);
3419 }
3420 __EXCEPT_PAGE_FAULT
3421 {
3422 SetLastError(STATUS_ACCESS_VIOLATION);
3423 ret = FALSE;
3424 }
3425 __ENDTRY
3426 return ret;
3427 }
3428
3429 static BOOL WINAPI CRYPT_AsnDecodeBasicConstraints2(DWORD dwCertEncodingType,
3430 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3431 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3432 {
3433 BOOL ret;
3434
3435 __TRY
3436 {
3437 struct AsnDecodeSequenceItem items[] = {
3438 { ASN_BOOL, offsetof(CERT_BASIC_CONSTRAINTS2_INFO, fCA),
3439 CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE, FALSE, 0, 0 },
3440 { ASN_INTEGER, offsetof(CERT_BASIC_CONSTRAINTS2_INFO,
3441 fPathLenConstraint), CRYPT_AsnDecodePathLenConstraint,
3442 sizeof(struct PATH_LEN_CONSTRAINT), TRUE, FALSE, 0, 0 },
3443 };
3444
3445 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3446 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3447 pcbStructInfo, NULL, NULL);
3448 }
3449 __EXCEPT_PAGE_FAULT
3450 {
3451 SetLastError(STATUS_ACCESS_VIOLATION);
3452 ret = FALSE;
3453 }
3454 __ENDTRY
3455 return ret;
3456 }
3457
3458 static BOOL CRYPT_AsnDecodePolicyQualifier(const BYTE *pbEncoded,
3459 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3460 DWORD *pcbDecoded)
3461 {
3462 struct AsnDecodeSequenceItem items[] = {
3463 { ASN_OBJECTIDENTIFIER, offsetof(CERT_POLICY_QUALIFIER_INFO,
3464 pszPolicyQualifierId), CRYPT_AsnDecodeOidInternal, sizeof(LPSTR),
3465 FALSE, TRUE, offsetof(CERT_POLICY_QUALIFIER_INFO, pszPolicyQualifierId),
3466 0 },
3467 { 0, offsetof(CERT_POLICY_QUALIFIER_INFO, Qualifier),
3468 CRYPT_AsnDecodeDerBlob, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
3469 offsetof(CERT_POLICY_QUALIFIER_INFO, Qualifier.pbData), 0 },
3470 };
3471 BOOL ret;
3472 CERT_POLICY_QUALIFIER_INFO *qualifier = pvStructInfo;
3473
3474 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3475 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3476
3477 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3478 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3479 pcbDecoded, qualifier ? qualifier->pszPolicyQualifierId : NULL);
3480 return ret;
3481 }
3482
3483 static BOOL CRYPT_AsnDecodePolicyQualifiers(const BYTE *pbEncoded,
3484 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3485 DWORD *pcbDecoded)
3486 {
3487 BOOL ret;
3488 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3489 CRYPT_AsnDecodePolicyQualifier, sizeof(CERT_POLICY_QUALIFIER_INFO), TRUE,
3490 offsetof(CERT_POLICY_QUALIFIER_INFO, pszPolicyQualifierId) };
3491 struct GenericArray *entries = pvStructInfo;
3492
3493 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3494 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3495
3496 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
3497 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
3498 entries ? entries->rgItems : NULL);
3499 TRACE("Returning %d (%08x)\n", ret, GetLastError());
3500 return ret;
3501 }
3502
3503 static BOOL CRYPT_AsnDecodeCertPolicy(const BYTE *pbEncoded, DWORD cbEncoded,
3504 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
3505 {
3506 struct AsnDecodeSequenceItem items[] = {
3507 { ASN_OBJECTIDENTIFIER, offsetof(CERT_POLICY_INFO, pszPolicyIdentifier),
3508 CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), FALSE, TRUE,
3509 offsetof(CERT_POLICY_INFO, pszPolicyIdentifier), 0 },
3510 { ASN_SEQUENCEOF, offsetof(CERT_POLICY_INFO, cPolicyQualifier),
3511 CRYPT_AsnDecodePolicyQualifiers, sizeof(struct GenericArray), TRUE,
3512 TRUE, offsetof(CERT_POLICY_INFO, rgPolicyQualifier), 0 },
3513 };
3514 CERT_POLICY_INFO *info = pvStructInfo;
3515 BOOL ret;
3516
3517 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3518 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3519
3520 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3521 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3522 pcbDecoded, info ? info->pszPolicyIdentifier : NULL);
3523 return ret;
3524 }
3525
3526 static BOOL WINAPI CRYPT_AsnDecodeCertPolicies(DWORD dwCertEncodingType,
3527 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3528 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3529 {
3530 BOOL ret = FALSE;
3531
3532 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3533 pDecodePara, pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3534
3535 __TRY
3536 {
3537 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3538 CRYPT_AsnDecodeCertPolicy, sizeof(CERT_POLICY_INFO), TRUE,
3539 offsetof(CERT_POLICY_INFO, pszPolicyIdentifier) };
3540
3541 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
3542 pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
3543 }
3544 __EXCEPT_PAGE_FAULT
3545 {
3546 SetLastError(STATUS_ACCESS_VIOLATION);
3547 }
3548 __ENDTRY
3549 return ret;
3550 }
3551
3552 #define RSA1_MAGIC 0x31415352
3553
3554 struct DECODED_RSA_PUB_KEY
3555 {
3556 DWORD pubexp;
3557 CRYPT_INTEGER_BLOB modulus;
3558 };
3559
3560 static BOOL WINAPI CRYPT_AsnDecodeRsaPubKey(DWORD dwCertEncodingType,
3561 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3562 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3563 {
3564 BOOL ret;
3565
3566 __TRY
3567 {
3568 struct AsnDecodeSequenceItem items[] = {
3569 { ASN_INTEGER, offsetof(struct DECODED_RSA_PUB_KEY, modulus),
3570 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
3571 FALSE, TRUE, offsetof(struct DECODED_RSA_PUB_KEY, modulus.pbData),
3572 0 },
3573 { ASN_INTEGER, offsetof(struct DECODED_RSA_PUB_KEY, pubexp),
3574 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
3575 };
3576 struct DECODED_RSA_PUB_KEY *decodedKey = NULL;
3577 DWORD size = 0;
3578
3579 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3580 pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &decodedKey,
3581 &size, NULL, NULL);
3582 if (ret)
3583 {
3584 DWORD bytesNeeded = sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) +
3585 decodedKey->modulus.cbData;
3586
3587 if (!pvStructInfo)
3588 {
3589 *pcbStructInfo = bytesNeeded;
3590 ret = TRUE;
3591 }
3592 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3593 pvStructInfo, pcbStructInfo, bytesNeeded)))
3594 {
3595 BLOBHEADER *hdr;
3596 RSAPUBKEY *rsaPubKey;
3597
3598 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3599 pvStructInfo = *(BYTE **)pvStructInfo;
3600 hdr = (BLOBHEADER *)pvStructInfo;
3601 hdr->bType = PUBLICKEYBLOB;
3602 hdr->bVersion = CUR_BLOB_VERSION;
3603 hdr->reserved = 0;
3604 hdr->aiKeyAlg = CALG_RSA_KEYX;
3605 rsaPubKey = (RSAPUBKEY *)((BYTE *)pvStructInfo +
3606 sizeof(BLOBHEADER));
3607 rsaPubKey->magic = RSA1_MAGIC;
3608 rsaPubKey->pubexp = decodedKey->pubexp;
3609 rsaPubKey->bitlen = decodedKey->modulus.cbData * 8;
3610 memcpy((BYTE *)pvStructInfo + sizeof(BLOBHEADER) +
3611 sizeof(RSAPUBKEY), decodedKey->modulus.pbData,
3612 decodedKey->modulus.cbData);
3613 }
3614 LocalFree(decodedKey);
3615 }
3616 }
3617 __EXCEPT_PAGE_FAULT
3618 {
3619 SetLastError(STATUS_ACCESS_VIOLATION);
3620 ret = FALSE;
3621 }
3622 __ENDTRY
3623 return ret;
3624 }
3625
3626 static BOOL CRYPT_AsnDecodeOctetsInternal(const BYTE *pbEncoded,
3627 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3628 DWORD *pcbDecoded)
3629 {
3630 BOOL ret;
3631 DWORD bytesNeeded, dataLen;
3632
3633 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
3634 pvStructInfo, *pcbStructInfo, pcbDecoded);
3635
3636 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
3637 {
3638 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
3639
3640 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
3641 bytesNeeded = sizeof(CRYPT_DATA_BLOB);
3642 else
3643 bytesNeeded = dataLen + sizeof(CRYPT_DATA_BLOB);
3644 if (pcbDecoded)
3645 *pcbDecoded = 1 + lenBytes + dataLen;
3646 if (!pvStructInfo)
3647 *pcbStructInfo = bytesNeeded;
3648 else if (*pcbStructInfo < bytesNeeded)
3649 {
3650 SetLastError(ERROR_MORE_DATA);
3651 *pcbStructInfo = bytesNeeded;
3652 ret = FALSE;
3653 }
3654 else
3655 {
3656 CRYPT_DATA_BLOB *blob;
3657
3658 *pcbStructInfo = bytesNeeded;
3659 blob = (CRYPT_DATA_BLOB *)pvStructInfo;
3660 blob->cbData = dataLen;
3661 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
3662 blob->pbData = (BYTE *)pbEncoded + 1 + lenBytes;
3663 else
3664 {
3665 assert(blob->pbData);
3666 if (blob->cbData)
3667 memcpy(blob->pbData, pbEncoded + 1 + lenBytes,
3668 blob->cbData);
3669 }
3670 }
3671 }
3672 return ret;
3673 }
3674
3675 static BOOL WINAPI CRYPT_AsnDecodeOctets(DWORD dwCertEncodingType,
3676 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3677 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3678 {
3679 BOOL ret;
3680
3681 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3682 pDecodePara, pvStructInfo, *pcbStructInfo);
3683
3684 __TRY
3685 {
3686 DWORD bytesNeeded;
3687
3688 if (!cbEncoded)
3689 {
3690 SetLastError(CRYPT_E_ASN1_CORRUPT);
3691 ret = FALSE;
3692 }
3693 else if (pbEncoded[0] != ASN_OCTETSTRING)
3694 {
3695 SetLastError(CRYPT_E_ASN1_BADTAG);
3696 ret = FALSE;
3697 }
3698 else if ((ret = CRYPT_AsnDecodeOctetsInternal(pbEncoded, cbEncoded,
3699 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
3700 {
3701 if (!pvStructInfo)
3702 *pcbStructInfo = bytesNeeded;
3703 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3704 pvStructInfo, pcbStructInfo, bytesNeeded)))
3705 {
3706 CRYPT_DATA_BLOB *blob;
3707
3708 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3709 pvStructInfo = *(BYTE **)pvStructInfo;
3710 blob = (CRYPT_DATA_BLOB *)pvStructInfo;
3711 blob->pbData = (BYTE *)pvStructInfo + sizeof(CRYPT_DATA_BLOB);
3712 ret = CRYPT_AsnDecodeOctetsInternal(pbEncoded, cbEncoded,
3713 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3714 &bytesNeeded, NULL);
3715 }
3716 }
3717 }
3718 __EXCEPT_PAGE_FAULT
3719 {
3720 SetLastError(STATUS_ACCESS_VIOLATION);
3721 ret = FALSE;
3722 }
3723 __ENDTRY
3724 return ret;
3725 }
3726
3727 static BOOL CRYPT_AsnDecodeBitsInternal(const BYTE *pbEncoded, DWORD cbEncoded,
3728 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
3729 {
3730 BOOL ret;
3731 DWORD bytesNeeded, dataLen;
3732 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
3733
3734 TRACE("(%p, %d, 0x%08x, %p, %d, %p)\n", pbEncoded, cbEncoded, dwFlags,
3735 pvStructInfo, *pcbStructInfo, pcbDecoded);
3736
3737 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
3738 {
3739 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
3740 bytesNeeded = sizeof(CRYPT_BIT_BLOB);
3741 else
3742 bytesNeeded = dataLen - 1 + sizeof(CRYPT_BIT_BLOB);
3743 if (pcbDecoded)
3744 *pcbDecoded = 1 + lenBytes + dataLen;
3745 if (!pvStructInfo)
3746 *pcbStructInfo = bytesNeeded;
3747 else if (*pcbStructInfo < bytesNeeded)
3748 {
3749 *pcbStructInfo = bytesNeeded;
3750 SetLastError(ERROR_MORE_DATA);
3751 ret = FALSE;
3752 }
3753 else
3754 {
3755 CRYPT_BIT_BLOB *blob;
3756
3757 *pcbStructInfo = bytesNeeded;
3758 blob = (CRYPT_BIT_BLOB *)pvStructInfo;
3759 blob->cbData = dataLen - 1;
3760 blob->cUnusedBits = *(pbEncoded + 1 + lenBytes);
3761 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
3762 {
3763 blob->pbData = (BYTE *)pbEncoded + 2 + lenBytes;
3764 }
3765 else
3766 {
3767 assert(blob->pbData);
3768 if (blob->cbData)
3769 {
3770 BYTE mask = 0xff << blob->cUnusedBits;
3771
3772 memcpy(blob->pbData, pbEncoded + 2 + lenBytes,
3773 blob->cbData);
3774 blob->pbData[blob->cbData - 1] &= mask;
3775 }
3776 }
3777 }
3778 }
3779 return ret;
3780 }
3781
3782 static BOOL WINAPI CRYPT_AsnDecodeBits(DWORD dwCertEncodingType,
3783 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3784 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3785 {
3786 BOOL ret;
3787
3788 TRACE("(%p, %d, 0x%08x, %p, %p, %p)\n", pbEncoded, cbEncoded, dwFlags,
3789 pDecodePara, pvStructInfo, pcbStructInfo);
3790
3791 __TRY
3792 {
3793 DWORD bytesNeeded;
3794
3795 if (!cbEncoded)
3796 {
3797 SetLastError(CRYPT_E_ASN1_CORRUPT);
3798 ret = FALSE;
3799 }
3800 else if (pbEncoded[0] != ASN_BITSTRING)
3801 {
3802 SetLastError(CRYPT_E_ASN1_BADTAG);
3803 ret = FALSE;
3804 }
3805 else if ((ret = CRYPT_AsnDecodeBitsInternal(pbEncoded, cbEncoded,
3806 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
3807 {
3808 if (!pvStructInfo)
3809 *pcbStructInfo = bytesNeeded;
3810 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3811 pvStructInfo, pcbStructInfo, bytesNeeded)))
3812 {
3813 CRYPT_BIT_BLOB *blob;
3814
3815 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3816 pvStructInfo = *(BYTE **)pvStructInfo;
3817 blob = (CRYPT_BIT_BLOB *)pvStructInfo;
3818 blob->pbData = (BYTE *)pvStructInfo + sizeof(CRYPT_BIT_BLOB);
3819 ret = CRYPT_AsnDecodeBitsInternal(pbEncoded, cbEncoded,
3820 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3821 &bytesNeeded, NULL);
3822 }
3823 }
3824 }
3825 __EXCEPT_PAGE_FAULT
3826 {
3827 SetLastError(STATUS_ACCESS_VIOLATION);
3828 ret = FALSE;
3829 }
3830 __ENDTRY
3831 TRACE("returning %d (%08x)\n", ret, GetLastError());
3832 return ret;
3833 }
3834
3835 /* Ignores tag. Only allows integers 4 bytes or smaller in size. */
3836 static BOOL CRYPT_AsnDecodeIntInternal(const BYTE *pbEncoded, DWORD cbEncoded,
3837 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
3838 {
3839 BOOL ret;
3840 BYTE buf[sizeof(CRYPT_INTEGER_BLOB) + sizeof(int)];
3841 CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)buf;
3842 DWORD size = sizeof(buf);
3843
3844 blob->pbData = buf + sizeof(CRYPT_INTEGER_BLOB);
3845 ret = CRYPT_AsnDecodeIntegerInternal(pbEncoded, cbEncoded, 0, buf,
3846 &size, pcbDecoded);
3847 if (ret)
3848 {
3849 if (!pvStructInfo)
3850 *pcbStructInfo = sizeof(int);
3851 else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo, sizeof(int))))
3852 {
3853 int val, i;
3854
3855 if (blob->pbData[blob->cbData - 1] & 0x80)
3856 {
3857 /* initialize to a negative value to sign-extend */
3858 val = -1;
3859 }
3860 else
3861 val = 0;
3862 for (i = 0; i < blob->cbData; i++)
3863 {
3864 val <<= 8;
3865 val |= blob->pbData[blob->cbData - i - 1];
3866 }
3867 memcpy(pvStructInfo, &val, sizeof(int));
3868 }
3869 }
3870 else if (GetLastError() == ERROR_MORE_DATA)
3871 SetLastError(CRYPT_E_ASN1_LARGE);
3872 return ret;
3873 }
3874
3875 static BOOL WINAPI CRYPT_AsnDecodeInt(DWORD dwCertEncodingType,
3876 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3877 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3878 {
3879 BOOL ret;
3880
3881 __TRY
3882 {
3883 DWORD bytesNeeded;
3884
3885 if (!cbEncoded)
3886 {
3887 SetLastError(CRYPT_E_ASN1_EOD);
3888 ret = FALSE;
3889 }
3890 else if (pbEncoded[0] != ASN_INTEGER)
3891 {
3892 SetLastError(CRYPT_E_ASN1_BADTAG);
3893 ret = FALSE;
3894 }
3895 else
3896 ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded,
3897 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
3898 if (ret)
3899 {
3900 if (!pvStructInfo)
3901 *pcbStructInfo = bytesNeeded;
3902 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3903 pvStructInfo, pcbStructInfo, bytesNeeded)))
3904 {
3905 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3906 pvStructInfo = *(BYTE **)pvStructInfo;
3907 ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded,
3908 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3909 &bytesNeeded, NULL);
3910 }
3911 }
3912 }
3913 __EXCEPT_PAGE_FAULT
3914 {
3915 SetLastError(STATUS_ACCESS_VIOLATION);
3916 ret = FALSE;
3917 }
3918 __ENDTRY
3919 return ret;
3920 }
3921
3922 static BOOL CRYPT_AsnDecodeIntegerInternal(const BYTE *pbEncoded,
3923 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3924 DWORD *pcbDecoded)
3925 {
3926 BOOL ret;
3927 DWORD bytesNeeded, dataLen;
3928
3929 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
3930 {
3931 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
3932
3933 bytesNeeded = dataLen + sizeof(CRYPT_INTEGER_BLOB);
3934 if (pcbDecoded)
3935 *pcbDecoded = 1 + lenBytes + dataLen;
3936 if (!pvStructInfo)
3937 *pcbStructInfo = bytesNeeded;
3938 else if (*pcbStructInfo < bytesNeeded)
3939 {
3940 *pcbStructInfo = bytesNeeded;
3941 SetLastError(ERROR_MORE_DATA);
3942 ret = FALSE;
3943 }
3944 else
3945 {
3946 CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)pvStructInfo;
3947
3948 *pcbStructInfo = bytesNeeded;
3949 blob->cbData = dataLen;
3950 assert(blob->pbData);
3951 if (blob->cbData)
3952 {
3953 DWORD i;
3954
3955 for (i = 0; i < blob->cbData; i++)
3956 {
3957 blob->pbData[i] = *(pbEncoded + 1 + lenBytes +
3958 dataLen - i - 1);
3959 }
3960 }
3961 }
3962 }
3963 return ret;
3964 }
3965
3966 static BOOL WINAPI CRYPT_AsnDecodeInteger(DWORD dwCertEncodingType,
3967 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3968 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3969 {
3970 BOOL ret;
3971
3972 __TRY
3973 {
3974 DWORD bytesNeeded;
3975
3976 if (pbEncoded[0] != ASN_INTEGER)
3977 {
3978 SetLastError(CRYPT_E_ASN1_BADTAG);
3979 ret = FALSE;
3980 }
3981 else
3982 ret = CRYPT_AsnDecodeIntegerInternal(pbEncoded, cbEncoded,
3983 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
3984 if (ret)
3985 {
3986 if (!pvStructInfo)
3987 *pcbStructInfo = bytesNeeded;
3988 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3989 pvStructInfo, pcbStructInfo, bytesNeeded)))
3990 {
3991 CRYPT_INTEGER_BLOB *blob;
3992
3993 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3994 pvStructInfo = *(BYTE **)pvStructInfo;
3995 blob = (CRYPT_INTEGER_BLOB *)pvStructInfo;
3996 blob->pbData = (BYTE *)pvStructInfo +
3997 sizeof(CRYPT_INTEGER_BLOB);
3998 ret = CRYPT_AsnDecodeIntegerInternal(pbEncoded, cbEncoded,
3999 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, pvStructInfo,
4000 &bytesNeeded, NULL);
4001 }
4002 }
4003 }
4004 __EXCEPT_PAGE_FAULT
4005 {
4006 SetLastError(STATUS_ACCESS_VIOLATION);
4007 ret = FALSE;
4008 }
4009 __ENDTRY
4010 return ret;
4011 }
4012
4013 static BOOL CRYPT_AsnDecodeUnsignedIntegerInternal(const BYTE *pbEncoded,
4014 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4015 DWORD *pcbDecoded)
4016 {
4017 BOOL ret;
4018
4019 if (pbEncoded[0] == ASN_INTEGER)
4020 {
4021 DWORD bytesNeeded, dataLen;
4022
4023 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
4024 {
4025 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
4026
4027 if (pcbDecoded)
4028 *pcbDecoded = 1 + lenBytes + dataLen;
4029 bytesNeeded = dataLen + sizeof(CRYPT_INTEGER_BLOB);
4030 if (!pvStructInfo)
4031 *pcbStructInfo = bytesNeeded;
4032 else if (*pcbStructInfo < bytesNeeded)
4033 {
4034 *pcbStructInfo = bytesNeeded;
4035 SetLastError(ERROR_MORE_DATA);
4036 ret = FALSE;
4037 }
4038 else
4039 {
4040 CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)pvStructInfo;
4041
4042 *pcbStructInfo = bytesNeeded;
4043 blob->cbData = dataLen;
4044 assert(blob->pbData);
4045 /* remove leading zero byte if it exists */
4046 if (blob->cbData && *(pbEncoded + 1 + lenBytes) == 0)
4047 {
4048 blob->cbData--;
4049 blob->pbData++;
4050 }
4051 if (blob->cbData)
4052 {
4053 DWORD i;
4054
4055 for (i = 0; i < blob->cbData; i++)
4056 {
4057 blob->pbData[i] = *(pbEncoded + 1 + lenBytes +
4058 dataLen - i - 1);
4059 }
4060 }
4061 }
4062 }
4063 }
4064 else
4065 {
4066 SetLastError(CRYPT_E_ASN1_BADTAG);
4067 ret = FALSE;
4068 }
4069 return ret;
4070 }
4071
4072 static BOOL WINAPI CRYPT_AsnDecodeUnsignedInteger(DWORD dwCertEncodingType,
4073 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4074 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4075 {
4076 BOOL ret;
4077
4078 __TRY
4079 {
4080 DWORD bytesNeeded;
4081
4082 if ((ret = CRYPT_AsnDecodeUnsignedIntegerInternal(pbEncoded, cbEncoded,
4083 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
4084 {
4085 if (!pvStructInfo)
4086 *pcbStructInfo = bytesNeeded;
4087 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4088 pvStructInfo, pcbStructInfo, bytesNeeded)))
4089 {
4090 CRYPT_INTEGER_BLOB *blob;
4091
4092 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4093 pvStructInfo = *(BYTE **)pvStructInfo;
4094 blob = (CRYPT_INTEGER_BLOB *)pvStructInfo;
4095 blob->pbData = (BYTE *)pvStructInfo +
4096 sizeof(CRYPT_INTEGER_BLOB);
4097 ret = CRYPT_AsnDecodeUnsignedIntegerInternal(pbEncoded,
4098 cbEncoded, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, pvStructInfo,
4099 &bytesNeeded, NULL);
4100 }
4101 }
4102 }
4103 __EXCEPT_PAGE_FAULT
4104 {
4105 SetLastError(STATUS_ACCESS_VIOLATION);
4106 ret = FALSE;
4107 }
4108 __ENDTRY
4109 return ret;
4110 }
4111
4112 static BOOL WINAPI CRYPT_AsnDecodeEnumerated(DWORD dwCertEncodingType,
4113 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4114 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4115 {
4116 BOOL ret;
4117
4118 if (!pvStructInfo)
4119 {
4120 *pcbStructInfo = sizeof(int);
4121 return TRUE;
4122 }
4123 __TRY
4124 {
4125 if (pbEncoded[0] == ASN_ENUMERATED)
4126 {
4127 unsigned int val = 0, i;
4128
4129 if (cbEncoded <= 1)
4130 {
4131 SetLastError(CRYPT_E_ASN1_EOD);
4132 ret = FALSE;
4133 }
4134 else if (pbEncoded[1] == 0)
4135 {
4136 SetLastError(CRYPT_E_ASN1_CORRUPT);
4137 ret = FALSE;
4138 }
4139 else
4140 {
4141 /* A little strange looking, but we have to accept a sign byte:
4142 * 0xffffffff gets encoded as 0a 05 00 ff ff ff ff. Also,
4143 * assuming a small length is okay here, it has to be in short
4144 * form.
4145 */
4146 if (pbEncoded[1] > sizeof(unsigned int) + 1)
4147 {
4148 SetLastError(CRYPT_E_ASN1_LARGE);
4149 return FALSE;
4150 }
4151 for (i = 0; i < pbEncoded[1]; i++)
4152 {
4153 val <<= 8;
4154 val |= pbEncoded[2 + i];
4155 }
4156 if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4157 pvStructInfo, pcbStructInfo, sizeof(unsigned int))))
4158 {
4159 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4160 pvStructInfo = *(BYTE **)pvStructInfo;
4161 memcpy(pvStructInfo, &val, sizeof(unsigned int));
4162 }
4163 }
4164 }
4165 else
4166 {
4167 SetLastError(CRYPT_E_ASN1_BADTAG);
4168 ret = FALSE;
4169 }
4170 }
4171 __EXCEPT_PAGE_FAULT
4172 {
4173 SetLastError(STATUS_ACCESS_VIOLATION);
4174 ret = FALSE;
4175 }
4176 __ENDTRY
4177 return ret;
4178 }
4179
4180 /* Modifies word, pbEncoded, and len, and magically sets a value ret to FALSE
4181 * if it fails.
4182 */
4183 #define CRYPT_TIME_GET_DIGITS(pbEncoded, len, numDigits, word) \
4184 do { \
4185 BYTE i; \
4186 \
4187 (word) = 0; \
4188 for (i = 0; (len) > 0 && i < (numDigits); i++, (len)--) \
4189 { \
4190 if (!isdigit(*(pbEncoded))) \
4191 { \
4192 SetLastError(CRYPT_E_ASN1_CORRUPT); \
4193 ret = FALSE; \
4194 } \
4195 else \
4196 { \
4197 (word) *= 10; \
4198 (word) += *(pbEncoded)++ - '0'; \
4199 } \
4200 } \
4201 } while (0)
4202
4203 static BOOL CRYPT_AsnDecodeTimeZone(const BYTE *pbEncoded, DWORD len,
4204 SYSTEMTIME *sysTime)
4205 {
4206 BOOL ret = TRUE;
4207
4208 if (len >= 3 && (*pbEncoded == '+' || *pbEncoded == '-'))
4209 {
4210 WORD hours, minutes = 0;
4211 BYTE sign = *pbEncoded++;
4212
4213 len--;
4214 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, hours);
4215 if (ret && hours >= 24)
4216 {
4217 SetLastError(CRYPT_E_ASN1_CORRUPT);
4218 ret = FALSE;
4219 }
4220 else if (len >= 2)
4221 {
4222 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, minutes);
4223 if (ret && minutes >= 60)
4224 {
4225 SetLastError(CRYPT_E_ASN1_CORRUPT);
4226 ret = FALSE;
4227 }
4228 }
4229 if (ret)
4230 {
4231 if (sign == '+')
4232 {
4233 sysTime->wHour += hours;
4234 sysTime->wMinute += minutes;
4235 }
4236 else
4237 {
4238 if (hours > sysTime->wHour)
4239 {
4240 sysTime->wDay--;
4241 sysTime->wHour = 24 - (hours - sysTime->wHour);
4242 }
4243 else
4244 sysTime->wHour -= hours;
4245 if (minutes > sysTime->wMinute)
4246 {
4247 sysTime->wHour--;
4248 sysTime->wMinute = 60 - (minutes - sysTime->wMinute);
4249 }
4250 else
4251 sysTime->wMinute -= minutes;
4252 }
4253 }
4254 }
4255 return ret;
4256 }
4257
4258 #define MIN_ENCODED_TIME_LENGTH 10
4259
4260 static BOOL CRYPT_AsnDecodeUtcTimeInternal(const BYTE *pbEncoded,
4261 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4262 DWORD *pcbDecoded)
4263 {
4264 BOOL ret = FALSE;
4265
4266 if (pbEncoded[0] == ASN_UTCTIME)
4267 {
4268 if (cbEncoded <= 1)
4269 SetLastError(CRYPT_E_ASN1_EOD);
4270 else if (pbEncoded[1] > 0x7f)
4271 {
4272 /* long-form date strings really can't be valid */
4273 SetLastError(CRYPT_E_ASN1_CORRUPT);
4274 }
4275 else
4276 {
4277 SYSTEMTIME sysTime = { 0 };
4278 BYTE len = pbEncoded[1];
4279
4280 if (len < MIN_ENCODED_TIME_LENGTH)
4281 SetLastError(CRYPT_E_ASN1_CORRUPT);
4282 else
4283 {
4284 ret = TRUE;
4285 if (pcbDecoded)
4286 *pcbDecoded = 2 + len;
4287 pbEncoded += 2;
4288 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wYear);
4289 if (sysTime.wYear >= 50)
4290 sysTime.wYear += 1900;
4291 else
4292 sysTime.wYear += 2000;
4293 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wMonth);
4294 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wDay);
4295 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wHour);
4296 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wMinute);
4297 if (ret && len > 0)
4298 {
4299 if (len >= 2 && isdigit(*pbEncoded) &&
4300 isdigit(*(pbEncoded + 1)))
4301 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2,
4302 sysTime.wSecond);
4303 else if (isdigit(*pbEncoded))
4304 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 1,
4305 sysTime.wSecond);
4306 if (ret)
4307 ret = CRYPT_AsnDecodeTimeZone(pbEncoded, len,
4308 &sysTime);
4309 }
4310 if (ret)
4311 {
4312 if (!pvStructInfo)
4313 *pcbStructInfo = sizeof(FILETIME);
4314 else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo,
4315 sizeof(FILETIME))))
4316 ret = SystemTimeToFileTime(&sysTime,
4317 (FILETIME *)pvStructInfo);
4318 }
4319 }
4320 }
4321 }
4322 else
4323 SetLastError(CRYPT_E_ASN1_BADTAG);
4324 return ret;
4325 }
4326
4327 static BOOL WINAPI CRYPT_AsnDecodeUtcTime(DWORD dwCertEncodingType,
4328 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4329 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4330 {
4331 BOOL ret = FALSE;
4332
4333 __TRY
4334 {
4335 DWORD bytesNeeded;
4336
4337 ret = CRYPT_AsnDecodeUtcTimeInternal(pbEncoded, cbEncoded,
4338 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
4339 if (ret)
4340 {
4341 if (!pvStructInfo)
4342 *pcbStructInfo = bytesNeeded;
4343 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags,
4344 pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
4345 {
4346 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4347 pvStructInfo = *(BYTE **)pvStructInfo;
4348 ret = CRYPT_AsnDecodeUtcTimeInternal(pbEncoded, cbEncoded,
4349 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
4350 &bytesNeeded, NULL);
4351 }
4352 }
4353 }
4354 __EXCEPT_PAGE_FAULT
4355 {
4356 SetLastError(STATUS_ACCESS_VIOLATION);
4357 }
4358 __ENDTRY
4359 return ret;
4360 }
4361
4362 static BOOL CRYPT_AsnDecodeGeneralizedTime(const BYTE *pbEncoded,
4363 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4364 DWORD *pcbDecoded)
4365 {
4366 BOOL ret = FALSE;
4367
4368 if (pbEncoded[0] == ASN_GENERALTIME)
4369 {
4370 if (cbEncoded <= 1)
4371 SetLastError(CRYPT_E_ASN1_EOD);
4372 else if (pbEncoded[1] > 0x7f)
4373 {
4374 /* long-form date strings really can't be valid */
4375 SetLastError(CRYPT_E_ASN1_CORRUPT);
4376 }
4377 else
4378 {
4379 BYTE len = pbEncoded[1];
4380
4381 if (len < MIN_ENCODED_TIME_LENGTH)
4382 SetLastError(CRYPT_E_ASN1_CORRUPT);
4383 else
4384 {
4385 SYSTEMTIME sysTime = { 0 };
4386
4387 ret = TRUE;
4388 if (pcbDecoded)
4389 *pcbDecoded = 2 + len;
4390 pbEncoded += 2;
4391 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 4, sysTime.wYear);
4392 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wMonth);
4393 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wDay);
4394 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wHour);
4395 if (ret && len > 0)
4396 {
4397 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2,
4398 sysTime.wMinute);
4399 if (ret && len > 0)
4400 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2,
4401 sysTime.wSecond);
4402 if (ret && len > 0 && (*pbEncoded == '.' ||
4403 *pbEncoded == ','))
4404 {
4405 BYTE digits;
4406
4407 pbEncoded++;
4408 len--;
4409 /* workaround macro weirdness */
4410 digits = min(len, 3);
4411 CRYPT_TIME_GET_DIGITS(pbEncoded, len, digits,
4412 sysTime.wMilliseconds);
4413 }
4414 if (ret)
4415 ret = CRYPT_AsnDecodeTimeZone(pbEncoded, len,
4416 &sysTime);
4417 }
4418 if (ret)
4419 {
4420 if (!pvStructInfo)
4421 *pcbStructInfo = sizeof(FILETIME);
4422 else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo,
4423 sizeof(FILETIME))))
4424 ret = SystemTimeToFileTime(&sysTime,
4425 (FILETIME *)pvStructInfo);
4426 }
4427 }
4428 }
4429 }
4430 else
4431 SetLastError(CRYPT_E_ASN1_BADTAG);
4432 return ret;
4433 }
4434
4435 static BOOL CRYPT_AsnDecodeChoiceOfTimeInternal(const BYTE *pbEncoded,
4436 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4437 DWORD *pcbDecoded)
4438 {
4439 BOOL ret;
4440 InternalDecodeFunc decode = NULL;
4441
4442 if (pbEncoded[0] == ASN_UTCTIME)
4443 decode = CRYPT_AsnDecodeUtcTimeInternal;
4444 else if (pbEncoded[0] == ASN_GENERALTIME)
4445 decode = CRYPT_AsnDecodeGeneralizedTime;
4446 if (decode)
4447 ret = decode(pbEncoded, cbEncoded, dwFlags, pvStructInfo,
4448 pcbStructInfo, pcbDecoded);
4449 else
4450 {
4451 SetLastError(CRYPT_E_ASN1_BADTAG);
4452 ret = FALSE;
4453 }
4454 return ret;
4455 }
4456
4457 static BOOL WINAPI CRYPT_AsnDecodeChoiceOfTime(DWORD dwCertEncodingType,
4458 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4459 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4460 {
4461 BOOL ret;
4462
4463 __TRY
4464 {
4465 DWORD bytesNeeded;
4466
4467 ret = CRYPT_AsnDecodeChoiceOfTimeInternal(pbEncoded, cbEncoded,
4468 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
4469 if (ret)
4470 {
4471 if (!pvStructInfo)
4472 *pcbStructInfo = bytesNeeded;
4473 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4474 pvStructInfo, pcbStructInfo, bytesNeeded)))
4475 {
4476 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4477 pvStructInfo = *(BYTE **)pvStructInfo;
4478 ret = CRYPT_AsnDecodeChoiceOfTimeInternal(pbEncoded, cbEncoded,
4479 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
4480 &bytesNeeded, NULL);
4481 }
4482 }
4483 }
4484 __EXCEPT_PAGE_FAULT
4485 {
4486 SetLastError(STATUS_ACCESS_VIOLATION);
4487 ret = FALSE;
4488 }
4489 __ENDTRY
4490 return ret;
4491 }
4492
4493 static BOOL WINAPI CRYPT_AsnDecodeSequenceOfAny(DWORD dwCertEncodingType,
4494 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4495 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4496 {
4497 BOOL ret = TRUE;
4498
4499 __TRY
4500 {
4501 if (pbEncoded[0] == ASN_SEQUENCEOF)
4502 {
4503 DWORD bytesNeeded, dataLen, remainingLen, cValue;
4504
4505 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
4506 {
4507 BYTE lenBytes;
4508 const BYTE *ptr;
4509
4510 lenBytes = GET_LEN_BYTES(pbEncoded[1]);
4511 bytesNeeded = sizeof(CRYPT_SEQUENCE_OF_ANY);
4512 cValue = 0;
4513 ptr = pbEncoded + 1 + lenBytes;
4514 remainingLen = dataLen;
4515 while (ret && remainingLen)
4516 {
4517 DWORD nextLen;
4518
4519 ret = CRYPT_GetLen(ptr, remainingLen, &nextLen);
4520 if (ret)
4521 {
4522 DWORD nextLenBytes = GET_LEN_BYTES(ptr[1]);
4523
4524 remainingLen -= 1 + nextLenBytes + nextLen;
4525 ptr += 1 + nextLenBytes + nextLen;
4526 bytesNeeded += sizeof(CRYPT_DER_BLOB);
4527 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
4528 bytesNeeded += 1 + nextLenBytes + nextLen;
4529 cValue++;
4530 }
4531 }
4532 if (ret)
4533 {
4534 CRYPT_SEQUENCE_OF_ANY *seq;
4535 BYTE *nextPtr;
4536 DWORD i;
4537
4538 if (!pvStructInfo)
4539 *pcbStructInfo = bytesNeeded;
4540 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4541 pvStructInfo, pcbStructInfo, bytesNeeded)))
4542 {
4543 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4544 pvStructInfo = *(BYTE **)pvStructInfo;
4545 seq = (CRYPT_SEQUENCE_OF_ANY *)pvStructInfo;
4546 seq->cValue = cValue;
4547 seq->rgValue = (CRYPT_DER_BLOB *)((BYTE *)seq +
4548 sizeof(*seq));
4549 nextPtr = (BYTE *)seq->rgValue +
4550 cValue * sizeof(CRYPT_DER_BLOB);
4551 ptr = pbEncoded + 1 + lenBytes;
4552 remainingLen = dataLen;
4553 i = 0;
4554 while (ret && remainingLen)
4555 {
4556 DWORD nextLen;
4557
4558 ret = CRYPT_GetLen(ptr, remainingLen, &nextLen);
4559 if (ret)
4560 {
4561 DWORD nextLenBytes = GET_LEN_BYTES(ptr[1]);
4562
4563 seq->rgValue[i].cbData = 1 + nextLenBytes +
4564 nextLen;
4565 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
4566 seq->rgValue[i].pbData = (BYTE *)ptr;
4567 else
4568 {
4569 seq->rgValue[i].pbData = nextPtr;
4570 memcpy(nextPtr, ptr, 1 + nextLenBytes +
4571 nextLen);
4572 nextPtr += 1 + nextLenBytes + nextLen;
4573 }
4574 remainingLen -= 1 + nextLenBytes + nextLen;
4575 ptr += 1 + nextLenBytes + nextLen;
4576 i++;
4577 }
4578 }
4579 }
4580 }
4581 }
4582 }
4583 else
4584 {
4585 SetLastError(CRYPT_E_ASN1_BADTAG);
4586 ret = FALSE;
4587 }
4588 }
4589 __EXCEPT_PAGE_FAULT
4590 {
4591 SetLastError(STATUS_ACCESS_VIOLATION);
4592 ret = FALSE;
4593 }
4594 __ENDTRY
4595 return ret;
4596 }
4597
4598 static BOOL CRYPT_AsnDecodeDistPointName(const BYTE *pbEncoded,
4599 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4600 DWORD *pcbDecoded)
4601 {
4602 BOOL ret;
4603
4604 if (pbEncoded[0] == (ASN_CONTEXT | ASN_CONSTRUCTOR | 0))
4605 {
4606 DWORD bytesNeeded, dataLen;
4607
4608 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
4609 {
4610 struct AsnArrayDescriptor arrayDesc = {
4611 ASN_CONTEXT | ASN_CONSTRUCTOR | 0, CRYPT_AsnDecodeAltNameEntry,
4612 sizeof(CERT_ALT_NAME_ENTRY), TRUE,
4613 offsetof(CERT_ALT_NAME_ENTRY, u.pwszURL) };
4614 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
4615 DWORD nameLen;
4616
4617 if (dataLen)
4618 {
4619 ret = CRYPT_AsnDecodeArray(&arrayDesc,
4620 pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
4621 0, NULL, NULL, &nameLen, NULL, NULL);
4622 /* The CERT_ALT_NAME_INFO's size is included by CRYPT_AsnDecodeArray
4623 * as the sizeof(struct GenericArray), so don't include it in the
4624 * total bytes needed.
4625 */
4626 bytesNeeded = sizeof(CRL_DIST_POINT_NAME) + nameLen -
4627 sizeof(CERT_ALT_NAME_INFO);
4628 }
4629 else
4630 bytesNeeded = sizeof(CRL_DIST_POINT_NAME);
4631 if (pcbDecoded)
4632 *pcbDecoded = 1 + lenBytes + dataLen;
4633 if (!pvStructInfo)
4634 *pcbStructInfo = bytesNeeded;
4635 else if (*pcbStructInfo < bytesNeeded)
4636 {
4637 *pcbStructInfo = bytesNeeded;
4638 SetLastError(ERROR_MORE_DATA);
4639 ret = FALSE;
4640 }
4641 else
4642 {
4643 CRL_DIST_POINT_NAME *name = (CRL_DIST_POINT_NAME *)pvStructInfo;
4644
4645 *pcbStructInfo = bytesNeeded;
4646 if (dataLen)
4647 {
4648 name->dwDistPointNameChoice = CRL_DIST_POINT_FULL_NAME;
4649 ret = CRYPT_AsnDecodeArray(&arrayDesc,
4650 pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
4651 0, NULL, &name->u.FullName, &nameLen, NULL,
4652 name->u.FullName.rgAltEntry);
4653 }
4654 else
4655 name->dwDistPointNameChoice = CRL_DIST_POINT_NO_NAME;
4656 }
4657 }
4658 }
4659 else
4660 {
4661 SetLastError(CRYPT_E_ASN1_BADTAG);
4662 ret = FALSE;
4663 }
4664 return ret;
4665 }
4666
4667 static BOOL CRYPT_AsnDecodeDistPoint(const BYTE *pbEncoded, DWORD cbEncoded,
4668 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
4669 {
4670 struct AsnDecodeSequenceItem items[] = {
4671 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CRL_DIST_POINT,
4672 DistPointName), CRYPT_AsnDecodeDistPointName,
4673 sizeof(CRL_DIST_POINT_NAME), TRUE, TRUE, offsetof(CRL_DIST_POINT,
4674 DistPointName.u.FullName.rgAltEntry), 0 },
4675 { ASN_CONTEXT | 1, offsetof(CRL_DIST_POINT, ReasonFlags),
4676 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
4677 offsetof(CRL_DIST_POINT, ReasonFlags.pbData), 0 },
4678 { ASN_CONTEXT | ASN_CONSTRUCTOR | 2, offsetof(CRL_DIST_POINT, CRLIssuer),
4679 CRYPT_AsnDecodeAltNameInternal, sizeof(CERT_ALT_NAME_INFO), TRUE, TRUE,
4680 offsetof(CRL_DIST_POINT, CRLIssuer.rgAltEntry), 0 },
4681 };
4682 CRL_DIST_POINT *point = (CRL_DIST_POINT *)pvStructInfo;
4683 BOOL ret;
4684
4685 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4686 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
4687 pcbDecoded, point ? point->DistPointName.u.FullName.rgAltEntry : NULL);
4688 return ret;
4689 }
4690
4691 static BOOL WINAPI CRYPT_AsnDecodeCRLDistPoints(DWORD dwCertEncodingType,
4692 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4693 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4694 {
4695 BOOL ret;
4696
4697 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4698 pDecodePara, pvStructInfo, *pcbStructInfo);
4699
4700 __TRY
4701 {
4702 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
4703 CRYPT_AsnDecodeDistPoint, sizeof(CRL_DIST_POINT), TRUE,
4704 offsetof(CRL_DIST_POINT, DistPointName.u.FullName.rgAltEntry) };
4705
4706 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
4707 pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
4708 }
4709 __EXCEPT_PAGE_FAULT
4710 {
4711 SetLastError(STATUS_ACCESS_VIOLATION);
4712 ret = FALSE;
4713 }
4714 __ENDTRY
4715 return ret;
4716 }
4717
4718 static BOOL WINAPI CRYPT_AsnDecodeEnhancedKeyUsage(DWORD dwCertEncodingType,
4719 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4720 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4721 {
4722 BOOL ret;
4723
4724 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4725 pDecodePara, pvStructInfo, *pcbStructInfo);
4726
4727 __TRY
4728 {
4729 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
4730 CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), TRUE, 0 };
4731
4732 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
4733 pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
4734 }
4735 __EXCEPT_PAGE_FAULT
4736 {
4737 SetLastError(STATUS_ACCESS_VIOLATION);
4738 ret = FALSE;
4739 }
4740 __ENDTRY
4741 return ret;
4742 }
4743
4744 static BOOL WINAPI CRYPT_AsnDecodeIssuingDistPoint(DWORD dwCertEncodingType,
4745 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4746 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4747 {
4748 BOOL ret;
4749
4750 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4751 pDecodePara, pvStructInfo, *pcbStructInfo);
4752
4753 __TRY
4754 {
4755 struct AsnDecodeSequenceItem items[] = {
4756 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CRL_ISSUING_DIST_POINT,
4757 DistPointName), CRYPT_AsnDecodeDistPointName,
4758 sizeof(CRL_DIST_POINT_NAME), TRUE, TRUE,
4759 offsetof(CRL_ISSUING_DIST_POINT,
4760 DistPointName.u.FullName.rgAltEntry), 0 },
4761 { ASN_CONTEXT | 1, offsetof(CRL_ISSUING_DIST_POINT,
4762 fOnlyContainsUserCerts), CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE,
4763 FALSE, 0 },
4764 { ASN_CONTEXT | 2, offsetof(CRL_ISSUING_DIST_POINT,
4765 fOnlyContainsCACerts), CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE,
4766 FALSE, 0 },
4767 { ASN_CONTEXT | 3, offsetof(CRL_ISSUING_DIST_POINT,
4768 OnlySomeReasonFlags), CRYPT_AsnDecodeBitsInternal,
4769 sizeof(CRYPT_BIT_BLOB), TRUE, TRUE, offsetof(CRL_ISSUING_DIST_POINT,
4770 OnlySomeReasonFlags.pbData), 0 },
4771 { ASN_CONTEXT | 4, offsetof(CRL_ISSUING_DIST_POINT,
4772 fIndirectCRL), CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE, FALSE, 0 },
4773 };
4774
4775 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4776 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
4777 pcbStructInfo, NULL, NULL);
4778 }
4779 __EXCEPT_PAGE_FAULT
4780 {
4781 SetLastError(STATUS_ACCESS_VIOLATION);
4782 ret = FALSE;
4783 }
4784 __ENDTRY
4785 return ret;
4786 }
4787
4788 static BOOL CRYPT_AsnDecodeMaximum(const BYTE *pbEncoded,
4789 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4790 DWORD *pcbDecoded)
4791 {
4792 BOOL ret = FALSE;
4793
4794 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
4795 pvStructInfo, *pcbStructInfo, pcbDecoded);
4796
4797 if (!cbEncoded)
4798 {
4799 SetLastError(CRYPT_E_ASN1_EOD);
4800 return FALSE;
4801 }
4802 if (pbEncoded[0] != (ASN_CONTEXT | 1))
4803 {
4804 SetLastError(CRYPT_E_ASN1_BADTAG);
4805 return FALSE;
4806 }
4807 /* The BOOL is implicit: if the integer is present, then it's TRUE */
4808 ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags,
4809 pvStructInfo ? (BYTE *)pvStructInfo + sizeof(BOOL) : NULL, pcbStructInfo,
4810 pcbDecoded);
4811 if (ret && pvStructInfo)
4812 *(BOOL *)pvStructInfo = TRUE;
4813 TRACE("returning %d\n", ret);
4814 return ret;
4815 }
4816
4817 static BOOL CRYPT_AsnDecodeSubtree(const BYTE *pbEncoded,
4818 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4819 DWORD *pcbDecoded)
4820 {
4821 BOOL ret;
4822 struct AsnDecodeSequenceItem items[] = {
4823 { 0, offsetof(CERT_GENERAL_SUBTREE, Base),
4824 CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), TRUE, TRUE,
4825 offsetof(CERT_ALT_NAME_ENTRY, u.pwszURL), 0 },
4826 { ASN_CONTEXT | 0, offsetof(CERT_GENERAL_SUBTREE, dwMinimum),
4827 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), TRUE, FALSE, 0, 0 },
4828 { ASN_CONTEXT | 1, offsetof(CERT_GENERAL_SUBTREE, fMaximum),
4829 CRYPT_AsnDecodeMaximum, sizeof(BOOL) + sizeof(DWORD), TRUE, FALSE, 0,
4830 0 },
4831 };
4832 CERT_GENERAL_SUBTREE *subtree = (CERT_GENERAL_SUBTREE *)pvStructInfo;
4833
4834 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
4835 pvStructInfo, *pcbStructInfo, pcbDecoded);
4836
4837 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4838 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
4839 pcbDecoded, subtree ? (BYTE *)subtree->Base.u.pwszURL : NULL);
4840 if (pcbDecoded)
4841 {
4842 TRACE("%d\n", *pcbDecoded);
4843 if (*pcbDecoded < cbEncoded)
4844 TRACE("%02x %02x\n", *(pbEncoded + *pcbDecoded),
4845 *(pbEncoded + *pcbDecoded + 1));
4846 }
4847 TRACE("returning %d\n", ret);
4848 return ret;
4849 }
4850
4851 static BOOL CRYPT_AsnDecodeSubtreeArray(const BYTE *pbEncoded,
4852 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4853 DWORD *pcbDecoded)
4854 {
4855 BOOL ret = TRUE;
4856 struct AsnArrayDescriptor arrayDesc = { 0,
4857 CRYPT_AsnDecodeSubtree, sizeof(CERT_GENERAL_SUBTREE), TRUE,
4858 offsetof(CERT_GENERAL_SUBTREE, Base.u.pwszURL) };
4859 struct GenericArray *array = (struct GenericArray *)pvStructInfo;
4860
4861 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
4862 pvStructInfo, *pcbStructInfo, pcbDecoded);
4863
4864 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
4865 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
4866 array ? array->rgItems : NULL);
4867 return ret;
4868 }
4869
4870
4871 static BOOL WINAPI CRYPT_AsnDecodeNameConstraints(DWORD dwCertEncodingType,
4872 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4873 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4874 {
4875 BOOL ret = FALSE;
4876
4877 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4878 pDecodePara, pvStructInfo, *pcbStructInfo);
4879
4880 __TRY
4881 {
4882 struct AsnDecodeSequenceItem items[] = {
4883 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0,
4884 offsetof(CERT_NAME_CONSTRAINTS_INFO, cPermittedSubtree),
4885 CRYPT_AsnDecodeSubtreeArray, sizeof(struct GenericArray), TRUE, TRUE,
4886 offsetof(CERT_NAME_CONSTRAINTS_INFO, rgPermittedSubtree), 0 },
4887 { ASN_CONTEXT | ASN_CONSTRUCTOR | 1,
4888 offsetof(CERT_NAME_CONSTRAINTS_INFO, cExcludedSubtree),
4889 CRYPT_AsnDecodeSubtreeArray, sizeof(struct GenericArray), TRUE, TRUE,
4890 offsetof(CERT_NAME_CONSTRAINTS_INFO, rgExcludedSubtree), 0 },
4891 };
4892
4893 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4894 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
4895 pcbStructInfo, NULL, NULL);
4896 }
4897 __EXCEPT_PAGE_FAULT
4898 {
4899 SetLastError(STATUS_ACCESS_VIOLATION);
4900 }
4901 __ENDTRY
4902 return ret;
4903 }
4904
4905 static BOOL CRYPT_AsnDecodeIssuerSerialNumber(const BYTE *pbEncoded,
4906 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4907 DWORD *pcbDecoded)
4908 {
4909 BOOL ret;
4910 struct AsnDecodeSequenceItem items[] = {
4911 { 0, offsetof(CERT_ISSUER_SERIAL_NUMBER, Issuer), CRYPT_AsnDecodeDerBlob,
4912 sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CERT_ISSUER_SERIAL_NUMBER,
4913 Issuer.pbData) },
4914 { ASN_INTEGER, offsetof(CERT_ISSUER_SERIAL_NUMBER, SerialNumber),
4915 CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), FALSE,
4916 TRUE, offsetof(CERT_ISSUER_SERIAL_NUMBER, SerialNumber.pbData), 0 },
4917 };
4918 CERT_ISSUER_SERIAL_NUMBER *issuerSerial =
4919 (CERT_ISSUER_SERIAL_NUMBER *)pvStructInfo;
4920
4921 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
4922 pvStructInfo, *pcbStructInfo, pcbDecoded);
4923
4924 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4925 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
4926 pcbDecoded, issuerSerial ? issuerSerial->Issuer.pbData : NULL);
4927 if (ret && issuerSerial && !issuerSerial->SerialNumber.cbData)
4928 {
4929 SetLastError(CRYPT_E_ASN1_CORRUPT);
4930 ret = FALSE;
4931 }
4932 TRACE("returning %d\n", ret);
4933 return ret;
4934 }
4935
4936 static BOOL CRYPT_AsnDecodePKCSSignerInfoInternal(const BYTE *pbEncoded,
4937 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4938 DWORD *pcbDecoded)
4939 {
4940 CMSG_SIGNER_INFO *info = (CMSG_SIGNER_INFO *)pvStructInfo;
4941 struct AsnDecodeSequenceItem items[] = {
4942 { ASN_INTEGER, offsetof(CMSG_SIGNER_INFO, dwVersion),
4943 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
4944 { ASN_SEQUENCEOF, offsetof(CMSG_SIGNER_INFO, Issuer),
4945 CRYPT_AsnDecodeIssuerSerialNumber, sizeof(CERT_ISSUER_SERIAL_NUMBER),
4946 FALSE, TRUE, offsetof(CMSG_SIGNER_INFO, Issuer.pbData), 0 },
4947 { ASN_SEQUENCEOF, offsetof(CMSG_SIGNER_INFO, HashAlgorithm),
4948 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
4949 FALSE, TRUE, offsetof(CMSG_SIGNER_INFO, HashAlgorithm.pszObjId), 0 },
4950 { ASN_CONSTRUCTOR | ASN_CONTEXT | 0,
4951 offsetof(CMSG_SIGNER_INFO, AuthAttrs),
4952 CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
4953 TRUE, TRUE, offsetof(CMSG_SIGNER_INFO, AuthAttrs.rgAttr), 0 },
4954 { ASN_SEQUENCEOF, offsetof(CMSG_SIGNER_INFO, HashEncryptionAlgorithm),
4955 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
4956 FALSE, TRUE, offsetof(CMSG_SIGNER_INFO,
4957 HashEncryptionAlgorithm.pszObjId), 0 },
4958 { ASN_OCTETSTRING, offsetof(CMSG_SIGNER_INFO, EncryptedHash),
4959 CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_DER_BLOB),
4960 FALSE, TRUE, offsetof(CMSG_SIGNER_INFO, EncryptedHash.pbData), 0 },
4961 { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
4962 offsetof(CMSG_SIGNER_INFO, UnauthAttrs),
4963 CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
4964 TRUE, TRUE, offsetof(CMSG_SIGNER_INFO, UnauthAttrs.rgAttr), 0 },
4965 };
4966 BOOL ret;
4967
4968 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4969 pvStructInfo, *pcbStructInfo);
4970
4971 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4972 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
4973 pcbDecoded, info ? info->Issuer.pbData : NULL);
4974 return ret;
4975 }
4976
4977 static BOOL WINAPI CRYPT_AsnDecodePKCSSignerInfo(DWORD dwCertEncodingType,
4978 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4979 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4980 {
4981 BOOL ret = FALSE;
4982
4983 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4984 pDecodePara, pvStructInfo, *pcbStructInfo);
4985
4986 __TRY
4987 {
4988 ret = CRYPT_AsnDecodePKCSSignerInfoInternal(pbEncoded, cbEncoded,
4989 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
4990 if (ret && pvStructInfo)
4991 {
4992 ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
4993 pcbStructInfo, *pcbStructInfo);
4994 if (ret)
4995 {
4996 CMSG_SIGNER_INFO *info;
4997
4998 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4999 pvStructInfo = *(BYTE **)pvStructInfo;
5000 info = (CMSG_SIGNER_INFO *)pvStructInfo;
5001 info->Issuer.pbData = ((BYTE *)info +
5002 sizeof(CMSG_SIGNER_INFO));
5003 ret = CRYPT_AsnDecodePKCSSignerInfoInternal(pbEncoded,
5004 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
5005 pcbStructInfo, NULL);
5006 }
5007 }
5008 }
5009 __EXCEPT_PAGE_FAULT
5010 {
5011 SetLastError(STATUS_ACCESS_VIOLATION);
5012 }
5013 __ENDTRY
5014 TRACE("returning %d\n", ret);
5015 return ret;
5016 }
5017
5018 static BOOL CRYPT_AsnDecodeCMSSignerId(const BYTE *pbEncoded,
5019 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
5020 DWORD *pcbDecoded)
5021 {
5022 CERT_ID *id = (CERT_ID *)pvStructInfo;
5023 BOOL ret = FALSE;
5024
5025 if (*pbEncoded == ASN_SEQUENCEOF)
5026 {
5027 ret = CRYPT_AsnDecodeIssuerSerialNumber(pbEncoded, cbEncoded, dwFlags,
5028 id ? &id->u.IssuerSerialNumber : NULL, pcbStructInfo, pcbDecoded);
5029 if (ret)
5030 {
5031 if (id)
5032 id->dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
5033 if (*pcbStructInfo > sizeof(CERT_ISSUER_SERIAL_NUMBER))
5034 *pcbStructInfo = sizeof(CERT_ID) + *pcbStructInfo -
5035 sizeof(CERT_ISSUER_SERIAL_NUMBER);
5036 else
5037 *pcbStructInfo = sizeof(CERT_ID);
5038 }
5039 }
5040 else if (*pbEncoded == (ASN_CONTEXT | 0))
5041 {
5042 ret = CRYPT_AsnDecodeOctetsInternal(pbEncoded, cbEncoded, dwFlags,
5043 id ? &id->u.KeyId : NULL, pcbStructInfo, pcbDecoded);
5044 if (ret)
5045 {
5046 if (id)
5047 id->dwIdChoice = CERT_ID_KEY_IDENTIFIER;
5048 if (*pcbStructInfo > sizeof(CRYPT_DATA_BLOB))
5049 *pcbStructInfo = sizeof(CERT_ID) + *pcbStructInfo -
5050 sizeof(CRYPT_DATA_BLOB);
5051 else
5052 *pcbStructInfo = sizeof(CERT_ID);
5053 }
5054 }
5055 else
5056 SetLastError(CRYPT_E_ASN1_BADTAG);
5057 return ret;
5058 }
5059
5060 static BOOL CRYPT_AsnDecodeCMSSignerInfoInternal(const BYTE *pbEncoded,
5061 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
5062 DWORD *pcbDecoded)
5063 {
5064 CMSG_CMS_SIGNER_INFO *info = (CMSG_CMS_SIGNER_INFO *)pvStructInfo;
5065 struct AsnDecodeSequenceItem items[] = {
5066 { ASN_INTEGER, offsetof(CMSG_CMS_SIGNER_INFO, dwVersion),
5067 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
5068 { 0, offsetof(CMSG_CMS_SIGNER_INFO, SignerId),
5069 CRYPT_AsnDecodeCMSSignerId, sizeof(CERT_ID), FALSE, TRUE,
5070 offsetof(CMSG_CMS_SIGNER_INFO, SignerId.u.KeyId.pbData), 0 },
5071 { ASN_SEQUENCEOF, offsetof(CMSG_CMS_SIGNER_INFO, HashAlgorithm),
5072 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
5073 FALSE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, HashAlgorithm.pszObjId), 0 },
5074 { ASN_CONSTRUCTOR | ASN_CONTEXT | 0,
5075 offsetof(CMSG_CMS_SIGNER_INFO, AuthAttrs),
5076 CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
5077 TRUE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, AuthAttrs.rgAttr), 0 },
5078 { ASN_SEQUENCEOF, offsetof(CMSG_CMS_SIGNER_INFO, HashEncryptionAlgorithm),
5079 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
5080 FALSE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO,
5081 HashEncryptionAlgorithm.pszObjId), 0 },
5082 { ASN_OCTETSTRING, offsetof(CMSG_CMS_SIGNER_INFO, EncryptedHash),
5083 CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_DER_BLOB),
5084 FALSE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, EncryptedHash.pbData), 0 },
5085 { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
5086 offsetof(CMSG_CMS_SIGNER_INFO, UnauthAttrs),
5087 CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
5088 TRUE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, UnauthAttrs.rgAttr), 0 },
5089 };
5090 BOOL ret;
5091
5092 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
5093 pvStructInfo, *pcbStructInfo);
5094
5095 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
5096 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
5097 pcbDecoded, info ? info->SignerId.u.KeyId.pbData : NULL);
5098 return ret;
5099 }
5100
5101 static BOOL WINAPI CRYPT_AsnDecodeCMSSignerInfo(DWORD dwCertEncodingType,
5102 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
5103 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
5104 {
5105 BOOL ret = FALSE;
5106
5107 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
5108 pDecodePara, pvStructInfo, *pcbStructInfo);
5109
5110 __TRY
5111 {
5112 ret = CRYPT_AsnDecodeCMSSignerInfoInternal(pbEncoded, cbEncoded,
5113 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
5114 if (ret && pvStructInfo)
5115 {
5116 ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
5117 pcbStructInfo, *pcbStructInfo);
5118 if (ret)
5119 {
5120 CMSG_CMS_SIGNER_INFO *info;
5121
5122 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
5123 pvStructInfo = *(BYTE **)pvStructInfo;
5124 info = (CMSG_CMS_SIGNER_INFO *)pvStructInfo;
5125 info->SignerId.u.KeyId.pbData = ((BYTE *)info +
5126 sizeof(CMSG_CMS_SIGNER_INFO));
5127 ret = CRYPT_AsnDecodeCMSSignerInfoInternal(pbEncoded,
5128 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
5129 pcbStructInfo, NULL);
5130 }
5131 }
5132 }
5133 __EXCEPT_PAGE_FAULT
5134 {
5135 SetLastError(STATUS_ACCESS_VIOLATION);
5136 }
5137 __ENDTRY
5138 TRACE("returning %d\n", ret);
5139 return ret;
5140 }
5141
5142 static BOOL CRYPT_DecodeSignerArray(const BYTE *pbEncoded, DWORD cbEncoded,
5143 DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
5144 {
5145 BOOL ret;
5146 struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
5147 CRYPT_AsnDecodeCMSSignerInfoInternal, sizeof(CMSG_CMS_SIGNER_INFO), TRUE,
5148 offsetof(CMSG_CMS_SIGNER_INFO, SignerId.u.KeyId.pbData) };
5149 struct GenericArray *array = (struct GenericArray *)pvStructInfo;
5150
5151 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
5152 pvStructInfo, *pcbStructInfo, pcbDecoded);
5153
5154 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
5155 NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
5156 array ? array->rgItems : NULL);
5157 return ret;
5158 }
5159
5160 BOOL CRYPT_AsnDecodeCMSSignedInfo(const BYTE *pbEncoded, DWORD cbEncoded,
5161 DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
5162 CRYPT_SIGNED_INFO *signedInfo, DWORD *pcbSignedInfo)
5163 {
5164 BOOL ret = FALSE;
5165 struct AsnDecodeSequenceItem items[] = {
5166 { ASN_INTEGER, offsetof(CRYPT_SIGNED_INFO, version),
5167 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
5168 /* Placeholder for the hash algorithms - redundant with those in the
5169 * signers, so just ignore them.
5170 */
5171 { ASN_CONSTRUCTOR | ASN_SETOF, 0, NULL, 0, TRUE, FALSE, 0, 0 },
5172 { ASN_SEQUENCE, offsetof(CRYPT_SIGNED_INFO, content),
5173 CRYPT_AsnDecodePKCSContentInfoInternal, sizeof(CRYPT_CONTENT_INFO),
5174 FALSE, TRUE, offsetof(CRYPT_SIGNED_INFO, content.pszObjId), 0 },
5175 { ASN_CONSTRUCTOR | ASN_CONTEXT | 0,
5176 offsetof(CRYPT_SIGNED_INFO, cCertEncoded),
5177 CRYPT_DecodeDERArray, sizeof(struct GenericArray), TRUE, TRUE,
5178 offsetof(CRYPT_SIGNED_INFO, rgCertEncoded), 0 },
5179 { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
5180 offsetof(CRYPT_SIGNED_INFO, cCrlEncoded), CRYPT_DecodeDERArray,
5181 sizeof(struct GenericArray), TRUE, TRUE,
5182 offsetof(CRYPT_SIGNED_INFO, rgCrlEncoded), 0 },
5183 { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CRYPT_SIGNED_INFO, cSignerInfo),
5184 CRYPT_DecodeSignerArray, sizeof(struct GenericArray), TRUE, TRUE,
5185 offsetof(CRYPT_SIGNED_INFO, rgSignerInfo), 0 },
5186 };
5187
5188 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
5189 pDecodePara, signedInfo, *pcbSignedInfo);
5190
5191 ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
5192 pbEncoded, cbEncoded, dwFlags, pDecodePara, signedInfo, pcbSignedInfo,
5193 NULL, NULL);
5194 TRACE("returning %d\n", ret);
5195 return ret;
5196 }
5197
5198 static CryptDecodeObjectExFunc CRYPT_GetBuiltinDecoder(DWORD dwCertEncodingType,
5199 LPCSTR lpszStructType)
5200 {
5201 CryptDecodeObjectExFunc decodeFunc = NULL;
5202
5203 if ((dwCertEncodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING
5204 && (dwCertEncodingType & CMSG_ENCODING_TYPE_MASK) != PKCS_7_ASN_ENCODING)
5205 {
5206 SetLastError(ERROR_FILE_NOT_FOUND);
5207 return NULL;
5208 }
5209 if (!HIWORD(lpszStructType))
5210 {
5211 switch (LOWORD(lpszStructType))
5212 {
5213 case LOWORD(X509_CERT):
5214 decodeFunc = CRYPT_AsnDecodeCertSignedContent;
5215 break;
5216 case LOWORD(X509_CERT_TO_BE_SIGNED):
5217 decodeFunc = CRYPT_AsnDecodeCert;
5218 break;
5219 case LOWORD(X509_CERT_CRL_TO_BE_SIGNED):
5220 decodeFunc = CRYPT_AsnDecodeCRL;
5221 break;
5222 case LOWORD(X509_EXTENSIONS):
5223 decodeFunc = CRYPT_AsnDecodeExtensions;
5224 break;
5225 case LOWORD(X509_NAME_VALUE):
5226 decodeFunc = CRYPT_AsnDecodeNameValue;
5227 break;
5228 case LOWORD(X509_NAME):
5229 decodeFunc = CRYPT_AsnDecodeName;
5230 break;
5231 case LOWORD(X509_PUBLIC_KEY_INFO):
5232 decodeFunc = CRYPT_AsnDecodePubKeyInfo;
5233 break;
5234 case LOWORD(X509_AUTHORITY_KEY_ID):
5235 decodeFunc = CRYPT_AsnDecodeAuthorityKeyId;
5236 break;
5237 case LOWORD(X509_ALTERNATE_NAME):
5238 decodeFunc = CRYPT_AsnDecodeAltName;
5239 break;
5240 case LOWORD(X509_BASIC_CONSTRAINTS):
5241 decodeFunc = CRYPT_AsnDecodeBasicConstraints;
5242 break;
5243 case LOWORD(X509_BASIC_CONSTRAINTS2):
5244 decodeFunc = CRYPT_AsnDecodeBasicConstraints2;
5245 break;
5246 case LOWORD(X509_CERT_POLICIES):
5247 decodeFunc = CRYPT_AsnDecodeCertPolicies;
5248 break;
5249 case LOWORD(RSA_CSP_PUBLICKEYBLOB):
5250 decodeFunc = CRYPT_AsnDecodeRsaPubKey;
5251 break;
5252 case LOWORD(X509_UNICODE_NAME):
5253 decodeFunc = CRYPT_AsnDecodeUnicodeName;
5254 break;
5255 case LOWORD(PKCS_ATTRIBUTE):
5256 decodeFunc = CRYPT_AsnDecodePKCSAttribute;
5257 break;
5258 case LOWORD(X509_UNICODE_NAME_VALUE):
5259 decodeFunc = CRYPT_AsnDecodeUnicodeNameValue;
5260 break;
5261 case LOWORD(X509_OCTET_STRING):
5262 decodeFunc = CRYPT_AsnDecodeOctets;
5263 break;
5264 case LOWORD(X509_BITS):
5265 case LOWORD(X509_KEY_USAGE):
5266 decodeFunc = CRYPT_AsnDecodeBits;
5267 break;
5268 case LOWORD(X509_INTEGER):
5269 decodeFunc = CRYPT_AsnDecodeInt;
5270 break;
5271 case LOWORD(X509_MULTI_BYTE_INTEGER):
5272 decodeFunc = CRYPT_AsnDecodeInteger;
5273 break;
5274 case LOWORD(X509_MULTI_BYTE_UINT):
5275 decodeFunc = CRYPT_AsnDecodeUnsignedInteger;
5276 break;
5277 case LOWORD(X509_ENUMERATED):
5278 decodeFunc = CRYPT_AsnDecodeEnumerated;
5279 break;
5280 case LOWORD(X509_CHOICE_OF_TIME):
5281 decodeFunc = CRYPT_AsnDecodeChoiceOfTime;
5282 break;
5283 case LOWORD(X509_AUTHORITY_KEY_ID2):
5284 decodeFunc = CRYPT_AsnDecodeAuthorityKeyId2;
5285 break;
5286 case LOWORD(X509_AUTHORITY_INFO_ACCESS):
5287 decodeFunc = CRYPT_AsnDecodeAuthorityInfoAccess;
5288 break;
5289 case LOWORD(PKCS_CONTENT_INFO):
5290 decodeFunc = CRYPT_AsnDecodePKCSContentInfo;
5291 break;
5292 case LOWORD(X509_SEQUENCE_OF_ANY):
5293 decodeFunc = CRYPT_AsnDecodeSequenceOfAny;
5294 break;
5295 case LOWORD(PKCS_UTC_TIME):
5296 decodeFunc = CRYPT_AsnDecodeUtcTime;
5297 break;
5298 case LOWORD(X509_CRL_DIST_POINTS):
5299 decodeFunc = CRYPT_AsnDecodeCRLDistPoints;
5300 break;
5301 case LOWORD(X509_ENHANCED_KEY_USAGE):
5302 decodeFunc = CRYPT_AsnDecodeEnhancedKeyUsage;
5303 break;
5304 case LOWORD(PKCS_CTL):
5305 decodeFunc = CRYPT_AsnDecodeCTL;
5306 break;
5307 case LOWORD(PKCS_SMIME_CAPABILITIES):
5308 decodeFunc = CRYPT_AsnDecodeSMIMECapabilities;
5309 break;
5310 case LOWORD(X509_PKIX_POLICY_QUALIFIER_USERNOTICE):
5311 decodeFunc = CRYPT_AsnDecodePolicyQualifierUserNotice;
5312 break;
5313 case LOWORD(PKCS_ATTRIBUTES):
5314 decodeFunc = CRYPT_AsnDecodePKCSAttributes;
5315 break;
5316 case LOWORD(X509_ISSUING_DIST_POINT):
5317 decodeFunc = CRYPT_AsnDecodeIssuingDistPoint;
5318 break;
5319 case LOWORD(X509_NAME_CONSTRAINTS):
5320 decodeFunc = CRYPT_AsnDecodeNameConstraints;
5321 break;
5322 case LOWORD(PKCS7_SIGNER_INFO):
5323 decodeFunc = CRYPT_AsnDecodePKCSSignerInfo;
5324 break;
5325 case LOWORD(CMS_SIGNER_INFO):
5326 decodeFunc = CRYPT_AsnDecodeCMSSignerInfo;
5327 break;
5328 }
5329 }
5330 else if (!strcmp(lpszStructType, szOID_CERT_EXTENSIONS))
5331 decodeFunc = CRYPT_AsnDecodeExtensions;
5332 else if (!strcmp(lpszStructType, szOID_RSA_signingTime))
5333 decodeFunc = CRYPT_AsnDecodeUtcTime;
5334 else if (!strcmp(lpszStructType, szOID_RSA_SMIMECapabilities))
5335 decodeFunc = CRYPT_AsnDecodeSMIMECapabilities;
5336 else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER))
5337 decodeFunc = CRYPT_AsnDecodeAuthorityKeyId;
5338 else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER2))
5339 decodeFunc = CRYPT_AsnDecodeAuthorityKeyId2;
5340 else if (!strcmp(lpszStructType, szOID_CRL_REASON_CODE))
5341 decodeFunc = CRYPT_AsnDecodeEnumerated;
5342 else if (!strcmp(lpszStructType, szOID_KEY_USAGE))
5343 decodeFunc = CRYPT_AsnDecodeBits;
5344 else if (!strcmp(lpszStructType, szOID_SUBJECT_KEY_IDENTIFIER))
5345 decodeFunc = CRYPT_AsnDecodeOctets;
5346 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS))
5347 decodeFunc = CRYPT_AsnDecodeBasicConstraints;
5348 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS2))
5349 decodeFunc = CRYPT_AsnDecodeBasicConstraints2;
5350 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME))
5351 decodeFunc = CRYPT_AsnDecodeAltName;
5352 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME2))
5353 decodeFunc = CRYPT_AsnDecodeAltName;
5354 else if (!strcmp(lpszStructType, szOID_NEXT_UPDATE_LOCATION))
5355 decodeFunc = CRYPT_AsnDecodeAltName;
5356 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME))
5357 decodeFunc = CRYPT_AsnDecodeAltName;
5358 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME2))
5359 decodeFunc = CRYPT_AsnDecodeAltName;
5360 else if (!strcmp(lpszStructType, szOID_CRL_DIST_POINTS))
5361 decodeFunc = CRYPT_AsnDecodeCRLDistPoints;
5362 else if (!strcmp(lpszStructType, szOID_CERT_POLICIES))
5363 decodeFunc = CRYPT_AsnDecodeCertPolicies;
5364 else if (!strcmp(lpszStructType, szOID_ENHANCED_KEY_USAGE))
5365 decodeFunc = CRYPT_AsnDecodeEnhancedKeyUsage;
5366 else if (!strcmp(lpszStructType, szOID_ISSUING_DIST_POINT))
5367 decodeFunc = CRYPT_AsnDecodeIssuingDistPoint;
5368 else if (!strcmp(lpszStructType, szOID_NAME_CONSTRAINTS))
5369 decodeFunc = CRYPT_AsnDecodeNameConstraints;
5370 else if (!strcmp(lpszStructType, szOID_AUTHORITY_INFO_ACCESS))
5371 decodeFunc = CRYPT_AsnDecodeAuthorityInfoAccess;
5372 else if (!strcmp(lpszStructType, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE))
5373 decodeFunc = CRYPT_AsnDecodePolicyQualifierUserNotice;
5374 else if (!strcmp(lpszStructType, szOID_CTL))
5375 decodeFunc = CRYPT_AsnDecodeCTL;
5376 return decodeFunc;
5377 }
5378
5379 static CryptDecodeObjectFunc CRYPT_LoadDecoderFunc(DWORD dwCertEncodingType,
5380 LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
5381 {
5382 static HCRYPTOIDFUNCSET set = NULL;
5383 CryptDecodeObjectFunc decodeFunc = NULL;
5384
5385 if (!set)
5386 set = CryptInitOIDFunctionSet(CRYPT_OID_DECODE_OBJECT_FUNC, 0);
5387 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
5388 (void **)&decodeFunc, hFunc);
5389 return decodeFunc;
5390 }
5391
5392 static CryptDecodeObjectExFunc CRYPT_LoadDecoderExFunc(DWORD dwCertEncodingType,
5393 LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
5394 {
5395 static HCRYPTOIDFUNCSET set = NULL;
5396 CryptDecodeObjectExFunc decodeFunc = NULL;
5397
5398 if (!set)
5399 set = CryptInitOIDFunctionSet(CRYPT_OID_DECODE_OBJECT_EX_FUNC, 0);
5400 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
5401 (void **)&decodeFunc, hFunc);
5402 return decodeFunc;
5403 }
5404
5405 BOOL WINAPI CryptDecodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType,
5406 const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo,
5407 DWORD *pcbStructInfo)
5408 {
5409 BOOL ret = FALSE;
5410 CryptDecodeObjectFunc pCryptDecodeObject = NULL;
5411 CryptDecodeObjectExFunc pCryptDecodeObjectEx = NULL;
5412 HCRYPTOIDFUNCADDR hFunc = NULL;
5413
5414 TRACE_(crypt)("(0x%08x, %s, %p, %d, 0x%08x, %p, %p)\n", dwCertEncodingType,
5415 debugstr_a(lpszStructType), pbEncoded, cbEncoded, dwFlags,
5416 pvStructInfo, pcbStructInfo);
5417
5418 if (!pvStructInfo && !pcbStructInfo)
5419 {
5420 SetLastError(ERROR_INVALID_PARAMETER);
5421 return FALSE;
5422 }
5423 if (cbEncoded > MAX_ENCODED_LEN)
5424 {
5425 SetLastError(CRYPT_E_ASN1_LARGE);
5426 return FALSE;
5427 }
5428
5429 if (!(pCryptDecodeObjectEx = CRYPT_GetBuiltinDecoder(dwCertEncodingType,
5430 lpszStructType)))
5431 {
5432 TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n",
5433 debugstr_a(lpszStructType));
5434 pCryptDecodeObject = CRYPT_LoadDecoderFunc(dwCertEncodingType,
5435 lpszStructType, &hFunc);
5436 if (!pCryptDecodeObject)
5437 pCryptDecodeObjectEx = CRYPT_LoadDecoderExFunc(dwCertEncodingType,
5438 lpszStructType, &hFunc);
5439 }
5440 if (pCryptDecodeObject)
5441 ret = pCryptDecodeObject(dwCertEncodingType, lpszStructType,
5442 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo);
5443 else if (pCryptDecodeObjectEx)
5444 ret = pCryptDecodeObjectEx(dwCertEncodingType, lpszStructType,
5445 pbEncoded, cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL,
5446 pvStructInfo, pcbStructInfo);
5447 if (hFunc)
5448 CryptFreeOIDFunctionAddress(hFunc, 0);
5449 TRACE_(crypt)("returning %d\n", ret);
5450 return ret;
5451 }
5452
5453 BOOL WINAPI CryptDecodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType,
5454 const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
5455 PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
5456 {
5457 BOOL ret = FALSE;
5458 CryptDecodeObjectExFunc decodeFunc;
5459 HCRYPTOIDFUNCADDR hFunc = NULL;
5460
5461 TRACE_(crypt)("(0x%08x, %s, %p, %d, 0x%08x, %p, %p, %p)\n",
5462 dwCertEncodingType, debugstr_a(lpszStructType), pbEncoded,
5463 cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo);
5464
5465 if (!pvStructInfo && !pcbStructInfo)
5466 {
5467 SetLastError(ERROR_INVALID_PARAMETER);
5468 return FALSE;
5469 }
5470 if (cbEncoded > MAX_ENCODED_LEN)
5471 {
5472 SetLastError(CRYPT_E_ASN1_LARGE);
5473 return FALSE;
5474 }
5475
5476 SetLastError(NOERROR);
5477 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG && pvStructInfo)
5478 *(BYTE **)pvStructInfo = NULL;
5479 decodeFunc = CRYPT_GetBuiltinDecoder(dwCertEncodingType, lpszStructType);
5480 if (!decodeFunc)
5481 {
5482 TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n",
5483 debugstr_a(lpszStructType));
5484 decodeFunc = CRYPT_LoadDecoderExFunc(dwCertEncodingType, lpszStructType,
5485 &hFunc);
5486 }
5487 if (decodeFunc)
5488 ret = decodeFunc(dwCertEncodingType, lpszStructType, pbEncoded,
5489 cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo);
5490 else
5491 {
5492 CryptDecodeObjectFunc pCryptDecodeObject =
5493 CRYPT_LoadDecoderFunc(dwCertEncodingType, lpszStructType, &hFunc);
5494
5495 /* Try CryptDecodeObject function. Don't call CryptDecodeObject
5496 * directly, as that could cause an infinite loop.
5497 */
5498 if (pCryptDecodeObject)
5499 {
5500 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
5501 {
5502 ret = pCryptDecodeObject(dwCertEncodingType, lpszStructType,
5503 pbEncoded, cbEncoded, dwFlags, NULL, pcbStructInfo);
5504 if (ret && (ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
5505 pvStructInfo, pcbStructInfo, *pcbStructInfo)))
5506 ret = pCryptDecodeObject(dwCertEncodingType,
5507 lpszStructType, pbEncoded, cbEncoded, dwFlags,
5508 *(BYTE **)pvStructInfo, pcbStructInfo);
5509 }
5510 else
5511 ret = pCryptDecodeObject(dwCertEncodingType, lpszStructType,
5512 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo);
5513 }
5514 }
5515 if (hFunc)
5516 CryptFreeOIDFunctionAddress(hFunc, 0);
5517 TRACE_(crypt)("returning %d\n", ret);
5518 return ret;
5519 }
A free Windows-compatible Operating System