2 * Copyright 2005-2008 Juan Lang
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.
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.
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
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.
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.)
28 * RFC3280, http://www.faqs.org/rfcs/rfc3280.html
30 * MSDN, especially "Constants for CryptEncodeObject and CryptDecodeObject"
34 #include "wine/port.h"
41 #define NONAMELESSUNION
48 #include "wine/debug.h"
49 #include "wine/exception.h"
50 #include "crypt32_private.h"
52 /* This is a bit arbitrary, but to set some limit: */
53 #define MAX_ENCODED_LEN 0x02000000
55 #define ASN_FLAGS_MASK 0xe0
56 #define ASN_TYPE_MASK 0x1f
58 WINE_DEFAULT_DEBUG_CHANNEL(cryptasn
);
59 WINE_DECLARE_DEBUG_CHANNEL(crypt
);
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
*);
72 /* Internal decoders don't do memory allocation or exception handling, and
73 * they report how many bytes they decoded.
75 typedef BOOL (*InternalDecodeFunc
)(const BYTE
*pbEncoded
, DWORD cbEncoded
,
76 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
);
78 static BOOL
CRYPT_AsnDecodeChoiceOfTimeInternal(const BYTE
*pbEncoded
,
79 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
81 static BOOL
CRYPT_AsnDecodePubKeyInfoInternal(const BYTE
*pbEncoded
,
82 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
84 /* Like CRYPT_AsnDecodeExtensions, except assumes rgExtension is set ahead of
85 * time, doesn't do memory allocation, and doesn't do exception handling.
87 static BOOL
CRYPT_AsnDecodeExtensionsInternal(const BYTE
*pbEncoded
,
88 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
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
,
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
109 static BOOL
CRYPT_AsnDecodeIntegerInternal(const BYTE
*pbEncoded
,
110 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
112 /* Like CRYPT_AsnDecodeInteger, but unsigned. */
113 static BOOL
CRYPT_AsnDecodeUnsignedIntegerInternal(const BYTE
*pbEncoded
,
114 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
116 static BOOL
CRYPT_AsnDecodePKCSAttributesInternal(const BYTE
*pbEncoded
,
117 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
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))
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.
129 static BOOL
CRYPT_GetLengthIndefinite(const BYTE
*pbEncoded
, DWORD cbEncoded
,
136 SetLastError(CRYPT_E_ASN1_CORRUPT
);
139 else if (pbEncoded
[1] <= 0x7f)
141 if (pbEncoded
[1] + 1 > cbEncoded
)
143 SetLastError(CRYPT_E_ASN1_EOD
);
152 else if (pbEncoded
[1] == 0x80)
154 *len
= CMSG_INDEFINITE_LENGTH
;
159 BYTE lenLen
= GET_LEN_BYTES(pbEncoded
[1]);
161 if (lenLen
> sizeof(DWORD
) + 1)
163 SetLastError(CRYPT_E_ASN1_LARGE
);
166 else if (lenLen
+ 2 > cbEncoded
)
168 SetLastError(CRYPT_E_ASN1_CORRUPT
);
181 if (out
+ lenLen
+ 1 > cbEncoded
)
183 SetLastError(CRYPT_E_ASN1_EOD
);
196 /* Like CRYPT_GetLengthIndefinite, but disallows indefinite-length encoding. */
197 static BOOL
CRYPT_GetLen(const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD
*len
)
201 if ((ret
= CRYPT_GetLengthIndefinite(pbEncoded
, cbEncoded
, len
)) &&
202 *len
== CMSG_INDEFINITE_LENGTH
)
204 SetLastError(CRYPT_E_ASN1_CORRUPT
);
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.
215 static BOOL
CRYPT_DecodeEnsureSpace(DWORD dwFlags
,
216 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
221 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
223 if (pDecodePara
&& pDecodePara
->pfnAlloc
)
224 *(BYTE
**)pvStructInfo
= pDecodePara
->pfnAlloc(bytesNeeded
);
226 *(BYTE
**)pvStructInfo
= LocalAlloc(0, bytesNeeded
);
227 if (!*(BYTE
**)pvStructInfo
)
230 *pcbStructInfo
= bytesNeeded
;
232 else if (*pcbStructInfo
< bytesNeeded
)
234 *pcbStructInfo
= bytesNeeded
;
235 SetLastError(ERROR_MORE_DATA
);
239 *pcbStructInfo
= bytesNeeded
;
243 static void CRYPT_FreeSpace(PCRYPT_DECODE_PARA pDecodePara
, LPVOID pv
)
245 if (pDecodePara
&& pDecodePara
->pfnFree
)
246 pDecodePara
->pfnFree(pv
);
251 /* Helper function to check *pcbStructInfo and set it to the required size.
252 * Assumes pvStructInfo is not NULL.
254 static BOOL
CRYPT_DecodeCheckSpace(DWORD
*pcbStructInfo
, DWORD bytesNeeded
)
258 if (*pcbStructInfo
< bytesNeeded
)
260 *pcbStructInfo
= bytesNeeded
;
261 SetLastError(ERROR_MORE_DATA
);
266 *pcbStructInfo
= bytesNeeded
;
273 * The expected tag of the item. If tag is 0, decodeFunc is called
274 * regardless of the tag value seen.
276 * A sequence is decoded into a struct. The offset member is the
277 * offset of this item within that struct.
279 * The decoder function to use. If this is NULL, then the member isn't
280 * decoded, but minSize space is reserved for it.
282 * The minimum amount of space occupied after decoding. You must set this.
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).
292 * Used by CRYPT_AsnDecodeSequence, not for your use.
294 struct AsnDecodeSequenceItem
298 InternalDecodeFunc decodeFunc
;
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.
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
)
318 DWORD i
, decoded
= 0;
319 const BYTE
*ptr
= pbEncoded
;
321 TRACE("%p, %d, %p, %d, %08x, %p, %p, %p\n", items
, cItem
, pbEncoded
,
322 cbEncoded
, dwFlags
, pvStructInfo
, nextData
, cbDecoded
);
324 for (i
= 0, ret
= TRUE
; ret
&& i
< cItem
; i
++)
326 if (cbEncoded
- (ptr
- pbEncoded
) != 0)
330 if ((ret
= CRYPT_GetLengthIndefinite(ptr
,
331 cbEncoded
- (ptr
- pbEncoded
), &itemLen
)))
333 BYTE itemLenBytes
= GET_LEN_BYTES(ptr
[1]);
335 if (ptr
[0] == items
[i
].tag
|| !items
[i
].tag
)
337 DWORD itemEncodedLen
;
339 if (itemLen
== CMSG_INDEFINITE_LENGTH
)
340 itemEncodedLen
= cbEncoded
- (ptr
- pbEncoded
);
342 itemEncodedLen
= 1 + itemLenBytes
+ itemLen
;
343 if (nextData
&& pvStructInfo
&& items
[i
].hasPointer
)
345 TRACE("Setting next pointer to %p\n",
347 *(BYTE
**)((BYTE
*)pvStructInfo
+
348 items
[i
].pointerOffset
) = nextData
;
350 if (items
[i
].decodeFunc
)
355 TRACE("decoding item %d\n", i
);
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
);
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
)
372 WARN("decoded length %d exceeds encoded %d\n",
373 itemDecoded
, itemEncodedLen
);
374 SetLastError(CRYPT_E_ASN1_CORRUPT
);
379 if (itemLen
== CMSG_INDEFINITE_LENGTH
)
381 if (itemDecoded
> itemEncodedLen
- 2 ||
382 *(ptr
+ itemDecoded
) != 0 ||
383 *(ptr
+ itemDecoded
+ 1) != 0)
385 TRACE("expected 0 TLV\n");
386 SetLastError(CRYPT_E_ASN1_CORRUPT
);
395 decoded
+= itemDecoded
;
396 TRACE("item %d: decoded %d bytes\n", i
,
401 else if (items
[i
].optional
&&
402 GetLastError() == CRYPT_E_ASN1_BADTAG
)
404 TRACE("skipping optional item %d\n", i
);
405 items
[i
].size
= items
[i
].minSize
;
406 SetLastError(NOERROR
);
410 TRACE("item %d failed: %08x\n", i
,
413 else if (itemLen
== CMSG_INDEFINITE_LENGTH
)
415 ERR("can't use indefinite length encoding without a decoder\n");
416 SetLastError(CRYPT_E_ASN1_CORRUPT
);
421 TRACE("item %d: decoded %d bytes\n", i
, itemEncodedLen
);
422 ptr
+= itemEncodedLen
;
423 decoded
+= itemEncodedLen
;
424 items
[i
].size
= items
[i
].minSize
;
427 else if (items
[i
].optional
)
429 TRACE("skipping optional item %d\n", i
);
430 items
[i
].size
= items
[i
].minSize
;
434 TRACE("item %d: tag %02x doesn't match expected %02x\n",
435 i
, ptr
[0], items
[i
].tag
);
436 SetLastError(CRYPT_E_ASN1_BADTAG
);
441 else if (items
[i
].optional
)
443 TRACE("missing optional item %d, skipping\n", i
);
444 items
[i
].size
= items
[i
].minSize
;
448 TRACE("not enough bytes for item %d, failing\n", i
);
449 SetLastError(CRYPT_E_ASN1_CORRUPT
);
454 *cbDecoded
= decoded
;
455 TRACE("returning %d\n", ret
);
459 /* This decodes an arbitrary sequence into a contiguous block of memory
460 * (basically, a struct.) Each element being decoded is described by a struct
461 * AsnDecodeSequenceItem, see above.
462 * startingPointer is an optional pointer to the first place where dynamic
463 * data will be stored. If you know the starting offset, you may pass it
464 * here. Otherwise, pass NULL, and one will be inferred from the items.
466 static BOOL
CRYPT_AsnDecodeSequence(struct AsnDecodeSequenceItem items
[],
467 DWORD cItem
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
468 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
469 DWORD
*pcbDecoded
, void *startingPointer
)
473 TRACE("%p, %d, %p, %d, %08x, %p, %p, %d, %p\n", items
, cItem
, pbEncoded
,
474 cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
, *pcbStructInfo
,
479 SetLastError(CRYPT_E_ASN1_EOD
);
482 if (pbEncoded
[0] == ASN_SEQUENCE
)
486 if ((ret
= CRYPT_GetLengthIndefinite(pbEncoded
, cbEncoded
, &dataLen
)))
488 DWORD lenBytes
= GET_LEN_BYTES(pbEncoded
[1]), cbDecoded
;
489 const BYTE
*ptr
= pbEncoded
+ 1 + lenBytes
;
490 BOOL indefinite
= FALSE
;
492 cbEncoded
-= 1 + lenBytes
;
493 if (dataLen
== CMSG_INDEFINITE_LENGTH
)
498 else if (cbEncoded
< dataLen
)
500 TRACE("dataLen %d exceeds cbEncoded %d, failing\n", dataLen
,
502 SetLastError(CRYPT_E_ASN1_CORRUPT
);
507 ret
= CRYPT_AsnDecodeSequenceItems(items
, cItem
,
508 ptr
, dataLen
, dwFlags
, NULL
, NULL
, &cbDecoded
);
509 if (ret
&& dataLen
== CMSG_INDEFINITE_LENGTH
)
511 if (cbDecoded
> cbEncoded
- 2)
513 /* Not enough space for 0 TLV */
514 SetLastError(CRYPT_E_ASN1_CORRUPT
);
517 else if (*(ptr
+ cbDecoded
) != 0 ||
518 *(ptr
+ cbDecoded
+ 1) != 0)
520 TRACE("expected 0 TLV\n");
521 SetLastError(CRYPT_E_ASN1_CORRUPT
);
528 if (ret
&& !indefinite
&& cbDecoded
!= dataLen
)
530 TRACE("expected %d decoded, got %d, failing\n", dataLen
,
532 SetLastError(CRYPT_E_ASN1_CORRUPT
);
537 DWORD i
, bytesNeeded
= 0, structSize
= 0;
539 for (i
= 0; i
< cItem
; i
++)
541 bytesNeeded
+= items
[i
].size
;
542 structSize
+= items
[i
].minSize
;
545 *pcbDecoded
= 1 + lenBytes
+ cbDecoded
;
547 *pcbStructInfo
= bytesNeeded
;
548 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
,
549 pDecodePara
, pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
553 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
554 pvStructInfo
= *(BYTE
**)pvStructInfo
;
556 nextData
= (BYTE
*)startingPointer
;
558 nextData
= (BYTE
*)pvStructInfo
+ structSize
;
559 memset(pvStructInfo
, 0, structSize
);
560 ret
= CRYPT_AsnDecodeSequenceItems(items
, cItem
,
561 ptr
, dataLen
, dwFlags
, pvStructInfo
, nextData
,
563 if (!ret
&& (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
))
564 CRYPT_FreeSpace(pDecodePara
, pvStructInfo
);
571 SetLastError(CRYPT_E_ASN1_BADTAG
);
574 TRACE("returning %d (%08x)\n", ret
, GetLastError());
579 * The expected tag of the entire encoded array (usually a variant
580 * of ASN_SETOF or ASN_SEQUENCEOF.) If tag is 0, decodeFunc is called
581 * regardless of the tag seen.
583 * used to decode each item in the array
585 * is the minimum size of each decoded item
587 * indicates whether each item has a dynamic pointer
589 * indicates the offset within itemSize at which the pointer exists
591 struct AsnArrayDescriptor
594 InternalDecodeFunc decodeFunc
;
600 struct AsnArrayItemSize
606 /* Decodes an array of like types into a struct GenericArray.
607 * The layout and decoding of the array are described by a struct
608 * AsnArrayDescriptor.
610 static BOOL
CRYPT_AsnDecodeArray(const struct AsnArrayDescriptor
*arrayDesc
,
611 const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
612 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
613 DWORD
*pcbDecoded
, void *startingPointer
)
617 TRACE("%p, %p, %d, %08x, %p, %p, %d, %p\n", arrayDesc
, pbEncoded
,
618 cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
, *pcbStructInfo
,
621 if (!arrayDesc
->tag
|| pbEncoded
[0] == arrayDesc
->tag
)
625 if ((ret
= CRYPT_GetLengthIndefinite(pbEncoded
, cbEncoded
, &dataLen
)))
627 DWORD bytesNeeded
, cItems
= 0, decoded
;
628 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
629 /* There can be arbitrarily many items, but there is often only one.
631 struct AsnArrayItemSize itemSize
= { 0 }, *itemSizes
= &itemSize
;
633 decoded
= 1 + lenBytes
;
634 bytesNeeded
= sizeof(struct GenericArray
);
638 BOOL doneDecoding
= FALSE
;
640 for (ptr
= pbEncoded
+ 1 + lenBytes
; ret
&& !doneDecoding
; )
642 if (dataLen
== CMSG_INDEFINITE_LENGTH
)
649 SetLastError(CRYPT_E_ASN1_CORRUPT
);
656 else if (ptr
- pbEncoded
- 1 - lenBytes
>= dataLen
)
660 DWORD itemEncoded
, itemDataLen
, itemDecoded
, size
= 0;
662 /* Each item decoded may not tolerate extraneous bytes,
663 * so get the length of the next element if known.
665 if ((ret
= CRYPT_GetLengthIndefinite(ptr
,
666 cbEncoded
- (ptr
- pbEncoded
), &itemDataLen
)))
668 if (itemDataLen
== CMSG_INDEFINITE_LENGTH
)
669 itemEncoded
= cbEncoded
- (ptr
- pbEncoded
);
671 itemEncoded
= 1 + GET_LEN_BYTES(ptr
[1]) +
675 ret
= arrayDesc
->decodeFunc(ptr
, itemEncoded
,
676 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, &size
,
681 if (itemSizes
!= &itemSize
)
682 itemSizes
= CryptMemRealloc(itemSizes
,
683 cItems
* sizeof(struct AsnArrayItemSize
));
688 cItems
* sizeof(struct AsnArrayItemSize
));
690 memcpy(itemSizes
, &itemSize
,
695 decoded
+= itemDecoded
;
696 itemSizes
[cItems
- 1].encodedLen
= itemEncoded
;
697 itemSizes
[cItems
- 1].size
= size
;
710 *pcbDecoded
= decoded
;
712 *pcbStructInfo
= bytesNeeded
;
713 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
,
714 pDecodePara
, pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
719 struct GenericArray
*array
;
721 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
722 pvStructInfo
= *(BYTE
**)pvStructInfo
;
723 array
= (struct GenericArray
*)pvStructInfo
;
724 array
->cItems
= cItems
;
726 array
->rgItems
= startingPointer
;
728 array
->rgItems
= (BYTE
*)array
+
729 sizeof(struct GenericArray
);
730 nextData
= array
->rgItems
+
731 array
->cItems
* arrayDesc
->itemSize
;
732 for (i
= 0, ptr
= pbEncoded
+ 1 + lenBytes
; ret
&&
733 i
< cItems
&& ptr
- pbEncoded
- 1 - lenBytes
<
738 if (arrayDesc
->hasPointer
)
739 *(BYTE
**)(array
->rgItems
+ i
* arrayDesc
->itemSize
740 + arrayDesc
->pointerOffset
) = nextData
;
741 ret
= arrayDesc
->decodeFunc(ptr
,
742 itemSizes
[i
].encodedLen
,
743 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
,
744 array
->rgItems
+ i
* arrayDesc
->itemSize
,
745 &itemSizes
[i
].size
, &itemDecoded
);
748 nextData
+= itemSizes
[i
].size
- arrayDesc
->itemSize
;
752 if (!ret
&& (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
))
753 CRYPT_FreeSpace(pDecodePara
, pvStructInfo
);
756 if (itemSizes
!= &itemSize
)
757 CryptMemFree(itemSizes
);
762 SetLastError(CRYPT_E_ASN1_BADTAG
);
768 /* Decodes a DER-encoded BLOB into a CRYPT_DER_BLOB struct pointed to by
769 * pvStructInfo. The BLOB must be non-empty, otherwise the last error is set
770 * to CRYPT_E_ASN1_CORRUPT.
771 * Warning: assumes the CRYPT_DER_BLOB pointed to by pvStructInfo has pbData
774 static BOOL
CRYPT_AsnDecodeDerBlob(const BYTE
*pbEncoded
, DWORD cbEncoded
,
775 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
780 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
782 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
783 DWORD bytesNeeded
= sizeof(CRYPT_DER_BLOB
);
785 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
786 bytesNeeded
+= 1 + lenBytes
+ dataLen
;
789 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
791 *pcbStructInfo
= bytesNeeded
;
792 else if ((ret
= CRYPT_DecodeCheckSpace(pcbStructInfo
, bytesNeeded
)))
794 CRYPT_DER_BLOB
*blob
;
796 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
797 pvStructInfo
= *(BYTE
**)pvStructInfo
;
798 blob
= (CRYPT_DER_BLOB
*)pvStructInfo
;
799 blob
->cbData
= 1 + lenBytes
+ dataLen
;
802 if (dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
)
803 blob
->pbData
= (BYTE
*)pbEncoded
;
806 assert(blob
->pbData
);
807 memcpy(blob
->pbData
, pbEncoded
, blob
->cbData
);
812 SetLastError(CRYPT_E_ASN1_CORRUPT
);
820 /* Like CRYPT_AsnDecodeBitsInternal, but swaps the bytes */
821 static BOOL
CRYPT_AsnDecodeBitsSwapBytes(const BYTE
*pbEncoded
,
822 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
827 TRACE("(%p, %d, 0x%08x, %p, %d, %p)\n", pbEncoded
, cbEncoded
, dwFlags
,
828 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
830 /* Can't use the CRYPT_DECODE_NOCOPY_FLAG, because we modify the bytes in-
833 ret
= CRYPT_AsnDecodeBitsInternal(pbEncoded
, cbEncoded
,
834 dwFlags
& ~CRYPT_DECODE_NOCOPY_FLAG
, pvStructInfo
, pcbStructInfo
,
836 if (ret
&& pvStructInfo
)
838 CRYPT_BIT_BLOB
*blob
= (CRYPT_BIT_BLOB
*)pvStructInfo
;
845 for (i
= 0; i
< blob
->cbData
/ 2; i
++)
847 temp
= blob
->pbData
[i
];
848 blob
->pbData
[i
] = blob
->pbData
[blob
->cbData
- i
- 1];
849 blob
->pbData
[blob
->cbData
- i
- 1] = temp
;
853 TRACE("returning %d (%08x)\n", ret
, GetLastError());
857 static BOOL WINAPI
CRYPT_AsnDecodeCertSignedContent(DWORD dwCertEncodingType
,
858 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
859 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
863 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
864 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
868 struct AsnDecodeSequenceItem items
[] = {
869 { 0, offsetof(CERT_SIGNED_CONTENT_INFO
, ToBeSigned
),
870 CRYPT_AsnDecodeDerBlob
, sizeof(CRYPT_DER_BLOB
), FALSE
, TRUE
,
871 offsetof(CERT_SIGNED_CONTENT_INFO
, ToBeSigned
.pbData
), 0 },
872 { ASN_SEQUENCEOF
, offsetof(CERT_SIGNED_CONTENT_INFO
,
873 SignatureAlgorithm
), CRYPT_AsnDecodeAlgorithmId
,
874 sizeof(CRYPT_ALGORITHM_IDENTIFIER
), FALSE
, TRUE
,
875 offsetof(CERT_SIGNED_CONTENT_INFO
, SignatureAlgorithm
.pszObjId
), 0 },
876 { ASN_BITSTRING
, offsetof(CERT_SIGNED_CONTENT_INFO
, Signature
),
877 CRYPT_AsnDecodeBitsSwapBytes
, sizeof(CRYPT_BIT_BLOB
), FALSE
, TRUE
,
878 offsetof(CERT_SIGNED_CONTENT_INFO
, Signature
.pbData
), 0 },
881 if (dwFlags
& CRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG
)
882 items
[2].decodeFunc
= CRYPT_AsnDecodeBitsInternal
;
883 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
884 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
,
885 pcbStructInfo
, NULL
, NULL
);
889 SetLastError(STATUS_ACCESS_VIOLATION
);
894 TRACE("Returning %d (%08x)\n", ret
, GetLastError());
898 static BOOL
CRYPT_AsnDecodeCertVersion(const BYTE
*pbEncoded
, DWORD cbEncoded
,
899 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
904 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
906 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
908 ret
= CRYPT_AsnDecodeIntInternal(pbEncoded
+ 1 + lenBytes
, dataLen
,
909 dwFlags
, pvStructInfo
, pcbStructInfo
, NULL
);
911 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
916 static BOOL
CRYPT_AsnDecodeValidity(const BYTE
*pbEncoded
, DWORD cbEncoded
,
917 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
921 struct AsnDecodeSequenceItem items
[] = {
922 { 0, offsetof(CERT_PRIVATE_KEY_VALIDITY
, NotBefore
),
923 CRYPT_AsnDecodeChoiceOfTimeInternal
, sizeof(FILETIME
), FALSE
, FALSE
, 0 },
924 { 0, offsetof(CERT_PRIVATE_KEY_VALIDITY
, NotAfter
),
925 CRYPT_AsnDecodeChoiceOfTimeInternal
, sizeof(FILETIME
), FALSE
, FALSE
, 0 },
928 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
929 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
934 static BOOL
CRYPT_AsnDecodeCertExtensions(const BYTE
*pbEncoded
,
935 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
941 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
943 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
945 ret
= CRYPT_AsnDecodeExtensionsInternal(pbEncoded
+ 1 + lenBytes
,
946 dataLen
, dwFlags
, pvStructInfo
, pcbStructInfo
, NULL
);
947 if (ret
&& pcbDecoded
)
948 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
953 static BOOL WINAPI
CRYPT_AsnDecodeCertInfo(DWORD dwCertEncodingType
,
954 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
955 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
958 struct AsnDecodeSequenceItem items
[] = {
959 { ASN_CONTEXT
| ASN_CONSTRUCTOR
, offsetof(CERT_INFO
, dwVersion
),
960 CRYPT_AsnDecodeCertVersion
, sizeof(DWORD
), TRUE
, FALSE
, 0, 0 },
961 { ASN_INTEGER
, offsetof(CERT_INFO
, SerialNumber
),
962 CRYPT_AsnDecodeIntegerInternal
, sizeof(CRYPT_INTEGER_BLOB
), FALSE
,
963 TRUE
, offsetof(CERT_INFO
, SerialNumber
.pbData
), 0 },
964 { ASN_SEQUENCEOF
, offsetof(CERT_INFO
, SignatureAlgorithm
),
965 CRYPT_AsnDecodeAlgorithmId
, sizeof(CRYPT_ALGORITHM_IDENTIFIER
),
966 FALSE
, TRUE
, offsetof(CERT_INFO
, SignatureAlgorithm
.pszObjId
), 0 },
967 { 0, offsetof(CERT_INFO
, Issuer
), CRYPT_AsnDecodeDerBlob
,
968 sizeof(CRYPT_DER_BLOB
), FALSE
, TRUE
, offsetof(CERT_INFO
,
970 { ASN_SEQUENCEOF
, offsetof(CERT_INFO
, NotBefore
),
971 CRYPT_AsnDecodeValidity
, sizeof(CERT_PRIVATE_KEY_VALIDITY
), FALSE
,
973 { 0, offsetof(CERT_INFO
, Subject
), CRYPT_AsnDecodeDerBlob
,
974 sizeof(CRYPT_DER_BLOB
), FALSE
, TRUE
, offsetof(CERT_INFO
,
976 { ASN_SEQUENCEOF
, offsetof(CERT_INFO
, SubjectPublicKeyInfo
),
977 CRYPT_AsnDecodePubKeyInfoInternal
, sizeof(CERT_PUBLIC_KEY_INFO
),
978 FALSE
, TRUE
, offsetof(CERT_INFO
,
979 SubjectPublicKeyInfo
.Algorithm
.Parameters
.pbData
), 0 },
980 { ASN_BITSTRING
, offsetof(CERT_INFO
, IssuerUniqueId
),
981 CRYPT_AsnDecodeBitsInternal
, sizeof(CRYPT_BIT_BLOB
), TRUE
, TRUE
,
982 offsetof(CERT_INFO
, IssuerUniqueId
.pbData
), 0 },
983 { ASN_BITSTRING
, offsetof(CERT_INFO
, SubjectUniqueId
),
984 CRYPT_AsnDecodeBitsInternal
, sizeof(CRYPT_BIT_BLOB
), TRUE
, TRUE
,
985 offsetof(CERT_INFO
, SubjectUniqueId
.pbData
), 0 },
986 { ASN_CONTEXT
| ASN_CONSTRUCTOR
| 3, offsetof(CERT_INFO
, cExtension
),
987 CRYPT_AsnDecodeCertExtensions
, sizeof(CERT_EXTENSIONS
), TRUE
, TRUE
,
988 offsetof(CERT_INFO
, rgExtension
), 0 },
991 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
992 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
994 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
995 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
, pcbStructInfo
,
997 if (ret
&& pvStructInfo
)
1001 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
1002 info
= *(CERT_INFO
**)pvStructInfo
;
1004 info
= (CERT_INFO
*)pvStructInfo
;
1005 if (!info
->SerialNumber
.cbData
|| !info
->Issuer
.cbData
||
1006 !info
->Subject
.cbData
)
1008 SetLastError(CRYPT_E_ASN1_CORRUPT
);
1009 /* Don't need to deallocate, because it should have failed on the
1010 * first pass (and no memory was allocated.)
1016 TRACE("Returning %d (%08x)\n", ret
, GetLastError());
1020 static BOOL WINAPI
CRYPT_AsnDecodeCert(DWORD dwCertEncodingType
,
1021 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
1022 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
1026 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
1027 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
1033 /* Unless told not to, first try to decode it as a signed cert. */
1034 if (!(dwFlags
& CRYPT_DECODE_TO_BE_SIGNED_FLAG
))
1036 PCERT_SIGNED_CONTENT_INFO signedCert
= NULL
;
1038 ret
= CRYPT_AsnDecodeCertSignedContent(dwCertEncodingType
,
1039 X509_CERT
, pbEncoded
, cbEncoded
, CRYPT_DECODE_ALLOC_FLAG
, NULL
,
1040 (BYTE
*)&signedCert
, &size
);
1044 ret
= CRYPT_AsnDecodeCertInfo(dwCertEncodingType
,
1045 X509_CERT_TO_BE_SIGNED
, signedCert
->ToBeSigned
.pbData
,
1046 signedCert
->ToBeSigned
.cbData
, dwFlags
, pDecodePara
,
1047 pvStructInfo
, pcbStructInfo
);
1048 LocalFree(signedCert
);
1051 /* Failing that, try it as an unsigned cert */
1055 ret
= CRYPT_AsnDecodeCertInfo(dwCertEncodingType
,
1056 X509_CERT_TO_BE_SIGNED
, pbEncoded
, cbEncoded
, dwFlags
,
1057 pDecodePara
, pvStructInfo
, pcbStructInfo
);
1062 SetLastError(STATUS_ACCESS_VIOLATION
);
1066 TRACE("Returning %d (%08x)\n", ret
, GetLastError());
1070 static BOOL
CRYPT_AsnDecodeCRLEntry(const BYTE
*pbEncoded
, DWORD cbEncoded
,
1071 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
1074 struct AsnDecodeSequenceItem items
[] = {
1075 { ASN_INTEGER
, offsetof(CRL_ENTRY
, SerialNumber
),
1076 CRYPT_AsnDecodeIntegerInternal
, sizeof(CRYPT_INTEGER_BLOB
), FALSE
, TRUE
,
1077 offsetof(CRL_ENTRY
, SerialNumber
.pbData
), 0 },
1078 { 0, offsetof(CRL_ENTRY
, RevocationDate
),
1079 CRYPT_AsnDecodeChoiceOfTimeInternal
, sizeof(FILETIME
), FALSE
, FALSE
, 0 },
1080 { ASN_SEQUENCEOF
, offsetof(CRL_ENTRY
, cExtension
),
1081 CRYPT_AsnDecodeExtensionsInternal
, sizeof(CERT_EXTENSIONS
), TRUE
, TRUE
,
1082 offsetof(CRL_ENTRY
, rgExtension
), 0 },
1084 PCRL_ENTRY entry
= (PCRL_ENTRY
)pvStructInfo
;
1086 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
, entry
,
1089 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
1090 pbEncoded
, cbEncoded
, dwFlags
, NULL
, entry
, pcbStructInfo
, pcbDecoded
,
1091 entry
? entry
->SerialNumber
.pbData
: NULL
);
1092 if (ret
&& entry
&& !entry
->SerialNumber
.cbData
)
1094 WARN("empty CRL entry serial number\n");
1095 SetLastError(CRYPT_E_ASN1_CORRUPT
);
1101 /* Warning: assumes pvStructInfo is a struct GenericArray whose rgItems has
1102 * been set prior to calling.
1104 static BOOL
CRYPT_AsnDecodeCRLEntries(const BYTE
*pbEncoded
, DWORD cbEncoded
,
1105 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
1108 struct AsnArrayDescriptor arrayDesc
= { ASN_SEQUENCEOF
,
1109 CRYPT_AsnDecodeCRLEntry
, sizeof(CRL_ENTRY
), TRUE
,
1110 offsetof(CRL_ENTRY
, SerialNumber
.pbData
) };
1111 struct GenericArray
*entries
= (struct GenericArray
*)pvStructInfo
;
1113 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
1114 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
1116 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
1117 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
1118 entries
? entries
->rgItems
: NULL
);
1119 TRACE("Returning %d (%08x)\n", ret
, GetLastError());
1123 static BOOL WINAPI
CRYPT_AsnDecodeCRLInfo(DWORD dwCertEncodingType
,
1124 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
1125 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
1127 struct AsnDecodeSequenceItem items
[] = {
1128 { ASN_INTEGER
, offsetof(CRL_INFO
, dwVersion
),
1129 CRYPT_AsnDecodeIntInternal
, sizeof(DWORD
), TRUE
, FALSE
, 0, 0 },
1130 { ASN_SEQUENCEOF
, offsetof(CRL_INFO
, SignatureAlgorithm
),
1131 CRYPT_AsnDecodeAlgorithmId
, sizeof(CRYPT_ALGORITHM_IDENTIFIER
),
1132 FALSE
, TRUE
, offsetof(CRL_INFO
, SignatureAlgorithm
.pszObjId
), 0 },
1133 { 0, offsetof(CRL_INFO
, Issuer
), CRYPT_AsnDecodeDerBlob
,
1134 sizeof(CRYPT_DER_BLOB
), FALSE
, TRUE
, offsetof(CRL_INFO
,
1136 { 0, offsetof(CRL_INFO
, ThisUpdate
), CRYPT_AsnDecodeChoiceOfTimeInternal
,
1137 sizeof(FILETIME
), FALSE
, FALSE
, 0 },
1138 { 0, offsetof(CRL_INFO
, NextUpdate
), CRYPT_AsnDecodeChoiceOfTimeInternal
,
1139 sizeof(FILETIME
), TRUE
, FALSE
, 0 },
1140 { ASN_SEQUENCEOF
, offsetof(CRL_INFO
, cCRLEntry
),
1141 CRYPT_AsnDecodeCRLEntries
, sizeof(struct GenericArray
), TRUE
, TRUE
,
1142 offsetof(CRL_INFO
, rgCRLEntry
), 0 },
1143 { ASN_CONTEXT
| ASN_CONSTRUCTOR
| 0, offsetof(CRL_INFO
, cExtension
),
1144 CRYPT_AsnDecodeCertExtensions
, sizeof(CERT_EXTENSIONS
), TRUE
, TRUE
,
1145 offsetof(CRL_INFO
, rgExtension
), 0 },
1149 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
1150 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
1152 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
1153 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
, pcbStructInfo
,
1156 TRACE("Returning %d (%08x)\n", ret
, GetLastError());
1160 static BOOL WINAPI
CRYPT_AsnDecodeCRL(DWORD dwCertEncodingType
,
1161 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
1162 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
1166 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
1167 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
1173 /* Unless told not to, first try to decode it as a signed crl. */
1174 if (!(dwFlags
& CRYPT_DECODE_TO_BE_SIGNED_FLAG
))
1176 PCERT_SIGNED_CONTENT_INFO signedCrl
= NULL
;
1178 ret
= CRYPT_AsnDecodeCertSignedContent(dwCertEncodingType
,
1179 X509_CERT
, pbEncoded
, cbEncoded
, CRYPT_DECODE_ALLOC_FLAG
, NULL
,
1180 (BYTE
*)&signedCrl
, &size
);
1184 ret
= CRYPT_AsnDecodeCRLInfo(dwCertEncodingType
,
1185 X509_CERT_CRL_TO_BE_SIGNED
, signedCrl
->ToBeSigned
.pbData
,
1186 signedCrl
->ToBeSigned
.cbData
, dwFlags
, pDecodePara
,
1187 pvStructInfo
, pcbStructInfo
);
1188 LocalFree(signedCrl
);
1191 /* Failing that, try it as an unsigned crl */
1195 ret
= CRYPT_AsnDecodeCRLInfo(dwCertEncodingType
,
1196 X509_CERT_CRL_TO_BE_SIGNED
, pbEncoded
, cbEncoded
,
1197 dwFlags
, pDecodePara
, pvStructInfo
, pcbStructInfo
);
1202 SetLastError(STATUS_ACCESS_VIOLATION
);
1206 TRACE("Returning %d (%08x)\n", ret
, GetLastError());
1210 static BOOL
CRYPT_AsnDecodeOidIgnoreTag(const BYTE
*pbEncoded
, DWORD cbEncoded
,
1211 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
1216 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
1217 pvStructInfo
, *pcbStructInfo
);
1219 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
1221 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
1222 DWORD bytesNeeded
= sizeof(LPSTR
);
1226 /* The largest possible string for the first two components
1227 * is 2.175 (= 2 * 40 + 175 = 255), so this is big enough.
1232 snprintf(firstTwo
, sizeof(firstTwo
), "%d.%d",
1233 pbEncoded
[1 + lenBytes
] / 40,
1234 pbEncoded
[1 + lenBytes
] - (pbEncoded
[1 + lenBytes
] / 40)
1236 bytesNeeded
+= strlen(firstTwo
) + 1;
1237 for (ptr
= pbEncoded
+ 2 + lenBytes
; ret
&&
1238 ptr
- pbEncoded
- 1 - lenBytes
< dataLen
; )
1240 /* large enough for ".4000000" */
1244 while (ptr
- pbEncoded
- 1 - lenBytes
< dataLen
&&
1251 if (ptr
- pbEncoded
- 1 - lenBytes
>= dataLen
||
1254 SetLastError(CRYPT_E_ASN1_CORRUPT
);
1261 snprintf(str
, sizeof(str
), ".%d", val
);
1262 bytesNeeded
+= strlen(str
);
1267 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
1269 *pcbStructInfo
= bytesNeeded
;
1270 else if (*pcbStructInfo
< bytesNeeded
)
1272 *pcbStructInfo
= bytesNeeded
;
1273 SetLastError(ERROR_MORE_DATA
);
1281 LPSTR pszObjId
= *(LPSTR
*)pvStructInfo
;
1284 sprintf(pszObjId
, "%d.%d", pbEncoded
[1 + lenBytes
] / 40,
1285 pbEncoded
[1 + lenBytes
] - (pbEncoded
[1 + lenBytes
] /
1287 pszObjId
+= strlen(pszObjId
);
1288 for (ptr
= pbEncoded
+ 2 + lenBytes
; ret
&&
1289 ptr
- pbEncoded
- 1 - lenBytes
< dataLen
; )
1293 while (ptr
- pbEncoded
- 1 - lenBytes
< dataLen
&&
1302 sprintf(pszObjId
, ".%d", val
);
1303 pszObjId
+= strlen(pszObjId
);
1307 *(LPSTR
*)pvStructInfo
= NULL
;
1308 *pcbStructInfo
= bytesNeeded
;
1314 static BOOL
CRYPT_AsnDecodeOidInternal(const BYTE
*pbEncoded
, DWORD cbEncoded
,
1315 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
1319 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
1320 pvStructInfo
, *pcbStructInfo
);
1322 if (pbEncoded
[0] == ASN_OBJECTIDENTIFIER
)
1323 ret
= CRYPT_AsnDecodeOidIgnoreTag(pbEncoded
, cbEncoded
, dwFlags
,
1324 pvStructInfo
, pcbStructInfo
, pcbDecoded
);
1327 SetLastError(CRYPT_E_ASN1_BADTAG
);
1333 /* Warning: assumes pvStructInfo is a CERT_EXTENSION whose pszObjId is set
1336 static BOOL
CRYPT_AsnDecodeExtension(const BYTE
*pbEncoded
, DWORD cbEncoded
,
1337 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
1339 struct AsnDecodeSequenceItem items
[] = {
1340 { ASN_OBJECTIDENTIFIER
, offsetof(CERT_EXTENSION
, pszObjId
),
1341 CRYPT_AsnDecodeOidIgnoreTag
, sizeof(LPSTR
), FALSE
, TRUE
,
1342 offsetof(CERT_EXTENSION
, pszObjId
), 0 },
1343 { ASN_BOOL
, offsetof(CERT_EXTENSION
, fCritical
), CRYPT_AsnDecodeBool
,
1344 sizeof(BOOL
), TRUE
, FALSE
, 0, 0 },
1345 { ASN_OCTETSTRING
, offsetof(CERT_EXTENSION
, Value
),
1346 CRYPT_AsnDecodeOctetsInternal
, sizeof(CRYPT_OBJID_BLOB
), FALSE
, TRUE
,
1347 offsetof(CERT_EXTENSION
, Value
.pbData
) },
1350 PCERT_EXTENSION ext
= (PCERT_EXTENSION
)pvStructInfo
;
1352 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
, ext
,
1356 TRACE("ext->pszObjId is %p\n", ext
->pszObjId
);
1357 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
1358 pbEncoded
, cbEncoded
, dwFlags
, NULL
, ext
, pcbStructInfo
,
1359 pcbDecoded
, ext
? ext
->pszObjId
: NULL
);
1361 TRACE("ext->pszObjId is %p (%s)\n", ext
->pszObjId
,
1362 debugstr_a(ext
->pszObjId
));
1363 TRACE("returning %d (%08x)\n", ret
, GetLastError());
1367 static BOOL
CRYPT_AsnDecodeExtensionsInternal(const BYTE
*pbEncoded
,
1368 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
1372 struct AsnArrayDescriptor arrayDesc
= { ASN_SEQUENCEOF
,
1373 CRYPT_AsnDecodeExtension
, sizeof(CERT_EXTENSION
), TRUE
,
1374 offsetof(CERT_EXTENSION
, pszObjId
) };
1375 PCERT_EXTENSIONS exts
= (PCERT_EXTENSIONS
)pvStructInfo
;
1377 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
1378 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
1380 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
1381 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
1382 exts
? exts
->rgExtension
: NULL
);
1386 static BOOL WINAPI
CRYPT_AsnDecodeExtensions(DWORD dwCertEncodingType
,
1387 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
1388 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
1394 ret
= CRYPT_AsnDecodeExtensionsInternal(pbEncoded
, cbEncoded
,
1395 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, pcbStructInfo
, NULL
);
1396 if (ret
&& pvStructInfo
)
1398 ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
, pvStructInfo
,
1399 pcbStructInfo
, *pcbStructInfo
);
1402 CERT_EXTENSIONS
*exts
;
1404 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
1405 pvStructInfo
= *(BYTE
**)pvStructInfo
;
1406 exts
= (CERT_EXTENSIONS
*)pvStructInfo
;
1407 exts
->rgExtension
= (CERT_EXTENSION
*)((BYTE
*)exts
+
1408 sizeof(CERT_EXTENSIONS
));
1409 ret
= CRYPT_AsnDecodeExtensionsInternal(pbEncoded
, cbEncoded
,
1410 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
1411 pcbStructInfo
, NULL
);
1417 SetLastError(STATUS_ACCESS_VIOLATION
);
1424 /* Warning: this assumes the address of value->Value.pbData is already set, in
1425 * order to avoid overwriting memory. (In some cases, it may change it, if it
1426 * doesn't copy anything to memory.) Be sure to set it correctly!
1428 static BOOL
CRYPT_AsnDecodeNameValueInternal(const BYTE
*pbEncoded
,
1429 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
1434 CERT_NAME_VALUE
*value
= (CERT_NAME_VALUE
*)pvStructInfo
;
1436 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
1438 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
1439 DWORD bytesNeeded
= sizeof(CERT_NAME_VALUE
), valueType
;
1441 switch (pbEncoded
[0])
1443 case ASN_OCTETSTRING
:
1444 valueType
= CERT_RDN_OCTET_STRING
;
1445 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
1446 bytesNeeded
+= dataLen
;
1448 case ASN_NUMERICSTRING
:
1449 valueType
= CERT_RDN_NUMERIC_STRING
;
1450 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
1451 bytesNeeded
+= dataLen
;
1453 case ASN_PRINTABLESTRING
:
1454 valueType
= CERT_RDN_PRINTABLE_STRING
;
1455 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
1456 bytesNeeded
+= dataLen
;
1459 valueType
= CERT_RDN_IA5_STRING
;
1460 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
1461 bytesNeeded
+= dataLen
;
1464 valueType
= CERT_RDN_T61_STRING
;
1465 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
1466 bytesNeeded
+= dataLen
;
1468 case ASN_VIDEOTEXSTRING
:
1469 valueType
= CERT_RDN_VIDEOTEX_STRING
;
1470 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
1471 bytesNeeded
+= dataLen
;
1473 case ASN_GRAPHICSTRING
:
1474 valueType
= CERT_RDN_GRAPHIC_STRING
;
1475 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
1476 bytesNeeded
+= dataLen
;
1478 case ASN_VISIBLESTRING
:
1479 valueType
= CERT_RDN_VISIBLE_STRING
;
1480 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
1481 bytesNeeded
+= dataLen
;
1483 case ASN_GENERALSTRING
:
1484 valueType
= CERT_RDN_GENERAL_STRING
;
1485 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
1486 bytesNeeded
+= dataLen
;
1488 case ASN_UNIVERSALSTRING
:
1489 FIXME("ASN_UNIVERSALSTRING: unimplemented\n");
1490 SetLastError(CRYPT_E_ASN1_BADTAG
);
1493 valueType
= CERT_RDN_BMP_STRING
;
1494 bytesNeeded
+= dataLen
;
1496 case ASN_UTF8STRING
:
1497 valueType
= CERT_RDN_UTF8_STRING
;
1498 bytesNeeded
+= MultiByteToWideChar(CP_UTF8
, 0,
1499 (LPCSTR
)pbEncoded
+ 1 + lenBytes
, dataLen
, NULL
, 0) * 2;
1502 SetLastError(CRYPT_E_ASN1_BADTAG
);
1507 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
1509 *pcbStructInfo
= bytesNeeded
;
1510 else if (*pcbStructInfo
< bytesNeeded
)
1512 *pcbStructInfo
= bytesNeeded
;
1513 SetLastError(ERROR_MORE_DATA
);
1518 *pcbStructInfo
= bytesNeeded
;
1519 value
->dwValueType
= valueType
;
1524 assert(value
->Value
.pbData
);
1525 switch (pbEncoded
[0])
1527 case ASN_OCTETSTRING
:
1528 case ASN_NUMERICSTRING
:
1529 case ASN_PRINTABLESTRING
:
1532 case ASN_VIDEOTEXSTRING
:
1533 case ASN_GRAPHICSTRING
:
1534 case ASN_VISIBLESTRING
:
1535 case ASN_GENERALSTRING
:
1536 value
->Value
.cbData
= dataLen
;
1539 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
1540 memcpy(value
->Value
.pbData
,
1541 pbEncoded
+ 1 + lenBytes
, dataLen
);
1543 value
->Value
.pbData
= (LPBYTE
)pbEncoded
+ 1 +
1549 LPWSTR str
= (LPWSTR
)value
->Value
.pbData
;
1551 value
->Value
.cbData
= dataLen
;
1552 for (i
= 0; i
< dataLen
/ 2; i
++)
1553 str
[i
] = (pbEncoded
[1 + lenBytes
+ 2 * i
] << 8) |
1554 pbEncoded
[1 + lenBytes
+ 2 * i
+ 1];
1557 case ASN_UTF8STRING
:
1559 LPWSTR str
= (LPWSTR
)value
->Value
.pbData
;
1561 value
->Value
.cbData
= MultiByteToWideChar(CP_UTF8
, 0,
1562 (LPCSTR
)pbEncoded
+ 1 + lenBytes
, dataLen
,
1563 str
, bytesNeeded
- sizeof(CERT_NAME_VALUE
)) * 2;
1570 value
->Value
.cbData
= 0;
1571 value
->Value
.pbData
= NULL
;
1578 static BOOL WINAPI
CRYPT_AsnDecodeNameValue(DWORD dwCertEncodingType
,
1579 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
1580 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
1586 ret
= CRYPT_AsnDecodeNameValueInternal(pbEncoded
, cbEncoded
,
1587 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, pcbStructInfo
, NULL
);
1588 if (ret
&& pvStructInfo
)
1590 ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
, pvStructInfo
,
1591 pcbStructInfo
, *pcbStructInfo
);
1594 CERT_NAME_VALUE
*value
;
1596 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
1597 pvStructInfo
= *(BYTE
**)pvStructInfo
;
1598 value
= (CERT_NAME_VALUE
*)pvStructInfo
;
1599 value
->Value
.pbData
= ((BYTE
*)value
+ sizeof(CERT_NAME_VALUE
));
1600 ret
= CRYPT_AsnDecodeNameValueInternal( pbEncoded
, cbEncoded
,
1601 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
1602 pcbStructInfo
, NULL
);
1608 SetLastError(STATUS_ACCESS_VIOLATION
);
1615 static BOOL
CRYPT_AsnDecodeUnicodeNameValueInternal(const BYTE
*pbEncoded
,
1616 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
1621 CERT_NAME_VALUE
*value
= (CERT_NAME_VALUE
*)pvStructInfo
;
1623 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
1625 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
1626 DWORD bytesNeeded
= sizeof(CERT_NAME_VALUE
), valueType
;
1628 switch (pbEncoded
[0])
1630 case ASN_NUMERICSTRING
:
1631 valueType
= CERT_RDN_NUMERIC_STRING
;
1632 bytesNeeded
+= dataLen
* 2;
1634 case ASN_PRINTABLESTRING
:
1635 valueType
= CERT_RDN_PRINTABLE_STRING
;
1636 bytesNeeded
+= dataLen
* 2;
1639 valueType
= CERT_RDN_IA5_STRING
;
1640 bytesNeeded
+= dataLen
* 2;
1643 valueType
= CERT_RDN_T61_STRING
;
1644 bytesNeeded
+= dataLen
* 2;
1646 case ASN_VIDEOTEXSTRING
:
1647 valueType
= CERT_RDN_VIDEOTEX_STRING
;
1648 bytesNeeded
+= dataLen
* 2;
1650 case ASN_GRAPHICSTRING
:
1651 valueType
= CERT_RDN_GRAPHIC_STRING
;
1652 bytesNeeded
+= dataLen
* 2;
1654 case ASN_VISIBLESTRING
:
1655 valueType
= CERT_RDN_VISIBLE_STRING
;
1656 bytesNeeded
+= dataLen
* 2;
1658 case ASN_GENERALSTRING
:
1659 valueType
= CERT_RDN_GENERAL_STRING
;
1660 bytesNeeded
+= dataLen
* 2;
1662 case ASN_UNIVERSALSTRING
:
1663 valueType
= CERT_RDN_UNIVERSAL_STRING
;
1664 bytesNeeded
+= dataLen
/ 2;
1667 valueType
= CERT_RDN_BMP_STRING
;
1668 bytesNeeded
+= dataLen
;
1670 case ASN_UTF8STRING
:
1671 valueType
= CERT_RDN_UTF8_STRING
;
1672 bytesNeeded
+= MultiByteToWideChar(CP_UTF8
, 0,
1673 (LPCSTR
)pbEncoded
+ 1 + lenBytes
, dataLen
, NULL
, 0) * 2;
1676 SetLastError(CRYPT_E_ASN1_BADTAG
);
1681 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
1683 *pcbStructInfo
= bytesNeeded
;
1684 else if (*pcbStructInfo
< bytesNeeded
)
1686 *pcbStructInfo
= bytesNeeded
;
1687 SetLastError(ERROR_MORE_DATA
);
1692 *pcbStructInfo
= bytesNeeded
;
1693 value
->dwValueType
= valueType
;
1697 LPWSTR str
= (LPWSTR
)value
->Value
.pbData
;
1699 assert(value
->Value
.pbData
);
1700 switch (pbEncoded
[0])
1702 case ASN_NUMERICSTRING
:
1703 case ASN_PRINTABLESTRING
:
1706 case ASN_VIDEOTEXSTRING
:
1707 case ASN_GRAPHICSTRING
:
1708 case ASN_VISIBLESTRING
:
1709 case ASN_GENERALSTRING
:
1710 value
->Value
.cbData
= dataLen
* 2;
1711 for (i
= 0; i
< dataLen
; i
++)
1712 str
[i
] = pbEncoded
[1 + lenBytes
+ i
];
1714 case ASN_UNIVERSALSTRING
:
1715 value
->Value
.cbData
= dataLen
/ 2;
1716 for (i
= 0; i
< dataLen
/ 4; i
++)
1717 str
[i
] = (pbEncoded
[1 + lenBytes
+ 2 * i
+ 2] << 8)
1718 | pbEncoded
[1 + lenBytes
+ 2 * i
+ 3];
1721 value
->Value
.cbData
= dataLen
;
1722 for (i
= 0; i
< dataLen
/ 2; i
++)
1723 str
[i
] = (pbEncoded
[1 + lenBytes
+ 2 * i
] << 8) |
1724 pbEncoded
[1 + lenBytes
+ 2 * i
+ 1];
1726 case ASN_UTF8STRING
:
1727 value
->Value
.cbData
= MultiByteToWideChar(CP_UTF8
, 0,
1728 (LPCSTR
)pbEncoded
+ 1 + lenBytes
, dataLen
,
1729 str
, bytesNeeded
- sizeof(CERT_NAME_VALUE
)) * 2;
1735 value
->Value
.cbData
= 0;
1736 value
->Value
.pbData
= NULL
;
1743 static BOOL WINAPI
CRYPT_AsnDecodeUnicodeNameValue(DWORD dwCertEncodingType
,
1744 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
1745 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
1751 ret
= CRYPT_AsnDecodeUnicodeNameValueInternal(pbEncoded
, cbEncoded
,
1752 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, pcbStructInfo
, NULL
);
1753 if (ret
&& pvStructInfo
)
1755 ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
, pvStructInfo
,
1756 pcbStructInfo
, *pcbStructInfo
);
1759 CERT_NAME_VALUE
*value
;
1761 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
1762 pvStructInfo
= *(BYTE
**)pvStructInfo
;
1763 value
= (CERT_NAME_VALUE
*)pvStructInfo
;
1764 value
->Value
.pbData
= ((BYTE
*)value
+ sizeof(CERT_NAME_VALUE
));
1765 ret
= CRYPT_AsnDecodeUnicodeNameValueInternal(pbEncoded
,
1766 cbEncoded
, dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
1767 pcbStructInfo
, NULL
);
1773 SetLastError(STATUS_ACCESS_VIOLATION
);
1780 static BOOL
CRYPT_AsnDecodeRdnAttr(const BYTE
*pbEncoded
, DWORD cbEncoded
,
1781 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
1784 struct AsnDecodeSequenceItem items
[] = {
1785 { ASN_OBJECTIDENTIFIER
, offsetof(CERT_RDN_ATTR
, pszObjId
),
1786 CRYPT_AsnDecodeOidIgnoreTag
, sizeof(LPSTR
), FALSE
, TRUE
,
1787 offsetof(CERT_RDN_ATTR
, pszObjId
), 0 },
1788 { 0, offsetof(CERT_RDN_ATTR
, dwValueType
),
1789 CRYPT_AsnDecodeNameValueInternal
, sizeof(CERT_NAME_VALUE
),
1790 FALSE
, TRUE
, offsetof(CERT_RDN_ATTR
, Value
.pbData
), 0 },
1792 CERT_RDN_ATTR
*attr
= (CERT_RDN_ATTR
*)pvStructInfo
;
1794 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
1795 pvStructInfo
, *pcbStructInfo
);
1798 TRACE("attr->pszObjId is %p\n", attr
->pszObjId
);
1799 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
1800 pbEncoded
, cbEncoded
, dwFlags
, NULL
, attr
, pcbStructInfo
, pcbDecoded
,
1801 attr
? attr
->pszObjId
: NULL
);
1804 TRACE("attr->pszObjId is %p (%s)\n", attr
->pszObjId
,
1805 debugstr_a(attr
->pszObjId
));
1806 TRACE("attr->dwValueType is %d\n", attr
->dwValueType
);
1808 TRACE("returning %d (%08x)\n", ret
, GetLastError());
1812 static BOOL
CRYPT_AsnDecodeRdn(const BYTE
*pbEncoded
, DWORD cbEncoded
,
1813 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
1816 struct AsnArrayDescriptor arrayDesc
= { ASN_CONSTRUCTOR
| ASN_SETOF
,
1817 CRYPT_AsnDecodeRdnAttr
, sizeof(CERT_RDN_ATTR
), TRUE
,
1818 offsetof(CERT_RDN_ATTR
, pszObjId
) };
1819 PCERT_RDN rdn
= (PCERT_RDN
)pvStructInfo
;
1821 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
1822 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
1823 rdn
? rdn
->rgRDNAttr
: NULL
);
1827 static BOOL WINAPI
CRYPT_AsnDecodeName(DWORD dwCertEncodingType
,
1828 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
1829 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
1835 struct AsnArrayDescriptor arrayDesc
= { ASN_SEQUENCEOF
,
1836 CRYPT_AsnDecodeRdn
, sizeof(CERT_RDN
), TRUE
,
1837 offsetof(CERT_RDN
, rgRDNAttr
) };
1839 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
1840 pDecodePara
, pvStructInfo
, pcbStructInfo
, NULL
, NULL
);
1844 SetLastError(STATUS_ACCESS_VIOLATION
);
1851 static BOOL
CRYPT_AsnDecodeUnicodeRdnAttr(const BYTE
*pbEncoded
,
1852 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
1856 struct AsnDecodeSequenceItem items
[] = {
1857 { ASN_OBJECTIDENTIFIER
, offsetof(CERT_RDN_ATTR
, pszObjId
),
1858 CRYPT_AsnDecodeOidIgnoreTag
, sizeof(LPSTR
), FALSE
, TRUE
,
1859 offsetof(CERT_RDN_ATTR
, pszObjId
), 0 },
1860 { 0, offsetof(CERT_RDN_ATTR
, dwValueType
),
1861 CRYPT_AsnDecodeUnicodeNameValueInternal
, sizeof(CERT_NAME_VALUE
),
1862 FALSE
, TRUE
, offsetof(CERT_RDN_ATTR
, Value
.pbData
), 0 },
1864 CERT_RDN_ATTR
*attr
= (CERT_RDN_ATTR
*)pvStructInfo
;
1866 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
1867 pvStructInfo
, *pcbStructInfo
);
1870 TRACE("attr->pszObjId is %p\n", attr
->pszObjId
);
1871 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
1872 pbEncoded
, cbEncoded
, dwFlags
, NULL
, attr
, pcbStructInfo
, pcbDecoded
,
1873 attr
? attr
->pszObjId
: NULL
);
1876 TRACE("attr->pszObjId is %p (%s)\n", attr
->pszObjId
,
1877 debugstr_a(attr
->pszObjId
));
1878 TRACE("attr->dwValueType is %d\n", attr
->dwValueType
);
1880 TRACE("returning %d (%08x)\n", ret
, GetLastError());
1884 static BOOL
CRYPT_AsnDecodeUnicodeRdn(const BYTE
*pbEncoded
, DWORD cbEncoded
,
1885 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
1888 struct AsnArrayDescriptor arrayDesc
= { ASN_CONSTRUCTOR
| ASN_SETOF
,
1889 CRYPT_AsnDecodeUnicodeRdnAttr
, sizeof(CERT_RDN_ATTR
), TRUE
,
1890 offsetof(CERT_RDN_ATTR
, pszObjId
) };
1891 PCERT_RDN rdn
= (PCERT_RDN
)pvStructInfo
;
1893 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
1894 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
1895 rdn
? rdn
->rgRDNAttr
: NULL
);
1899 static BOOL WINAPI
CRYPT_AsnDecodeUnicodeName(DWORD dwCertEncodingType
,
1900 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
1901 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
1907 struct AsnArrayDescriptor arrayDesc
= { ASN_SEQUENCEOF
,
1908 CRYPT_AsnDecodeUnicodeRdn
, sizeof(CERT_RDN
), TRUE
,
1909 offsetof(CERT_RDN
, rgRDNAttr
) };
1911 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
1912 pDecodePara
, pvStructInfo
, pcbStructInfo
, NULL
, NULL
);
1916 SetLastError(STATUS_ACCESS_VIOLATION
);
1923 static BOOL
CRYPT_FindEncodedLen(const BYTE
*pbEncoded
, DWORD cbEncoded
,
1926 BOOL ret
= TRUE
, done
= FALSE
;
1927 DWORD indefiniteNestingLevels
= 0, decoded
= 0;
1929 TRACE("(%p, %d)\n", pbEncoded
, cbEncoded
);
1936 else if ((ret
= CRYPT_GetLengthIndefinite(pbEncoded
, cbEncoded
,
1939 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
1941 if (dataLen
== CMSG_INDEFINITE_LENGTH
)
1943 indefiniteNestingLevels
++;
1944 pbEncoded
+= 1 + lenBytes
;
1945 cbEncoded
-= 1 + lenBytes
;
1946 decoded
+= 1 + lenBytes
;
1947 TRACE("indefiniteNestingLevels = %d\n",
1948 indefiniteNestingLevels
);
1952 if (pbEncoded
[0] == 0 && pbEncoded
[1] == 0 &&
1953 indefiniteNestingLevels
)
1955 indefiniteNestingLevels
--;
1956 TRACE("indefiniteNestingLevels = %d\n",
1957 indefiniteNestingLevels
);
1959 pbEncoded
+= 1 + lenBytes
+ dataLen
;
1960 cbEncoded
-= 1 + lenBytes
+ dataLen
;
1961 decoded
+= 1 + lenBytes
+ dataLen
;
1962 if (!indefiniteNestingLevels
)
1966 } while (ret
&& !done
);
1967 /* If we haven't found all 0 TLVs, we haven't found the end */
1968 if (ret
&& indefiniteNestingLevels
)
1970 SetLastError(CRYPT_E_ASN1_EOD
);
1974 *pcbDecoded
= decoded
;
1975 TRACE("returning %d (%d)\n", ret
, ret
? *pcbDecoded
: 0);
1979 static BOOL
CRYPT_AsnDecodeCopyBytes(const BYTE
*pbEncoded
,
1980 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
1984 DWORD bytesNeeded
= sizeof(CRYPT_OBJID_BLOB
), encodedLen
= 0;
1986 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
1987 pvStructInfo
, *pcbStructInfo
);
1989 if ((ret
= CRYPT_FindEncodedLen(pbEncoded
, cbEncoded
, &encodedLen
)))
1991 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
1992 bytesNeeded
+= encodedLen
;
1994 *pcbStructInfo
= bytesNeeded
;
1995 else if (*pcbStructInfo
< bytesNeeded
)
1997 SetLastError(ERROR_MORE_DATA
);
1998 *pcbStructInfo
= bytesNeeded
;
2003 PCRYPT_OBJID_BLOB blob
= (PCRYPT_OBJID_BLOB
)pvStructInfo
;
2005 *pcbStructInfo
= bytesNeeded
;
2006 blob
->cbData
= encodedLen
;
2009 if (dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
)
2010 blob
->pbData
= (LPBYTE
)pbEncoded
;
2013 assert(blob
->pbData
);
2014 memcpy(blob
->pbData
, pbEncoded
, blob
->cbData
);
2018 blob
->pbData
= NULL
;
2021 *pcbDecoded
= encodedLen
;
2026 static BOOL
CRYPT_DecodeDERArray(const BYTE
*pbEncoded
, DWORD cbEncoded
,
2027 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
2030 struct AsnArrayDescriptor arrayDesc
= { 0, CRYPT_AsnDecodeCopyBytes
,
2031 sizeof(CRYPT_DER_BLOB
), TRUE
, offsetof(CRYPT_DER_BLOB
, pbData
) };
2032 struct GenericArray
*array
= (struct GenericArray
*)pvStructInfo
;
2034 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
2035 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
2037 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
2038 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
2039 array
? array
->rgItems
: NULL
);
2043 static BOOL
CRYPT_AsnDecodeCTLUsage(const BYTE
*pbEncoded
, DWORD cbEncoded
,
2044 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
2047 struct AsnArrayDescriptor arrayDesc
= { ASN_SEQUENCEOF
,
2048 CRYPT_AsnDecodeOidInternal
, sizeof(LPSTR
), TRUE
, 0 };
2049 CTL_USAGE
*usage
= (CTL_USAGE
*)pvStructInfo
;
2051 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
2052 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
2053 usage
? usage
->rgpszUsageIdentifier
: NULL
);
2057 static BOOL
CRYPT_AsnDecodeCTLEntry(const BYTE
*pbEncoded
, DWORD cbEncoded
,
2058 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
2060 struct AsnDecodeSequenceItem items
[] = {
2061 { ASN_OCTETSTRING
, offsetof(CTL_ENTRY
, SubjectIdentifier
),
2062 CRYPT_AsnDecodeOctetsInternal
, sizeof(CRYPT_DATA_BLOB
), FALSE
, TRUE
,
2063 offsetof(CTL_ENTRY
, SubjectIdentifier
.pbData
), 0 },
2064 { ASN_CONSTRUCTOR
| ASN_SETOF
, offsetof(CTL_ENTRY
, cAttribute
),
2065 CRYPT_AsnDecodePKCSAttributesInternal
, sizeof(CRYPT_ATTRIBUTES
), FALSE
,
2066 TRUE
, offsetof(CTL_ENTRY
, rgAttribute
), 0 },
2069 CTL_ENTRY
*entry
= (CTL_ENTRY
*)pvStructInfo
;
2071 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
, entry
,
2074 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
2075 pbEncoded
, cbEncoded
, dwFlags
, NULL
, entry
, pcbStructInfo
,
2076 pcbDecoded
, entry
? entry
->SubjectIdentifier
.pbData
: NULL
);
2080 static BOOL
CRYPT_AsnDecodeCTLEntries(const BYTE
*pbEncoded
, DWORD cbEncoded
,
2081 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
2084 struct AsnArrayDescriptor arrayDesc
= { ASN_SEQUENCEOF
,
2085 CRYPT_AsnDecodeCTLEntry
, sizeof(CTL_ENTRY
), TRUE
,
2086 offsetof(CTL_ENTRY
, SubjectIdentifier
.pbData
) };
2087 struct GenericArray
*entries
= (struct GenericArray
*)pvStructInfo
;
2089 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
2090 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
2092 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
2093 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
2094 entries
? entries
->rgItems
: NULL
);
2098 static BOOL WINAPI
CRYPT_AsnDecodeCTL(DWORD dwCertEncodingType
,
2099 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
2100 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
2104 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
2105 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
2109 struct AsnDecodeSequenceItem items
[] = {
2110 { ASN_INTEGER
, offsetof(CTL_INFO
, dwVersion
),
2111 CRYPT_AsnDecodeIntInternal
, sizeof(DWORD
), TRUE
, FALSE
, 0, 0 },
2112 { ASN_SEQUENCEOF
, offsetof(CTL_INFO
, SubjectUsage
),
2113 CRYPT_AsnDecodeCTLUsage
, sizeof(CTL_USAGE
), FALSE
, TRUE
,
2114 offsetof(CTL_INFO
, SubjectUsage
.rgpszUsageIdentifier
), 0 },
2115 { ASN_OCTETSTRING
, offsetof(CTL_INFO
, ListIdentifier
),
2116 CRYPT_AsnDecodeOctetsInternal
, sizeof(CRYPT_DATA_BLOB
), TRUE
,
2117 TRUE
, offsetof(CTL_INFO
, ListIdentifier
.pbData
), 0 },
2118 { ASN_INTEGER
, offsetof(CTL_INFO
, SequenceNumber
),
2119 CRYPT_AsnDecodeIntegerInternal
, sizeof(CRYPT_INTEGER_BLOB
),
2120 TRUE
, TRUE
, offsetof(CTL_INFO
, SequenceNumber
.pbData
), 0 },
2121 { 0, offsetof(CTL_INFO
, ThisUpdate
),
2122 CRYPT_AsnDecodeChoiceOfTimeInternal
, sizeof(FILETIME
), FALSE
, FALSE
,
2124 { 0, offsetof(CTL_INFO
, NextUpdate
),
2125 CRYPT_AsnDecodeChoiceOfTimeInternal
, sizeof(FILETIME
), TRUE
, FALSE
,
2127 { ASN_SEQUENCEOF
, offsetof(CTL_INFO
, SubjectAlgorithm
),
2128 CRYPT_AsnDecodeAlgorithmId
, sizeof(CRYPT_ALGORITHM_IDENTIFIER
),
2129 FALSE
, TRUE
, offsetof(CTL_INFO
, SubjectAlgorithm
.pszObjId
), 0 },
2130 { ASN_SEQUENCEOF
, offsetof(CTL_INFO
, cCTLEntry
),
2131 CRYPT_AsnDecodeCTLEntries
, sizeof(struct GenericArray
),
2132 TRUE
, TRUE
, offsetof(CTL_INFO
, rgCTLEntry
), 0 },
2133 { ASN_CONTEXT
| ASN_CONSTRUCTOR
| 0, offsetof(CTL_INFO
, cExtension
),
2134 CRYPT_AsnDecodeCertExtensions
, sizeof(CERT_EXTENSIONS
), TRUE
, TRUE
,
2135 offsetof(CTL_INFO
, rgExtension
), 0 },
2138 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
2139 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
2141 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
2142 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
,
2143 pcbStructInfo
, NULL
, NULL
);
2147 SetLastError(STATUS_ACCESS_VIOLATION
);
2153 static BOOL
CRYPT_AsnDecodeSMIMECapability(const BYTE
*pbEncoded
,
2154 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
2158 struct AsnDecodeSequenceItem items
[] = {
2159 { ASN_OBJECTIDENTIFIER
, offsetof(CRYPT_SMIME_CAPABILITY
, pszObjId
),
2160 CRYPT_AsnDecodeOidIgnoreTag
, sizeof(LPSTR
), FALSE
, TRUE
,
2161 offsetof(CRYPT_SMIME_CAPABILITY
, pszObjId
), 0 },
2162 { 0, offsetof(CRYPT_SMIME_CAPABILITY
, Parameters
),
2163 CRYPT_AsnDecodeCopyBytes
, sizeof(CRYPT_OBJID_BLOB
), TRUE
, TRUE
,
2164 offsetof(CRYPT_SMIME_CAPABILITY
, Parameters
.pbData
), 0 },
2166 PCRYPT_SMIME_CAPABILITY capability
= (PCRYPT_SMIME_CAPABILITY
)pvStructInfo
;
2168 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
2169 pvStructInfo
, *pcbStructInfo
);
2171 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
2172 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
2173 pcbDecoded
, capability
? capability
->pszObjId
: NULL
);
2174 TRACE("returning %d\n", ret
);
2178 static BOOL
CRYPT_AsnDecodeSMIMECapabilitiesInternal(const BYTE
*pbEncoded
,
2179 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
2182 struct AsnArrayDescriptor arrayDesc
= { 0,
2183 CRYPT_AsnDecodeSMIMECapability
, sizeof(CRYPT_SMIME_CAPABILITY
), TRUE
,
2184 offsetof(CRYPT_SMIME_CAPABILITY
, pszObjId
) };
2185 PCRYPT_SMIME_CAPABILITIES capabilities
=
2186 (PCRYPT_SMIME_CAPABILITIES
)pvStructInfo
;
2189 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
2190 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
2191 capabilities
? capabilities
->rgCapability
: NULL
);
2195 static BOOL WINAPI
CRYPT_AsnDecodeSMIMECapabilities(DWORD dwCertEncodingType
,
2196 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
2197 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
2201 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
2202 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
2209 SetLastError(CRYPT_E_ASN1_EOD
);
2210 else if (pbEncoded
[0] != ASN_SEQUENCEOF
)
2211 SetLastError(CRYPT_E_ASN1_CORRUPT
);
2212 else if ((ret
= CRYPT_AsnDecodeSMIMECapabilitiesInternal(pbEncoded
,
2213 cbEncoded
, dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, &bytesNeeded
,
2217 *pcbStructInfo
= bytesNeeded
;
2218 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
2219 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
2221 PCRYPT_SMIME_CAPABILITIES capabilities
;
2223 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
2224 pvStructInfo
= *(BYTE
**)pvStructInfo
;
2225 capabilities
= (PCRYPT_SMIME_CAPABILITIES
)pvStructInfo
;
2226 capabilities
->rgCapability
=
2227 (PCRYPT_SMIME_CAPABILITY
)((BYTE
*)pvStructInfo
+
2228 sizeof(CRYPT_SMIME_CAPABILITIES
));
2229 ret
= CRYPT_AsnDecodeSMIMECapabilitiesInternal(pbEncoded
,
2230 cbEncoded
, dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
2231 &bytesNeeded
, NULL
);
2237 SetLastError(STATUS_ACCESS_VIOLATION
);
2240 TRACE("returning %d\n", ret
);
2244 static BOOL
CRYPT_AsnDecodePKCSAttributeInternal(const BYTE
*pbEncoded
,
2245 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
2249 struct AsnDecodeSequenceItem items
[] = {
2250 { ASN_OBJECTIDENTIFIER
, offsetof(CRYPT_ATTRIBUTE
, pszObjId
),
2251 CRYPT_AsnDecodeOidIgnoreTag
, sizeof(LPSTR
), FALSE
, TRUE
,
2252 offsetof(CRYPT_ATTRIBUTE
, pszObjId
), 0 },
2253 { ASN_CONSTRUCTOR
| ASN_SETOF
, offsetof(CRYPT_ATTRIBUTE
, cValue
),
2254 CRYPT_DecodeDERArray
, sizeof(struct GenericArray
), FALSE
, TRUE
,
2255 offsetof(CRYPT_ATTRIBUTE
, rgValue
), 0 },
2257 PCRYPT_ATTRIBUTE attr
= (PCRYPT_ATTRIBUTE
)pvStructInfo
;
2259 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
2260 pvStructInfo
, *pcbStructInfo
);
2262 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
2263 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
2264 pcbDecoded
, attr
? attr
->pszObjId
: NULL
);
2265 TRACE("returning %d\n", ret
);
2269 static BOOL WINAPI
CRYPT_AsnDecodePKCSAttribute(DWORD dwCertEncodingType
,
2270 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
2271 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
2275 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
2276 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
2282 ret
= CRYPT_AsnDecodePKCSAttributeInternal(pbEncoded
, cbEncoded
,
2283 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, &bytesNeeded
, NULL
);
2287 *pcbStructInfo
= bytesNeeded
;
2288 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
2289 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
2291 PCRYPT_ATTRIBUTE attr
;
2293 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
2294 pvStructInfo
= *(BYTE
**)pvStructInfo
;
2295 attr
= (PCRYPT_ATTRIBUTE
)pvStructInfo
;
2296 attr
->pszObjId
= (LPSTR
)((BYTE
*)pvStructInfo
+
2297 sizeof(CRYPT_ATTRIBUTE
));
2298 ret
= CRYPT_AsnDecodePKCSAttributeInternal(pbEncoded
, cbEncoded
,
2299 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
, &bytesNeeded
,
2306 SetLastError(STATUS_ACCESS_VIOLATION
);
2309 TRACE("returning %d\n", ret
);
2313 static BOOL
CRYPT_AsnDecodePKCSAttributesInternal(const BYTE
*pbEncoded
,
2314 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
2317 struct AsnArrayDescriptor arrayDesc
= { 0,
2318 CRYPT_AsnDecodePKCSAttributeInternal
, sizeof(CRYPT_ATTRIBUTE
), TRUE
,
2319 offsetof(CRYPT_ATTRIBUTE
, pszObjId
) };
2320 PCRYPT_ATTRIBUTES attrs
= (PCRYPT_ATTRIBUTES
)pvStructInfo
;
2323 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
2324 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
, attrs
? attrs
->rgAttr
:
2329 static BOOL WINAPI
CRYPT_AsnDecodePKCSAttributes(DWORD dwCertEncodingType
,
2330 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
2331 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
2335 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
2336 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
2343 SetLastError(CRYPT_E_ASN1_EOD
);
2344 else if (pbEncoded
[0] != (ASN_CONSTRUCTOR
| ASN_SETOF
))
2345 SetLastError(CRYPT_E_ASN1_CORRUPT
);
2346 else if ((ret
= CRYPT_AsnDecodePKCSAttributesInternal(pbEncoded
,
2347 cbEncoded
, dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, &bytesNeeded
,
2351 *pcbStructInfo
= bytesNeeded
;
2352 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
2353 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
2355 PCRYPT_ATTRIBUTES attrs
;
2357 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
2358 pvStructInfo
= *(BYTE
**)pvStructInfo
;
2359 attrs
= (PCRYPT_ATTRIBUTES
)pvStructInfo
;
2360 attrs
->rgAttr
= (PCRYPT_ATTRIBUTE
)((BYTE
*)pvStructInfo
+
2361 sizeof(CRYPT_ATTRIBUTES
));
2362 ret
= CRYPT_AsnDecodePKCSAttributesInternal(pbEncoded
,
2363 cbEncoded
, dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
2364 &bytesNeeded
, NULL
);
2370 SetLastError(STATUS_ACCESS_VIOLATION
);
2373 TRACE("returning %d\n", ret
);
2377 static BOOL
CRYPT_AsnDecodeAlgorithmId(const BYTE
*pbEncoded
, DWORD cbEncoded
,
2378 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
2380 CRYPT_ALGORITHM_IDENTIFIER
*algo
=
2381 (CRYPT_ALGORITHM_IDENTIFIER
*)pvStructInfo
;
2383 struct AsnDecodeSequenceItem items
[] = {
2384 { ASN_OBJECTIDENTIFIER
, offsetof(CRYPT_ALGORITHM_IDENTIFIER
, pszObjId
),
2385 CRYPT_AsnDecodeOidIgnoreTag
, sizeof(LPSTR
), FALSE
, TRUE
,
2386 offsetof(CRYPT_ALGORITHM_IDENTIFIER
, pszObjId
), 0 },
2387 { 0, offsetof(CRYPT_ALGORITHM_IDENTIFIER
, Parameters
),
2388 CRYPT_AsnDecodeCopyBytes
, sizeof(CRYPT_OBJID_BLOB
), TRUE
, TRUE
,
2389 offsetof(CRYPT_ALGORITHM_IDENTIFIER
, Parameters
.pbData
), 0 },
2392 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
2393 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
2395 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
2396 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
2397 pcbDecoded
, algo
? algo
->pszObjId
: NULL
);
2398 if (ret
&& pvStructInfo
)
2400 TRACE("pszObjId is %p (%s)\n", algo
->pszObjId
,
2401 debugstr_a(algo
->pszObjId
));
2406 static BOOL
CRYPT_AsnDecodePubKeyInfoInternal(const BYTE
*pbEncoded
,
2407 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
2411 struct AsnDecodeSequenceItem items
[] = {
2412 { ASN_SEQUENCEOF
, offsetof(CERT_PUBLIC_KEY_INFO
, Algorithm
),
2413 CRYPT_AsnDecodeAlgorithmId
, sizeof(CRYPT_ALGORITHM_IDENTIFIER
),
2414 FALSE
, TRUE
, offsetof(CERT_PUBLIC_KEY_INFO
,
2415 Algorithm
.pszObjId
) },
2416 { ASN_BITSTRING
, offsetof(CERT_PUBLIC_KEY_INFO
, PublicKey
),
2417 CRYPT_AsnDecodeBitsInternal
, sizeof(CRYPT_BIT_BLOB
), FALSE
, TRUE
,
2418 offsetof(CERT_PUBLIC_KEY_INFO
, PublicKey
.pbData
) },
2420 PCERT_PUBLIC_KEY_INFO info
= (PCERT_PUBLIC_KEY_INFO
)pvStructInfo
;
2422 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
2423 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
2424 pcbDecoded
, info
? info
->Algorithm
.Parameters
.pbData
: NULL
);
2428 static BOOL WINAPI
CRYPT_AsnDecodePubKeyInfo(DWORD dwCertEncodingType
,
2429 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
2430 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
2438 if ((ret
= CRYPT_AsnDecodePubKeyInfoInternal(pbEncoded
, cbEncoded
,
2439 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, &bytesNeeded
, NULL
)))
2442 *pcbStructInfo
= bytesNeeded
;
2443 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
2444 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
2446 PCERT_PUBLIC_KEY_INFO info
;
2448 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
2449 pvStructInfo
= *(BYTE
**)pvStructInfo
;
2450 info
= (PCERT_PUBLIC_KEY_INFO
)pvStructInfo
;
2451 info
->Algorithm
.Parameters
.pbData
= (BYTE
*)pvStructInfo
+
2452 sizeof(CERT_PUBLIC_KEY_INFO
);
2453 ret
= CRYPT_AsnDecodePubKeyInfoInternal(pbEncoded
, cbEncoded
,
2454 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
2455 &bytesNeeded
, NULL
);
2461 SetLastError(STATUS_ACCESS_VIOLATION
);
2468 static BOOL
CRYPT_AsnDecodeBool(const BYTE
*pbEncoded
, DWORD cbEncoded
,
2469 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
2475 SetLastError(CRYPT_E_ASN1_CORRUPT
);
2478 if (GET_LEN_BYTES(pbEncoded
[1]) > 1)
2480 SetLastError(CRYPT_E_ASN1_CORRUPT
);
2483 if (pbEncoded
[1] > 1)
2485 SetLastError(CRYPT_E_ASN1_CORRUPT
);
2492 *pcbStructInfo
= sizeof(BOOL
);
2495 else if (*pcbStructInfo
< sizeof(BOOL
))
2497 *pcbStructInfo
= sizeof(BOOL
);
2498 SetLastError(ERROR_MORE_DATA
);
2503 *pcbStructInfo
= sizeof(BOOL
);
2504 *(BOOL
*)pvStructInfo
= pbEncoded
[2] ? TRUE
: FALSE
;
2507 TRACE("returning %d (%08x)\n", ret
, GetLastError());
2511 static BOOL
CRYPT_AsnDecodeAltNameEntry(const BYTE
*pbEncoded
, DWORD cbEncoded
,
2512 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
2514 PCERT_ALT_NAME_ENTRY entry
= (PCERT_ALT_NAME_ENTRY
)pvStructInfo
;
2515 DWORD dataLen
, lenBytes
, bytesNeeded
= sizeof(CERT_ALT_NAME_ENTRY
);
2518 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
2519 pvStructInfo
, *pcbStructInfo
);
2523 SetLastError(CRYPT_E_ASN1_CORRUPT
);
2526 lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
2527 if (1 + lenBytes
> cbEncoded
)
2529 SetLastError(CRYPT_E_ASN1_CORRUPT
);
2532 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
2534 switch (pbEncoded
[0] & ASN_TYPE_MASK
)
2536 case 1: /* rfc822Name */
2537 case 2: /* dNSName */
2538 case 6: /* uniformResourceIdentifier */
2539 bytesNeeded
+= (dataLen
+ 1) * sizeof(WCHAR
);
2541 case 4: /* directoryName */
2542 case 7: /* iPAddress */
2543 bytesNeeded
+= dataLen
;
2545 case 8: /* registeredID */
2546 ret
= CRYPT_AsnDecodeOidIgnoreTag(pbEncoded
, cbEncoded
, 0, NULL
,
2550 /* FIXME: ugly, shouldn't need to know internals of OID decode
2551 * function to use it.
2553 bytesNeeded
+= dataLen
- sizeof(LPSTR
);
2556 case 0: /* otherName */
2557 FIXME("%d: stub\n", pbEncoded
[0] & ASN_TYPE_MASK
);
2558 SetLastError(CRYPT_E_ASN1_BADTAG
);
2561 case 3: /* x400Address, unimplemented */
2562 case 5: /* ediPartyName, unimplemented */
2563 TRACE("type %d unimplemented\n", pbEncoded
[0] & ASN_TYPE_MASK
);
2564 SetLastError(CRYPT_E_ASN1_BADTAG
);
2568 TRACE("type %d bad\n", pbEncoded
[0] & ASN_TYPE_MASK
);
2569 SetLastError(CRYPT_E_ASN1_CORRUPT
);
2575 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
2577 *pcbStructInfo
= bytesNeeded
;
2578 else if (*pcbStructInfo
< bytesNeeded
)
2580 *pcbStructInfo
= bytesNeeded
;
2581 SetLastError(ERROR_MORE_DATA
);
2586 *pcbStructInfo
= bytesNeeded
;
2587 /* MS used values one greater than the asn1 ones.. sigh */
2588 entry
->dwAltNameChoice
= (pbEncoded
[0] & ASN_TYPE_MASK
) + 1;
2589 switch (pbEncoded
[0] & ASN_TYPE_MASK
)
2591 case 1: /* rfc822Name */
2592 case 2: /* dNSName */
2593 case 6: /* uniformResourceIdentifier */
2597 for (i
= 0; i
< dataLen
; i
++)
2598 entry
->u
.pwszURL
[i
] =
2599 (WCHAR
)pbEncoded
[1 + lenBytes
+ i
];
2600 entry
->u
.pwszURL
[i
] = 0;
2601 TRACE("URL is %p (%s)\n", entry
->u
.pwszURL
,
2602 debugstr_w(entry
->u
.pwszURL
));
2605 case 4: /* directoryName */
2606 /* The data are memory-equivalent with the IPAddress case,
2609 case 7: /* iPAddress */
2610 /* The next data pointer is in the pwszURL spot, that is,
2611 * the first 4 bytes. Need to move it to the next spot.
2613 entry
->u
.IPAddress
.pbData
= (LPBYTE
)entry
->u
.pwszURL
;
2614 entry
->u
.IPAddress
.cbData
= dataLen
;
2615 memcpy(entry
->u
.IPAddress
.pbData
, pbEncoded
+ 1 + lenBytes
,
2618 case 8: /* registeredID */
2619 ret
= CRYPT_AsnDecodeOidIgnoreTag(pbEncoded
, cbEncoded
, 0,
2620 &entry
->u
.pszRegisteredID
, &dataLen
, NULL
);
2629 static BOOL
CRYPT_AsnDecodeAltNameInternal(const BYTE
*pbEncoded
,
2630 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
2634 struct AsnArrayDescriptor arrayDesc
= { 0,
2635 CRYPT_AsnDecodeAltNameEntry
, sizeof(CERT_ALT_NAME_ENTRY
), TRUE
,
2636 offsetof(CERT_ALT_NAME_ENTRY
, u
.pwszURL
) };
2637 PCERT_ALT_NAME_INFO info
= (PCERT_ALT_NAME_INFO
)pvStructInfo
;
2639 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
2640 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
2643 TRACE("info->rgAltEntry is %p\n", info
->rgAltEntry
);
2644 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
2645 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
2646 info
? info
->rgAltEntry
: NULL
);
2650 /* Like CRYPT_AsnDecodeIntegerInternal, but swaps the bytes */
2651 static BOOL
CRYPT_AsnDecodeIntegerSwapBytes(const BYTE
*pbEncoded
,
2652 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
2657 TRACE("(%p, %d, 0x%08x, %p, %d, %p)\n", pbEncoded
, cbEncoded
, dwFlags
,
2658 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
2660 /* Can't use the CRYPT_DECODE_NOCOPY_FLAG, because we modify the bytes in-
2663 ret
= CRYPT_AsnDecodeIntegerInternal(pbEncoded
, cbEncoded
,
2664 dwFlags
& ~CRYPT_DECODE_NOCOPY_FLAG
, pvStructInfo
, pcbStructInfo
,
2666 if (ret
&& pvStructInfo
)
2668 CRYPT_DATA_BLOB
*blob
= (CRYPT_DATA_BLOB
*)pvStructInfo
;
2675 for (i
= 0; i
< blob
->cbData
/ 2; i
++)
2677 temp
= blob
->pbData
[i
];
2678 blob
->pbData
[i
] = blob
->pbData
[blob
->cbData
- i
- 1];
2679 blob
->pbData
[blob
->cbData
- i
- 1] = temp
;
2683 TRACE("returning %d (%08x)\n", ret
, GetLastError());
2687 static BOOL WINAPI
CRYPT_AsnDecodeAuthorityKeyId(DWORD dwCertEncodingType
,
2688 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
2689 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
2695 struct AsnDecodeSequenceItem items
[] = {
2696 { ASN_CONTEXT
| 0, offsetof(CERT_AUTHORITY_KEY_ID_INFO
, KeyId
),
2697 CRYPT_AsnDecodeIntegerSwapBytes
, sizeof(CRYPT_DATA_BLOB
),
2698 TRUE
, TRUE
, offsetof(CERT_AUTHORITY_KEY_ID_INFO
, KeyId
.pbData
), 0 },
2699 { ASN_CONTEXT
| ASN_CONSTRUCTOR
| 1,
2700 offsetof(CERT_AUTHORITY_KEY_ID_INFO
, CertIssuer
),
2701 CRYPT_AsnDecodeOctetsInternal
, sizeof(CERT_NAME_BLOB
), TRUE
, TRUE
,
2702 offsetof(CERT_AUTHORITY_KEY_ID_INFO
, CertIssuer
.pbData
), 0 },
2703 { ASN_CONTEXT
| 2, offsetof(CERT_AUTHORITY_KEY_ID_INFO
,
2704 CertSerialNumber
), CRYPT_AsnDecodeIntegerInternal
,
2705 sizeof(CRYPT_INTEGER_BLOB
), TRUE
, TRUE
,
2706 offsetof(CERT_AUTHORITY_KEY_ID_INFO
, CertSerialNumber
.pbData
), 0 },
2709 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
2710 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
,
2711 pcbStructInfo
, NULL
, NULL
);
2715 SetLastError(STATUS_ACCESS_VIOLATION
);
2722 static BOOL WINAPI
CRYPT_AsnDecodeAuthorityKeyId2(DWORD dwCertEncodingType
,
2723 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
2724 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
2730 struct AsnDecodeSequenceItem items
[] = {
2731 { ASN_CONTEXT
| 0, offsetof(CERT_AUTHORITY_KEY_ID2_INFO
, KeyId
),
2732 CRYPT_AsnDecodeIntegerSwapBytes
, sizeof(CRYPT_DATA_BLOB
),
2733 TRUE
, TRUE
, offsetof(CERT_AUTHORITY_KEY_ID2_INFO
, KeyId
.pbData
), 0 },
2734 { ASN_CONTEXT
| ASN_CONSTRUCTOR
| 1,
2735 offsetof(CERT_AUTHORITY_KEY_ID2_INFO
, AuthorityCertIssuer
),
2736 CRYPT_AsnDecodeAltNameInternal
, sizeof(CERT_ALT_NAME_INFO
), TRUE
,
2737 TRUE
, offsetof(CERT_AUTHORITY_KEY_ID2_INFO
,
2738 AuthorityCertIssuer
.rgAltEntry
), 0 },
2739 { ASN_CONTEXT
| 2, offsetof(CERT_AUTHORITY_KEY_ID2_INFO
,
2740 AuthorityCertSerialNumber
), CRYPT_AsnDecodeIntegerInternal
,
2741 sizeof(CRYPT_INTEGER_BLOB
), TRUE
, TRUE
,
2742 offsetof(CERT_AUTHORITY_KEY_ID2_INFO
,
2743 AuthorityCertSerialNumber
.pbData
), 0 },
2746 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
2747 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
,
2748 pcbStructInfo
, NULL
, NULL
);
2752 SetLastError(STATUS_ACCESS_VIOLATION
);
2759 static BOOL
CRYPT_AsnDecodeAccessDescription(const BYTE
*pbEncoded
,
2760 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
2763 struct AsnDecodeSequenceItem items
[] = {
2764 { 0, offsetof(CERT_ACCESS_DESCRIPTION
, pszAccessMethod
),
2765 CRYPT_AsnDecodeOidInternal
, sizeof(LPSTR
), FALSE
, TRUE
,
2766 offsetof(CERT_ACCESS_DESCRIPTION
, pszAccessMethod
), 0 },
2767 { 0, offsetof(CERT_ACCESS_DESCRIPTION
, AccessLocation
),
2768 CRYPT_AsnDecodeAltNameEntry
, sizeof(CERT_ALT_NAME_ENTRY
), FALSE
,
2769 TRUE
, offsetof(CERT_ACCESS_DESCRIPTION
, AccessLocation
.u
.pwszURL
), 0 },
2771 CERT_ACCESS_DESCRIPTION
*descr
= (CERT_ACCESS_DESCRIPTION
*)pvStructInfo
;
2773 return CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
2774 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
2775 pcbDecoded
, descr
? descr
->pszAccessMethod
: NULL
);
2778 static BOOL WINAPI
CRYPT_AsnDecodeAuthorityInfoAccess(DWORD dwCertEncodingType
,
2779 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
2780 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
2784 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
2785 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
2789 struct AsnArrayDescriptor arrayDesc
= { ASN_SEQUENCEOF
,
2790 CRYPT_AsnDecodeAccessDescription
, sizeof(CERT_ACCESS_DESCRIPTION
),
2791 TRUE
, offsetof(CERT_ACCESS_DESCRIPTION
, pszAccessMethod
) };
2793 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
2794 pDecodePara
, pvStructInfo
, pcbStructInfo
, NULL
, NULL
);
2798 SetLastError(STATUS_ACCESS_VIOLATION
);
2805 static BOOL
CRYPT_AsnDecodePKCSContent(const BYTE
*pbEncoded
, DWORD cbEncoded
,
2806 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
2811 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
2812 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
2814 /* The caller has already checked the tag, no need to check it again.
2815 * Check the outer length is valid:
2817 if ((ret
= CRYPT_GetLengthIndefinite(pbEncoded
, cbEncoded
, &dataLen
)))
2819 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
2822 pbEncoded
+= 1 + lenBytes
;
2823 cbEncoded
-= 1 + lenBytes
;
2824 if (dataLen
== CMSG_INDEFINITE_LENGTH
)
2825 cbEncoded
-= 2; /* space for 0 TLV */
2826 /* Check the inner length is valid: */
2827 if ((ret
= CRYPT_GetLengthIndefinite(pbEncoded
, cbEncoded
, &innerLen
)))
2831 ret
= CRYPT_AsnDecodeCopyBytes(pbEncoded
, cbEncoded
, dwFlags
,
2832 pvStructInfo
, pcbStructInfo
, &decodedLen
);
2833 if (dataLen
== CMSG_INDEFINITE_LENGTH
)
2835 if (*(pbEncoded
+ decodedLen
) != 0 ||
2836 *(pbEncoded
+ decodedLen
+ 1) != 0)
2838 TRACE("expected 0 TLV, got {%02x,%02x}\n",
2839 *(pbEncoded
+ decodedLen
),
2840 *(pbEncoded
+ decodedLen
+ 1));
2841 SetLastError(CRYPT_E_ASN1_CORRUPT
);
2847 if (ret
&& pcbDecoded
)
2849 *pcbDecoded
= 1 + lenBytes
+ decodedLen
;
2850 TRACE("decoded %d bytes\n", *pcbDecoded
);
2857 static BOOL
CRYPT_AsnDecodePKCSContentInfoInternal(const BYTE
*pbEncoded
,
2858 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
2861 CRYPT_CONTENT_INFO
*info
= (CRYPT_CONTENT_INFO
*)pvStructInfo
;
2862 struct AsnDecodeSequenceItem items
[] = {
2863 { ASN_OBJECTIDENTIFIER
, offsetof(CRYPT_CONTENT_INFO
, pszObjId
),
2864 CRYPT_AsnDecodeOidIgnoreTag
, sizeof(LPSTR
), FALSE
, TRUE
,
2865 offsetof(CRYPT_CONTENT_INFO
, pszObjId
), 0 },
2866 { ASN_CONTEXT
| ASN_CONSTRUCTOR
| 0,
2867 offsetof(CRYPT_CONTENT_INFO
, Content
), CRYPT_AsnDecodePKCSContent
,
2868 sizeof(CRYPT_DER_BLOB
), TRUE
, TRUE
,
2869 offsetof(CRYPT_CONTENT_INFO
, Content
.pbData
), 0 },
2873 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
2874 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
2876 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
2877 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
2878 pcbDecoded
, info
? info
->pszObjId
: NULL
);
2882 static BOOL WINAPI
CRYPT_AsnDecodePKCSContentInfo(DWORD dwCertEncodingType
,
2883 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
2884 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
2888 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
2889 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
2893 ret
= CRYPT_AsnDecodePKCSContentInfoInternal(pbEncoded
, cbEncoded
,
2894 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, pcbStructInfo
, NULL
);
2895 if (ret
&& pvStructInfo
)
2897 ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
, pvStructInfo
,
2898 pcbStructInfo
, *pcbStructInfo
);
2901 CRYPT_CONTENT_INFO
*info
;
2903 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
2904 pvStructInfo
= *(BYTE
**)pvStructInfo
;
2905 info
= (CRYPT_CONTENT_INFO
*)pvStructInfo
;
2906 info
->pszObjId
= (LPSTR
)((BYTE
*)info
+
2907 sizeof(CRYPT_CONTENT_INFO
));
2908 ret
= CRYPT_AsnDecodePKCSContentInfoInternal(pbEncoded
,
2909 cbEncoded
, dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
2910 pcbStructInfo
, NULL
);
2916 SetLastError(STATUS_ACCESS_VIOLATION
);
2922 BOOL
CRYPT_AsnDecodePKCSDigestedData(const BYTE
*pbEncoded
, DWORD cbEncoded
,
2923 DWORD dwFlags
, PCRYPT_DECODE_PARA pDecodePara
,
2924 CRYPT_DIGESTED_DATA
*digestedData
, DWORD
*pcbDigestedData
)
2927 struct AsnDecodeSequenceItem items
[] = {
2928 { ASN_INTEGER
, offsetof(CRYPT_DIGESTED_DATA
, version
),
2929 CRYPT_AsnDecodeIntInternal
, sizeof(DWORD
), FALSE
, FALSE
, 0, 0 },
2930 { ASN_SEQUENCEOF
, offsetof(CRYPT_DIGESTED_DATA
, DigestAlgorithm
),
2931 CRYPT_AsnDecodeAlgorithmId
, sizeof(CRYPT_ALGORITHM_IDENTIFIER
),
2932 FALSE
, TRUE
, offsetof(CRYPT_DIGESTED_DATA
, DigestAlgorithm
.pszObjId
),
2934 { ASN_SEQUENCEOF
, offsetof(CRYPT_DIGESTED_DATA
, ContentInfo
),
2935 CRYPT_AsnDecodePKCSContentInfoInternal
,
2936 sizeof(CRYPT_CONTENT_INFO
), FALSE
, TRUE
, offsetof(CRYPT_DIGESTED_DATA
,
2937 ContentInfo
.pszObjId
), 0 },
2938 { ASN_OCTETSTRING
, offsetof(CRYPT_DIGESTED_DATA
, hash
),
2939 CRYPT_AsnDecodeOctetsInternal
, sizeof(CRYPT_HASH_BLOB
), FALSE
, TRUE
,
2940 offsetof(CRYPT_DIGESTED_DATA
, hash
.pbData
), 0 },
2943 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
2944 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, digestedData
, pcbDigestedData
,
2949 static BOOL WINAPI
CRYPT_AsnDecodeAltName(DWORD dwCertEncodingType
,
2950 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
2951 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
2955 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
2956 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
2962 if ((ret
= CRYPT_AsnDecodeAltNameInternal(pbEncoded
, cbEncoded
,
2963 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, &bytesNeeded
, NULL
)))
2966 *pcbStructInfo
= bytesNeeded
;
2967 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
2968 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
2970 CERT_ALT_NAME_INFO
*name
;
2972 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
2973 pvStructInfo
= *(BYTE
**)pvStructInfo
;
2974 name
= (CERT_ALT_NAME_INFO
*)pvStructInfo
;
2975 name
->rgAltEntry
= (PCERT_ALT_NAME_ENTRY
)
2976 ((BYTE
*)pvStructInfo
+ sizeof(CERT_ALT_NAME_INFO
));
2977 ret
= CRYPT_AsnDecodeAltNameInternal(pbEncoded
, cbEncoded
,
2978 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
2979 &bytesNeeded
, NULL
);
2985 SetLastError(STATUS_ACCESS_VIOLATION
);
2992 struct PATH_LEN_CONSTRAINT
2994 BOOL fPathLenConstraint
;
2995 DWORD dwPathLenConstraint
;
2998 static BOOL
CRYPT_AsnDecodePathLenConstraint(const BYTE
*pbEncoded
,
2999 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
3003 DWORD bytesNeeded
= sizeof(struct PATH_LEN_CONSTRAINT
), size
;
3005 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
3006 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
3010 ret
= CRYPT_AsnDecodeIntInternal(pbEncoded
, cbEncoded
, dwFlags
, NULL
,
3012 *pcbStructInfo
= bytesNeeded
;
3014 else if (*pcbStructInfo
< bytesNeeded
)
3016 SetLastError(ERROR_MORE_DATA
);
3017 *pcbStructInfo
= bytesNeeded
;
3022 struct PATH_LEN_CONSTRAINT
*constraint
=
3023 (struct PATH_LEN_CONSTRAINT
*)pvStructInfo
;
3025 *pcbStructInfo
= bytesNeeded
;
3026 size
= sizeof(constraint
->dwPathLenConstraint
);
3027 ret
= CRYPT_AsnDecodeIntInternal(pbEncoded
, cbEncoded
, dwFlags
,
3028 &constraint
->dwPathLenConstraint
, &size
, pcbDecoded
);
3030 constraint
->fPathLenConstraint
= TRUE
;
3031 TRACE("got an int, dwPathLenConstraint is %d\n",
3032 constraint
->dwPathLenConstraint
);
3034 TRACE("returning %d (%08x)\n", ret
, GetLastError());
3038 static BOOL
CRYPT_AsnDecodeSubtreeConstraints(const BYTE
*pbEncoded
,
3039 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
3043 struct AsnArrayDescriptor arrayDesc
= { ASN_SEQUENCEOF
,
3044 CRYPT_AsnDecodeCopyBytes
, sizeof(CERT_NAME_BLOB
), TRUE
,
3045 offsetof(CERT_NAME_BLOB
, pbData
) };
3046 struct GenericArray
*entries
= (struct GenericArray
*)pvStructInfo
;
3048 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
3049 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
3051 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
3052 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
3053 entries
? entries
->rgItems
: NULL
);
3054 TRACE("Returning %d (%08x)\n", ret
, GetLastError());
3058 static BOOL WINAPI
CRYPT_AsnDecodeBasicConstraints(DWORD dwCertEncodingType
,
3059 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
3060 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
3066 struct AsnDecodeSequenceItem items
[] = {
3067 { ASN_BITSTRING
, offsetof(CERT_BASIC_CONSTRAINTS_INFO
, SubjectType
),
3068 CRYPT_AsnDecodeBitsInternal
, sizeof(CRYPT_BIT_BLOB
), FALSE
, TRUE
,
3069 offsetof(CERT_BASIC_CONSTRAINTS_INFO
, SubjectType
.pbData
), 0 },
3070 { ASN_INTEGER
, offsetof(CERT_BASIC_CONSTRAINTS_INFO
,
3071 fPathLenConstraint
), CRYPT_AsnDecodePathLenConstraint
,
3072 sizeof(struct PATH_LEN_CONSTRAINT
), TRUE
, FALSE
, 0, 0 },
3073 { ASN_SEQUENCEOF
, offsetof(CERT_BASIC_CONSTRAINTS_INFO
,
3074 cSubtreesConstraint
), CRYPT_AsnDecodeSubtreeConstraints
,
3075 sizeof(struct GenericArray
), TRUE
, TRUE
,
3076 offsetof(CERT_BASIC_CONSTRAINTS_INFO
, rgSubtreesConstraint
), 0 },
3079 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
3080 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
,
3081 pcbStructInfo
, NULL
, NULL
);
3085 SetLastError(STATUS_ACCESS_VIOLATION
);
3092 static BOOL WINAPI
CRYPT_AsnDecodeBasicConstraints2(DWORD dwCertEncodingType
,
3093 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
3094 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
3100 struct AsnDecodeSequenceItem items
[] = {
3101 { ASN_BOOL
, offsetof(CERT_BASIC_CONSTRAINTS2_INFO
, fCA
),
3102 CRYPT_AsnDecodeBool
, sizeof(BOOL
), TRUE
, FALSE
, 0, 0 },
3103 { ASN_INTEGER
, offsetof(CERT_BASIC_CONSTRAINTS2_INFO
,
3104 fPathLenConstraint
), CRYPT_AsnDecodePathLenConstraint
,
3105 sizeof(struct PATH_LEN_CONSTRAINT
), TRUE
, FALSE
, 0, 0 },
3108 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
3109 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
,
3110 pcbStructInfo
, NULL
, NULL
);
3114 SetLastError(STATUS_ACCESS_VIOLATION
);
3121 #define RSA1_MAGIC 0x31415352
3123 struct DECODED_RSA_PUB_KEY
3126 CRYPT_INTEGER_BLOB modulus
;
3129 static BOOL WINAPI
CRYPT_AsnDecodeRsaPubKey(DWORD dwCertEncodingType
,
3130 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
3131 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
3137 struct AsnDecodeSequenceItem items
[] = {
3138 { ASN_INTEGER
, offsetof(struct DECODED_RSA_PUB_KEY
, modulus
),
3139 CRYPT_AsnDecodeUnsignedIntegerInternal
, sizeof(CRYPT_INTEGER_BLOB
),
3140 FALSE
, TRUE
, offsetof(struct DECODED_RSA_PUB_KEY
, modulus
.pbData
),
3142 { ASN_INTEGER
, offsetof(struct DECODED_RSA_PUB_KEY
, pubexp
),
3143 CRYPT_AsnDecodeIntInternal
, sizeof(DWORD
), FALSE
, FALSE
, 0, 0 },
3145 struct DECODED_RSA_PUB_KEY
*decodedKey
= NULL
;
3148 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
3149 pbEncoded
, cbEncoded
, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &decodedKey
,
3153 DWORD bytesNeeded
= sizeof(BLOBHEADER
) + sizeof(RSAPUBKEY
) +
3154 decodedKey
->modulus
.cbData
;
3158 *pcbStructInfo
= bytesNeeded
;
3161 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
3162 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
3165 RSAPUBKEY
*rsaPubKey
;
3167 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
3168 pvStructInfo
= *(BYTE
**)pvStructInfo
;
3169 hdr
= (BLOBHEADER
*)pvStructInfo
;
3170 hdr
->bType
= PUBLICKEYBLOB
;
3171 hdr
->bVersion
= CUR_BLOB_VERSION
;
3173 hdr
->aiKeyAlg
= CALG_RSA_KEYX
;
3174 rsaPubKey
= (RSAPUBKEY
*)((BYTE
*)pvStructInfo
+
3175 sizeof(BLOBHEADER
));
3176 rsaPubKey
->magic
= RSA1_MAGIC
;
3177 rsaPubKey
->pubexp
= decodedKey
->pubexp
;
3178 rsaPubKey
->bitlen
= decodedKey
->modulus
.cbData
* 8;
3179 memcpy((BYTE
*)pvStructInfo
+ sizeof(BLOBHEADER
) +
3180 sizeof(RSAPUBKEY
), decodedKey
->modulus
.pbData
,
3181 decodedKey
->modulus
.cbData
);
3183 LocalFree(decodedKey
);
3188 SetLastError(STATUS_ACCESS_VIOLATION
);
3195 static BOOL
CRYPT_AsnDecodeOctetsInternal(const BYTE
*pbEncoded
,
3196 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
3200 DWORD bytesNeeded
, dataLen
;
3202 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
3203 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
3205 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
3207 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
3209 if (dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
)
3210 bytesNeeded
= sizeof(CRYPT_DATA_BLOB
);
3212 bytesNeeded
= dataLen
+ sizeof(CRYPT_DATA_BLOB
);
3214 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
3216 *pcbStructInfo
= bytesNeeded
;
3217 else if (*pcbStructInfo
< bytesNeeded
)
3219 SetLastError(ERROR_MORE_DATA
);
3220 *pcbStructInfo
= bytesNeeded
;
3225 CRYPT_DATA_BLOB
*blob
;
3227 *pcbStructInfo
= bytesNeeded
;
3228 blob
= (CRYPT_DATA_BLOB
*)pvStructInfo
;
3229 blob
->cbData
= dataLen
;
3230 if (dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
)
3231 blob
->pbData
= (BYTE
*)pbEncoded
+ 1 + lenBytes
;
3234 assert(blob
->pbData
);
3236 memcpy(blob
->pbData
, pbEncoded
+ 1 + lenBytes
,
3244 static BOOL WINAPI
CRYPT_AsnDecodeOctets(DWORD dwCertEncodingType
,
3245 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
3246 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
3250 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
3251 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
3259 SetLastError(CRYPT_E_ASN1_CORRUPT
);
3262 else if (pbEncoded
[0] != ASN_OCTETSTRING
)
3264 SetLastError(CRYPT_E_ASN1_BADTAG
);
3267 else if ((ret
= CRYPT_AsnDecodeOctetsInternal(pbEncoded
, cbEncoded
,
3268 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, &bytesNeeded
, NULL
)))
3271 *pcbStructInfo
= bytesNeeded
;
3272 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
3273 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
3275 CRYPT_DATA_BLOB
*blob
;
3277 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
3278 pvStructInfo
= *(BYTE
**)pvStructInfo
;
3279 blob
= (CRYPT_DATA_BLOB
*)pvStructInfo
;
3280 blob
->pbData
= (BYTE
*)pvStructInfo
+ sizeof(CRYPT_DATA_BLOB
);
3281 ret
= CRYPT_AsnDecodeOctetsInternal(pbEncoded
, cbEncoded
,
3282 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
3283 &bytesNeeded
, NULL
);
3289 SetLastError(STATUS_ACCESS_VIOLATION
);
3296 static BOOL
CRYPT_AsnDecodeBitsInternal(const BYTE
*pbEncoded
, DWORD cbEncoded
,
3297 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
3300 DWORD bytesNeeded
, dataLen
;
3301 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
3303 TRACE("(%p, %d, 0x%08x, %p, %d, %p)\n", pbEncoded
, cbEncoded
, dwFlags
,
3304 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
3306 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
3308 if (dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
)
3309 bytesNeeded
= sizeof(CRYPT_BIT_BLOB
);
3311 bytesNeeded
= dataLen
- 1 + sizeof(CRYPT_BIT_BLOB
);
3313 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
3315 *pcbStructInfo
= bytesNeeded
;
3316 else if (*pcbStructInfo
< bytesNeeded
)
3318 *pcbStructInfo
= bytesNeeded
;
3319 SetLastError(ERROR_MORE_DATA
);
3324 CRYPT_BIT_BLOB
*blob
;
3326 *pcbStructInfo
= bytesNeeded
;
3327 blob
= (CRYPT_BIT_BLOB
*)pvStructInfo
;
3328 blob
->cbData
= dataLen
- 1;
3329 blob
->cUnusedBits
= *(pbEncoded
+ 1 + lenBytes
);
3330 if (dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
)
3332 blob
->pbData
= (BYTE
*)pbEncoded
+ 2 + lenBytes
;
3336 assert(blob
->pbData
);
3339 BYTE mask
= 0xff << blob
->cUnusedBits
;
3341 memcpy(blob
->pbData
, pbEncoded
+ 2 + lenBytes
,
3343 blob
->pbData
[blob
->cbData
- 1] &= mask
;
3351 static BOOL WINAPI
CRYPT_AsnDecodeBits(DWORD dwCertEncodingType
,
3352 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
3353 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
3357 TRACE("(%p, %d, 0x%08x, %p, %p, %p)\n", pbEncoded
, cbEncoded
, dwFlags
,
3358 pDecodePara
, pvStructInfo
, pcbStructInfo
);
3366 SetLastError(CRYPT_E_ASN1_CORRUPT
);
3369 else if (pbEncoded
[0] != ASN_BITSTRING
)
3371 SetLastError(CRYPT_E_ASN1_BADTAG
);
3374 else if ((ret
= CRYPT_AsnDecodeBitsInternal(pbEncoded
, cbEncoded
,
3375 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, &bytesNeeded
, NULL
)))
3378 *pcbStructInfo
= bytesNeeded
;
3379 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
3380 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
3382 CRYPT_BIT_BLOB
*blob
;
3384 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
3385 pvStructInfo
= *(BYTE
**)pvStructInfo
;
3386 blob
= (CRYPT_BIT_BLOB
*)pvStructInfo
;
3387 blob
->pbData
= (BYTE
*)pvStructInfo
+ sizeof(CRYPT_BIT_BLOB
);
3388 ret
= CRYPT_AsnDecodeBitsInternal(pbEncoded
, cbEncoded
,
3389 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
3390 &bytesNeeded
, NULL
);
3396 SetLastError(STATUS_ACCESS_VIOLATION
);
3400 TRACE("returning %d (%08x)\n", ret
, GetLastError());
3404 /* Ignores tag. Only allows integers 4 bytes or smaller in size. */
3405 static BOOL
CRYPT_AsnDecodeIntInternal(const BYTE
*pbEncoded
, DWORD cbEncoded
,
3406 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
3409 BYTE buf
[sizeof(CRYPT_INTEGER_BLOB
) + sizeof(int)];
3410 CRYPT_INTEGER_BLOB
*blob
= (CRYPT_INTEGER_BLOB
*)buf
;
3411 DWORD size
= sizeof(buf
);
3413 blob
->pbData
= buf
+ sizeof(CRYPT_INTEGER_BLOB
);
3414 ret
= CRYPT_AsnDecodeIntegerInternal(pbEncoded
, cbEncoded
, 0, buf
,
3419 *pcbStructInfo
= sizeof(int);
3420 else if ((ret
= CRYPT_DecodeCheckSpace(pcbStructInfo
, sizeof(int))))
3424 if (blob
->pbData
[blob
->cbData
- 1] & 0x80)
3426 /* initialize to a negative value to sign-extend */
3431 for (i
= 0; i
< blob
->cbData
; i
++)
3434 val
|= blob
->pbData
[blob
->cbData
- i
- 1];
3436 memcpy(pvStructInfo
, &val
, sizeof(int));
3439 else if (GetLastError() == ERROR_MORE_DATA
)
3440 SetLastError(CRYPT_E_ASN1_LARGE
);
3444 static BOOL WINAPI
CRYPT_AsnDecodeInt(DWORD dwCertEncodingType
,
3445 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
3446 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
3456 SetLastError(CRYPT_E_ASN1_EOD
);
3459 else if (pbEncoded
[0] != ASN_INTEGER
)
3461 SetLastError(CRYPT_E_ASN1_BADTAG
);
3465 ret
= CRYPT_AsnDecodeIntInternal(pbEncoded
, cbEncoded
,
3466 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, &bytesNeeded
, NULL
);
3470 *pcbStructInfo
= bytesNeeded
;
3471 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
3472 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
3474 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
3475 pvStructInfo
= *(BYTE
**)pvStructInfo
;
3476 ret
= CRYPT_AsnDecodeIntInternal(pbEncoded
, cbEncoded
,
3477 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
3478 &bytesNeeded
, NULL
);
3484 SetLastError(STATUS_ACCESS_VIOLATION
);
3491 static BOOL
CRYPT_AsnDecodeIntegerInternal(const BYTE
*pbEncoded
,
3492 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
3496 DWORD bytesNeeded
, dataLen
;
3498 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
3500 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
3502 bytesNeeded
= dataLen
+ sizeof(CRYPT_INTEGER_BLOB
);
3504 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
3506 *pcbStructInfo
= bytesNeeded
;
3507 else if (*pcbStructInfo
< bytesNeeded
)
3509 *pcbStructInfo
= bytesNeeded
;
3510 SetLastError(ERROR_MORE_DATA
);
3515 CRYPT_INTEGER_BLOB
*blob
= (CRYPT_INTEGER_BLOB
*)pvStructInfo
;
3517 *pcbStructInfo
= bytesNeeded
;
3518 blob
->cbData
= dataLen
;
3519 assert(blob
->pbData
);
3524 for (i
= 0; i
< blob
->cbData
; i
++)
3526 blob
->pbData
[i
] = *(pbEncoded
+ 1 + lenBytes
+
3535 static BOOL WINAPI
CRYPT_AsnDecodeInteger(DWORD dwCertEncodingType
,
3536 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
3537 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
3545 if (pbEncoded
[0] != ASN_INTEGER
)
3547 SetLastError(CRYPT_E_ASN1_BADTAG
);
3551 ret
= CRYPT_AsnDecodeIntegerInternal(pbEncoded
, cbEncoded
,
3552 dwFlags
& ~CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &bytesNeeded
, NULL
);
3556 *pcbStructInfo
= bytesNeeded
;
3557 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
3558 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
3560 CRYPT_INTEGER_BLOB
*blob
;
3562 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
3563 pvStructInfo
= *(BYTE
**)pvStructInfo
;
3564 blob
= (CRYPT_INTEGER_BLOB
*)pvStructInfo
;
3565 blob
->pbData
= (BYTE
*)pvStructInfo
+
3566 sizeof(CRYPT_INTEGER_BLOB
);
3567 ret
= CRYPT_AsnDecodeIntegerInternal(pbEncoded
, cbEncoded
,
3568 dwFlags
& ~CRYPT_ENCODE_ALLOC_FLAG
, pvStructInfo
,
3569 &bytesNeeded
, NULL
);
3575 SetLastError(STATUS_ACCESS_VIOLATION
);
3582 static BOOL
CRYPT_AsnDecodeUnsignedIntegerInternal(const BYTE
*pbEncoded
,
3583 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
3588 if (pbEncoded
[0] == ASN_INTEGER
)
3590 DWORD bytesNeeded
, dataLen
;
3592 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
3594 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
3597 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
3598 bytesNeeded
= dataLen
+ sizeof(CRYPT_INTEGER_BLOB
);
3600 *pcbStructInfo
= bytesNeeded
;
3601 else if (*pcbStructInfo
< bytesNeeded
)
3603 *pcbStructInfo
= bytesNeeded
;
3604 SetLastError(ERROR_MORE_DATA
);
3609 CRYPT_INTEGER_BLOB
*blob
= (CRYPT_INTEGER_BLOB
*)pvStructInfo
;
3611 *pcbStructInfo
= bytesNeeded
;
3612 blob
->cbData
= dataLen
;
3613 assert(blob
->pbData
);
3614 /* remove leading zero byte if it exists */
3615 if (blob
->cbData
&& *(pbEncoded
+ 1 + lenBytes
) == 0)
3624 for (i
= 0; i
< blob
->cbData
; i
++)
3626 blob
->pbData
[i
] = *(pbEncoded
+ 1 + lenBytes
+
3635 SetLastError(CRYPT_E_ASN1_BADTAG
);
3641 static BOOL WINAPI
CRYPT_AsnDecodeUnsignedInteger(DWORD dwCertEncodingType
,
3642 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
3643 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
3651 if ((ret
= CRYPT_AsnDecodeUnsignedIntegerInternal(pbEncoded
, cbEncoded
,
3652 dwFlags
& ~CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &bytesNeeded
, NULL
)))
3655 *pcbStructInfo
= bytesNeeded
;
3656 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
3657 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
3659 CRYPT_INTEGER_BLOB
*blob
;
3661 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
3662 pvStructInfo
= *(BYTE
**)pvStructInfo
;
3663 blob
= (CRYPT_INTEGER_BLOB
*)pvStructInfo
;
3664 blob
->pbData
= (BYTE
*)pvStructInfo
+
3665 sizeof(CRYPT_INTEGER_BLOB
);
3666 ret
= CRYPT_AsnDecodeUnsignedIntegerInternal(pbEncoded
,
3667 cbEncoded
, dwFlags
& ~CRYPT_ENCODE_ALLOC_FLAG
, pvStructInfo
,
3668 &bytesNeeded
, NULL
);
3674 SetLastError(STATUS_ACCESS_VIOLATION
);
3681 static BOOL WINAPI
CRYPT_AsnDecodeEnumerated(DWORD dwCertEncodingType
,
3682 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
3683 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
3689 *pcbStructInfo
= sizeof(int);
3694 if (pbEncoded
[0] == ASN_ENUMERATED
)
3696 unsigned int val
= 0, i
;
3700 SetLastError(CRYPT_E_ASN1_EOD
);
3703 else if (pbEncoded
[1] == 0)
3705 SetLastError(CRYPT_E_ASN1_CORRUPT
);
3710 /* A little strange looking, but we have to accept a sign byte:
3711 * 0xffffffff gets encoded as 0a 05 00 ff ff ff ff. Also,
3712 * assuming a small length is okay here, it has to be in short
3715 if (pbEncoded
[1] > sizeof(unsigned int) + 1)
3717 SetLastError(CRYPT_E_ASN1_LARGE
);
3720 for (i
= 0; i
< pbEncoded
[1]; i
++)
3723 val
|= pbEncoded
[2 + i
];
3725 if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
3726 pvStructInfo
, pcbStructInfo
, sizeof(unsigned int))))
3728 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
3729 pvStructInfo
= *(BYTE
**)pvStructInfo
;
3730 memcpy(pvStructInfo
, &val
, sizeof(unsigned int));
3736 SetLastError(CRYPT_E_ASN1_BADTAG
);
3742 SetLastError(STATUS_ACCESS_VIOLATION
);
3749 /* Modifies word, pbEncoded, and len, and magically sets a value ret to FALSE
3752 #define CRYPT_TIME_GET_DIGITS(pbEncoded, len, numDigits, word) \
3757 for (i = 0; (len) > 0 && i < (numDigits); i++, (len)--) \
3759 if (!isdigit(*(pbEncoded))) \
3761 SetLastError(CRYPT_E_ASN1_CORRUPT); \
3767 (word) += *(pbEncoded)++ - '0'; \
3772 static BOOL
CRYPT_AsnDecodeTimeZone(const BYTE
*pbEncoded
, DWORD len
,
3773 SYSTEMTIME
*sysTime
)
3777 if (len
>= 3 && (*pbEncoded
== '+' || *pbEncoded
== '-'))
3779 WORD hours
, minutes
= 0;
3780 BYTE sign
= *pbEncoded
++;
3783 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2, hours
);
3784 if (ret
&& hours
>= 24)
3786 SetLastError(CRYPT_E_ASN1_CORRUPT
);
3791 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2, minutes
);
3792 if (ret
&& minutes
>= 60)
3794 SetLastError(CRYPT_E_ASN1_CORRUPT
);
3802 sysTime
->wHour
+= hours
;
3803 sysTime
->wMinute
+= minutes
;
3807 if (hours
> sysTime
->wHour
)
3810 sysTime
->wHour
= 24 - (hours
- sysTime
->wHour
);
3813 sysTime
->wHour
-= hours
;
3814 if (minutes
> sysTime
->wMinute
)
3817 sysTime
->wMinute
= 60 - (minutes
- sysTime
->wMinute
);
3820 sysTime
->wMinute
-= minutes
;
3827 #define MIN_ENCODED_TIME_LENGTH 10
3829 static BOOL
CRYPT_AsnDecodeUtcTimeInternal(const BYTE
*pbEncoded
,
3830 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
3835 if (pbEncoded
[0] == ASN_UTCTIME
)
3838 SetLastError(CRYPT_E_ASN1_EOD
);
3839 else if (pbEncoded
[1] > 0x7f)
3841 /* long-form date strings really can't be valid */
3842 SetLastError(CRYPT_E_ASN1_CORRUPT
);
3846 SYSTEMTIME sysTime
= { 0 };
3847 BYTE len
= pbEncoded
[1];
3849 if (len
< MIN_ENCODED_TIME_LENGTH
)
3850 SetLastError(CRYPT_E_ASN1_CORRUPT
);
3855 *pcbDecoded
= 2 + len
;
3857 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2, sysTime
.wYear
);
3858 if (sysTime
.wYear
>= 50)
3859 sysTime
.wYear
+= 1900;
3861 sysTime
.wYear
+= 2000;
3862 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2, sysTime
.wMonth
);
3863 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2, sysTime
.wDay
);
3864 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2, sysTime
.wHour
);
3865 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2, sysTime
.wMinute
);
3868 if (len
>= 2 && isdigit(*pbEncoded
) &&
3869 isdigit(*(pbEncoded
+ 1)))
3870 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2,
3872 else if (isdigit(*pbEncoded
))
3873 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 1,
3876 ret
= CRYPT_AsnDecodeTimeZone(pbEncoded
, len
,
3882 *pcbStructInfo
= sizeof(FILETIME
);
3883 else if ((ret
= CRYPT_DecodeCheckSpace(pcbStructInfo
,
3885 ret
= SystemTimeToFileTime(&sysTime
,
3886 (FILETIME
*)pvStructInfo
);
3892 SetLastError(CRYPT_E_ASN1_BADTAG
);
3896 static BOOL WINAPI
CRYPT_AsnDecodeUtcTime(DWORD dwCertEncodingType
,
3897 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
3898 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
3906 ret
= CRYPT_AsnDecodeUtcTimeInternal(pbEncoded
, cbEncoded
,
3907 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, &bytesNeeded
, NULL
);
3911 *pcbStructInfo
= bytesNeeded
;
3912 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
,
3913 pDecodePara
, pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
3915 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
3916 pvStructInfo
= *(BYTE
**)pvStructInfo
;
3917 ret
= CRYPT_AsnDecodeUtcTimeInternal(pbEncoded
, cbEncoded
,
3918 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
3919 &bytesNeeded
, NULL
);
3925 SetLastError(STATUS_ACCESS_VIOLATION
);
3931 static BOOL
CRYPT_AsnDecodeGeneralizedTime(const BYTE
*pbEncoded
,
3932 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
3937 if (pbEncoded
[0] == ASN_GENERALTIME
)
3940 SetLastError(CRYPT_E_ASN1_EOD
);
3941 else if (pbEncoded
[1] > 0x7f)
3943 /* long-form date strings really can't be valid */
3944 SetLastError(CRYPT_E_ASN1_CORRUPT
);
3948 BYTE len
= pbEncoded
[1];
3950 if (len
< MIN_ENCODED_TIME_LENGTH
)
3951 SetLastError(CRYPT_E_ASN1_CORRUPT
);
3954 SYSTEMTIME sysTime
= { 0 };
3958 *pcbDecoded
= 2 + len
;
3960 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 4, sysTime
.wYear
);
3961 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2, sysTime
.wMonth
);
3962 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2, sysTime
.wDay
);
3963 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2, sysTime
.wHour
);
3966 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2,
3969 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, 2,
3971 if (ret
&& len
> 0 && (*pbEncoded
== '.' ||
3978 /* workaround macro weirdness */
3979 digits
= min(len
, 3);
3980 CRYPT_TIME_GET_DIGITS(pbEncoded
, len
, digits
,
3981 sysTime
.wMilliseconds
);
3984 ret
= CRYPT_AsnDecodeTimeZone(pbEncoded
, len
,
3990 *pcbStructInfo
= sizeof(FILETIME
);
3991 else if ((ret
= CRYPT_DecodeCheckSpace(pcbStructInfo
,
3993 ret
= SystemTimeToFileTime(&sysTime
,
3994 (FILETIME
*)pvStructInfo
);
4000 SetLastError(CRYPT_E_ASN1_BADTAG
);
4004 static BOOL
CRYPT_AsnDecodeChoiceOfTimeInternal(const BYTE
*pbEncoded
,
4005 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
4009 InternalDecodeFunc decode
= NULL
;
4011 if (pbEncoded
[0] == ASN_UTCTIME
)
4012 decode
= CRYPT_AsnDecodeUtcTimeInternal
;
4013 else if (pbEncoded
[0] == ASN_GENERALTIME
)
4014 decode
= CRYPT_AsnDecodeGeneralizedTime
;
4016 ret
= decode(pbEncoded
, cbEncoded
, dwFlags
, pvStructInfo
,
4017 pcbStructInfo
, pcbDecoded
);
4020 SetLastError(CRYPT_E_ASN1_BADTAG
);
4026 static BOOL WINAPI
CRYPT_AsnDecodeChoiceOfTime(DWORD dwCertEncodingType
,
4027 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
4028 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
4036 ret
= CRYPT_AsnDecodeChoiceOfTimeInternal(pbEncoded
, cbEncoded
,
4037 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, &bytesNeeded
, NULL
);
4041 *pcbStructInfo
= bytesNeeded
;
4042 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
4043 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
4045 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
4046 pvStructInfo
= *(BYTE
**)pvStructInfo
;
4047 ret
= CRYPT_AsnDecodeChoiceOfTimeInternal(pbEncoded
, cbEncoded
,
4048 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
4049 &bytesNeeded
, NULL
);
4055 SetLastError(STATUS_ACCESS_VIOLATION
);
4062 static BOOL WINAPI
CRYPT_AsnDecodeSequenceOfAny(DWORD dwCertEncodingType
,
4063 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
4064 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
4070 if (pbEncoded
[0] == ASN_SEQUENCEOF
)
4072 DWORD bytesNeeded
, dataLen
, remainingLen
, cValue
;
4074 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
4079 lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
4080 bytesNeeded
= sizeof(CRYPT_SEQUENCE_OF_ANY
);
4082 ptr
= pbEncoded
+ 1 + lenBytes
;
4083 remainingLen
= dataLen
;
4084 while (ret
&& remainingLen
)
4088 ret
= CRYPT_GetLen(ptr
, remainingLen
, &nextLen
);
4091 DWORD nextLenBytes
= GET_LEN_BYTES(ptr
[1]);
4093 remainingLen
-= 1 + nextLenBytes
+ nextLen
;
4094 ptr
+= 1 + nextLenBytes
+ nextLen
;
4095 bytesNeeded
+= sizeof(CRYPT_DER_BLOB
);
4096 if (!(dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
))
4097 bytesNeeded
+= 1 + nextLenBytes
+ nextLen
;
4103 CRYPT_SEQUENCE_OF_ANY
*seq
;
4108 *pcbStructInfo
= bytesNeeded
;
4109 else if ((ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
4110 pvStructInfo
, pcbStructInfo
, bytesNeeded
)))
4112 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
4113 pvStructInfo
= *(BYTE
**)pvStructInfo
;
4114 seq
= (CRYPT_SEQUENCE_OF_ANY
*)pvStructInfo
;
4115 seq
->cValue
= cValue
;
4116 seq
->rgValue
= (CRYPT_DER_BLOB
*)((BYTE
*)seq
+
4118 nextPtr
= (BYTE
*)seq
->rgValue
+
4119 cValue
* sizeof(CRYPT_DER_BLOB
);
4120 ptr
= pbEncoded
+ 1 + lenBytes
;
4121 remainingLen
= dataLen
;
4123 while (ret
&& remainingLen
)
4127 ret
= CRYPT_GetLen(ptr
, remainingLen
, &nextLen
);
4130 DWORD nextLenBytes
= GET_LEN_BYTES(ptr
[1]);
4132 seq
->rgValue
[i
].cbData
= 1 + nextLenBytes
+
4134 if (dwFlags
& CRYPT_DECODE_NOCOPY_FLAG
)
4135 seq
->rgValue
[i
].pbData
= (BYTE
*)ptr
;
4138 seq
->rgValue
[i
].pbData
= nextPtr
;
4139 memcpy(nextPtr
, ptr
, 1 + nextLenBytes
+
4141 nextPtr
+= 1 + nextLenBytes
+ nextLen
;
4143 remainingLen
-= 1 + nextLenBytes
+ nextLen
;
4144 ptr
+= 1 + nextLenBytes
+ nextLen
;
4154 SetLastError(CRYPT_E_ASN1_BADTAG
);
4160 SetLastError(STATUS_ACCESS_VIOLATION
);
4167 static BOOL
CRYPT_AsnDecodeDistPointName(const BYTE
*pbEncoded
,
4168 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
4173 if (pbEncoded
[0] == (ASN_CONTEXT
| ASN_CONSTRUCTOR
| 0))
4175 DWORD bytesNeeded
, dataLen
;
4177 if ((ret
= CRYPT_GetLen(pbEncoded
, cbEncoded
, &dataLen
)))
4179 struct AsnArrayDescriptor arrayDesc
= {
4180 ASN_CONTEXT
| ASN_CONSTRUCTOR
| 0, CRYPT_AsnDecodeAltNameEntry
,
4181 sizeof(CERT_ALT_NAME_ENTRY
), TRUE
,
4182 offsetof(CERT_ALT_NAME_ENTRY
, u
.pwszURL
) };
4183 BYTE lenBytes
= GET_LEN_BYTES(pbEncoded
[1]);
4188 ret
= CRYPT_AsnDecodeArray(&arrayDesc
,
4189 pbEncoded
+ 1 + lenBytes
, cbEncoded
- 1 - lenBytes
,
4190 0, NULL
, NULL
, &nameLen
, NULL
, NULL
);
4191 /* The CERT_ALT_NAME_INFO's size is included by CRYPT_AsnDecodeArray
4192 * as the sizeof(struct GenericArray), so don't include it in the
4193 * total bytes needed.
4195 bytesNeeded
= sizeof(CRL_DIST_POINT_NAME
) + nameLen
-
4196 sizeof(CERT_ALT_NAME_INFO
);
4199 bytesNeeded
= sizeof(CRL_DIST_POINT_NAME
);
4201 *pcbDecoded
= 1 + lenBytes
+ dataLen
;
4203 *pcbStructInfo
= bytesNeeded
;
4204 else if (*pcbStructInfo
< bytesNeeded
)
4206 *pcbStructInfo
= bytesNeeded
;
4207 SetLastError(ERROR_MORE_DATA
);
4212 CRL_DIST_POINT_NAME
*name
= (CRL_DIST_POINT_NAME
*)pvStructInfo
;
4214 *pcbStructInfo
= bytesNeeded
;
4217 name
->dwDistPointNameChoice
= CRL_DIST_POINT_FULL_NAME
;
4218 ret
= CRYPT_AsnDecodeArray(&arrayDesc
,
4219 pbEncoded
+ 1 + lenBytes
, cbEncoded
- 1 - lenBytes
,
4220 0, NULL
, &name
->u
.FullName
, &nameLen
, NULL
,
4221 name
->u
.FullName
.rgAltEntry
);
4224 name
->dwDistPointNameChoice
= CRL_DIST_POINT_NO_NAME
;
4230 SetLastError(CRYPT_E_ASN1_BADTAG
);
4236 static BOOL
CRYPT_AsnDecodeDistPoint(const BYTE
*pbEncoded
, DWORD cbEncoded
,
4237 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
4239 struct AsnDecodeSequenceItem items
[] = {
4240 { ASN_CONTEXT
| ASN_CONSTRUCTOR
| 0, offsetof(CRL_DIST_POINT
,
4241 DistPointName
), CRYPT_AsnDecodeDistPointName
,
4242 sizeof(CRL_DIST_POINT_NAME
), TRUE
, TRUE
, offsetof(CRL_DIST_POINT
,
4243 DistPointName
.u
.FullName
.rgAltEntry
), 0 },
4244 { ASN_CONTEXT
| 1, offsetof(CRL_DIST_POINT
, ReasonFlags
),
4245 CRYPT_AsnDecodeBitsInternal
, sizeof(CRYPT_BIT_BLOB
), TRUE
, TRUE
,
4246 offsetof(CRL_DIST_POINT
, ReasonFlags
.pbData
), 0 },
4247 { ASN_CONTEXT
| ASN_CONSTRUCTOR
| 2, offsetof(CRL_DIST_POINT
, CRLIssuer
),
4248 CRYPT_AsnDecodeAltNameInternal
, sizeof(CERT_ALT_NAME_INFO
), TRUE
, TRUE
,
4249 offsetof(CRL_DIST_POINT
, CRLIssuer
.rgAltEntry
), 0 },
4253 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
4254 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
4259 static BOOL WINAPI
CRYPT_AsnDecodeCRLDistPoints(DWORD dwCertEncodingType
,
4260 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
4261 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
4265 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
4266 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
4270 struct AsnArrayDescriptor arrayDesc
= { ASN_SEQUENCEOF
,
4271 CRYPT_AsnDecodeDistPoint
, sizeof(CRL_DIST_POINT
), TRUE
,
4272 offsetof(CRL_DIST_POINT
, DistPointName
.u
.FullName
.rgAltEntry
) };
4274 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
4275 pDecodePara
, pvStructInfo
, pcbStructInfo
, NULL
, NULL
);
4279 SetLastError(STATUS_ACCESS_VIOLATION
);
4286 static BOOL WINAPI
CRYPT_AsnDecodeEnhancedKeyUsage(DWORD dwCertEncodingType
,
4287 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
4288 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
4292 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
4293 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
4297 struct AsnArrayDescriptor arrayDesc
= { ASN_SEQUENCEOF
,
4298 CRYPT_AsnDecodeOidInternal
, sizeof(LPSTR
), TRUE
, 0 };
4300 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
4301 pDecodePara
, pvStructInfo
, pcbStructInfo
, NULL
, NULL
);
4305 SetLastError(STATUS_ACCESS_VIOLATION
);
4312 static BOOL WINAPI
CRYPT_AsnDecodeIssuingDistPoint(DWORD dwCertEncodingType
,
4313 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
4314 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
4318 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
4319 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
4323 struct AsnDecodeSequenceItem items
[] = {
4324 { ASN_CONTEXT
| ASN_CONSTRUCTOR
| 0, offsetof(CRL_ISSUING_DIST_POINT
,
4325 DistPointName
), CRYPT_AsnDecodeDistPointName
,
4326 sizeof(CRL_DIST_POINT_NAME
), TRUE
, TRUE
,
4327 offsetof(CRL_ISSUING_DIST_POINT
,
4328 DistPointName
.u
.FullName
.rgAltEntry
), 0 },
4329 { ASN_CONTEXT
| 1, offsetof(CRL_ISSUING_DIST_POINT
,
4330 fOnlyContainsUserCerts
), CRYPT_AsnDecodeBool
, sizeof(BOOL
), TRUE
,
4332 { ASN_CONTEXT
| 2, offsetof(CRL_ISSUING_DIST_POINT
,
4333 fOnlyContainsCACerts
), CRYPT_AsnDecodeBool
, sizeof(BOOL
), TRUE
,
4335 { ASN_CONTEXT
| 3, offsetof(CRL_ISSUING_DIST_POINT
,
4336 OnlySomeReasonFlags
), CRYPT_AsnDecodeBitsInternal
,
4337 sizeof(CRYPT_BIT_BLOB
), TRUE
, TRUE
, offsetof(CRL_ISSUING_DIST_POINT
,
4338 OnlySomeReasonFlags
.pbData
), 0 },
4339 { ASN_CONTEXT
| 4, offsetof(CRL_ISSUING_DIST_POINT
,
4340 fIndirectCRL
), CRYPT_AsnDecodeBool
, sizeof(BOOL
), TRUE
, FALSE
, 0 },
4343 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
4344 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
,
4345 pcbStructInfo
, NULL
, NULL
);
4349 SetLastError(STATUS_ACCESS_VIOLATION
);
4356 static BOOL
CRYPT_AsnDecodeMaximum(const BYTE
*pbEncoded
,
4357 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
4362 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
4363 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
4367 SetLastError(CRYPT_E_ASN1_EOD
);
4370 if (pbEncoded
[0] != (ASN_CONTEXT
| 1))
4372 SetLastError(CRYPT_E_ASN1_BADTAG
);
4375 /* The BOOL is implicit: if the integer is present, then it's TRUE */
4376 ret
= CRYPT_AsnDecodeIntInternal(pbEncoded
, cbEncoded
, dwFlags
,
4377 pvStructInfo
? (BYTE
*)pvStructInfo
+ sizeof(BOOL
) : NULL
, pcbStructInfo
,
4379 if (ret
&& pvStructInfo
)
4380 *(BOOL
*)pvStructInfo
= TRUE
;
4381 TRACE("returning %d\n", ret
);
4385 static BOOL
CRYPT_AsnDecodeSubtree(const BYTE
*pbEncoded
,
4386 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
4390 struct AsnDecodeSequenceItem items
[] = {
4391 { 0, offsetof(CERT_GENERAL_SUBTREE
, Base
),
4392 CRYPT_AsnDecodeAltNameEntry
, sizeof(CERT_ALT_NAME_ENTRY
), TRUE
, TRUE
,
4393 offsetof(CERT_ALT_NAME_ENTRY
, u
.pwszURL
), 0 },
4394 { ASN_CONTEXT
| 0, offsetof(CERT_GENERAL_SUBTREE
, dwMinimum
),
4395 CRYPT_AsnDecodeIntInternal
, sizeof(DWORD
), TRUE
, FALSE
, 0, 0 },
4396 { ASN_CONTEXT
| 1, offsetof(CERT_GENERAL_SUBTREE
, fMaximum
),
4397 CRYPT_AsnDecodeMaximum
, sizeof(BOOL
) + sizeof(DWORD
), TRUE
, FALSE
, 0,
4400 CERT_GENERAL_SUBTREE
*subtree
= (CERT_GENERAL_SUBTREE
*)pvStructInfo
;
4402 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
4403 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
4405 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
4406 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
4407 pcbDecoded
, subtree
? (BYTE
*)subtree
->Base
.u
.pwszURL
: NULL
);
4410 TRACE("%d\n", *pcbDecoded
);
4411 if (*pcbDecoded
< cbEncoded
)
4412 TRACE("%02x %02x\n", *(pbEncoded
+ *pcbDecoded
),
4413 *(pbEncoded
+ *pcbDecoded
+ 1));
4415 TRACE("returning %d\n", ret
);
4419 static BOOL
CRYPT_AsnDecodeSubtreeArray(const BYTE
*pbEncoded
,
4420 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
4424 struct AsnArrayDescriptor arrayDesc
= { 0,
4425 CRYPT_AsnDecodeSubtree
, sizeof(CERT_GENERAL_SUBTREE
), TRUE
,
4426 offsetof(CERT_GENERAL_SUBTREE
, Base
.u
.pwszURL
) };
4427 struct GenericArray
*array
= (struct GenericArray
*)pvStructInfo
;
4429 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
4430 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
4432 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
4433 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
4434 array
? array
->rgItems
: NULL
);
4439 static BOOL WINAPI
CRYPT_AsnDecodeNameConstraints(DWORD dwCertEncodingType
,
4440 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
4441 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
4445 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
4446 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
4450 struct AsnDecodeSequenceItem items
[] = {
4451 { ASN_CONTEXT
| ASN_CONSTRUCTOR
| 0,
4452 offsetof(CERT_NAME_CONSTRAINTS_INFO
, cPermittedSubtree
),
4453 CRYPT_AsnDecodeSubtreeArray
, sizeof(struct GenericArray
), TRUE
, TRUE
,
4454 offsetof(CERT_NAME_CONSTRAINTS_INFO
, rgPermittedSubtree
), 0 },
4455 { ASN_CONTEXT
| ASN_CONSTRUCTOR
| 1,
4456 offsetof(CERT_NAME_CONSTRAINTS_INFO
, cExcludedSubtree
),
4457 CRYPT_AsnDecodeSubtreeArray
, sizeof(struct GenericArray
), TRUE
, TRUE
,
4458 offsetof(CERT_NAME_CONSTRAINTS_INFO
, rgExcludedSubtree
), 0 },
4461 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
4462 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
,
4463 pcbStructInfo
, NULL
, NULL
);
4467 SetLastError(STATUS_ACCESS_VIOLATION
);
4473 static BOOL
CRYPT_AsnDecodeIssuerSerialNumber(const BYTE
*pbEncoded
,
4474 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
4478 struct AsnDecodeSequenceItem items
[] = {
4479 { 0, offsetof(CERT_ISSUER_SERIAL_NUMBER
, Issuer
), CRYPT_AsnDecodeDerBlob
,
4480 sizeof(CRYPT_DER_BLOB
), FALSE
, TRUE
, offsetof(CERT_ISSUER_SERIAL_NUMBER
,
4482 { ASN_INTEGER
, offsetof(CERT_ISSUER_SERIAL_NUMBER
, SerialNumber
),
4483 CRYPT_AsnDecodeIntegerInternal
, sizeof(CRYPT_INTEGER_BLOB
), FALSE
,
4484 TRUE
, offsetof(CERT_ISSUER_SERIAL_NUMBER
, SerialNumber
.pbData
), 0 },
4486 CERT_ISSUER_SERIAL_NUMBER
*issuerSerial
=
4487 (CERT_ISSUER_SERIAL_NUMBER
*)pvStructInfo
;
4489 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
4490 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
4492 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
4493 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
4494 pcbDecoded
, issuerSerial
? issuerSerial
->Issuer
.pbData
: NULL
);
4495 if (ret
&& issuerSerial
&& !issuerSerial
->SerialNumber
.cbData
)
4497 SetLastError(CRYPT_E_ASN1_CORRUPT
);
4500 TRACE("returning %d\n", ret
);
4504 static BOOL
CRYPT_AsnDecodePKCSSignerInfoInternal(const BYTE
*pbEncoded
,
4505 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
4508 CMSG_SIGNER_INFO
*info
= (CMSG_SIGNER_INFO
*)pvStructInfo
;
4509 struct AsnDecodeSequenceItem items
[] = {
4510 { ASN_INTEGER
, offsetof(CMSG_SIGNER_INFO
, dwVersion
),
4511 CRYPT_AsnDecodeIntInternal
, sizeof(DWORD
), FALSE
, FALSE
, 0, 0 },
4512 { ASN_SEQUENCEOF
, offsetof(CMSG_SIGNER_INFO
, Issuer
),
4513 CRYPT_AsnDecodeIssuerSerialNumber
, sizeof(CERT_ISSUER_SERIAL_NUMBER
),
4514 FALSE
, TRUE
, offsetof(CMSG_SIGNER_INFO
, Issuer
.pbData
), 0 },
4515 { ASN_SEQUENCEOF
, offsetof(CMSG_SIGNER_INFO
, HashAlgorithm
),
4516 CRYPT_AsnDecodeAlgorithmId
, sizeof(CRYPT_ALGORITHM_IDENTIFIER
),
4517 FALSE
, TRUE
, offsetof(CMSG_SIGNER_INFO
, HashAlgorithm
.pszObjId
), 0 },
4518 { ASN_CONSTRUCTOR
| ASN_CONTEXT
| 0,
4519 offsetof(CMSG_SIGNER_INFO
, AuthAttrs
),
4520 CRYPT_AsnDecodePKCSAttributesInternal
, sizeof(CRYPT_ATTRIBUTES
),
4521 TRUE
, TRUE
, offsetof(CMSG_SIGNER_INFO
, AuthAttrs
.rgAttr
), 0 },
4522 { ASN_SEQUENCEOF
, offsetof(CMSG_SIGNER_INFO
, HashEncryptionAlgorithm
),
4523 CRYPT_AsnDecodeAlgorithmId
, sizeof(CRYPT_ALGORITHM_IDENTIFIER
),
4524 FALSE
, TRUE
, offsetof(CMSG_SIGNER_INFO
,
4525 HashEncryptionAlgorithm
.pszObjId
), 0 },
4526 { ASN_OCTETSTRING
, offsetof(CMSG_SIGNER_INFO
, EncryptedHash
),
4527 CRYPT_AsnDecodeOctetsInternal
, sizeof(CRYPT_DER_BLOB
),
4528 FALSE
, TRUE
, offsetof(CMSG_SIGNER_INFO
, EncryptedHash
.pbData
), 0 },
4529 { ASN_CONSTRUCTOR
| ASN_CONTEXT
| 1,
4530 offsetof(CMSG_SIGNER_INFO
, UnauthAttrs
),
4531 CRYPT_AsnDecodePKCSAttributesInternal
, sizeof(CRYPT_ATTRIBUTES
),
4532 TRUE
, TRUE
, offsetof(CMSG_SIGNER_INFO
, UnauthAttrs
.rgAttr
), 0 },
4536 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
4537 pvStructInfo
, *pcbStructInfo
);
4539 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
4540 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
4541 pcbDecoded
, info
? info
->Issuer
.pbData
: NULL
);
4545 static BOOL WINAPI
CRYPT_AsnDecodePKCSSignerInfo(DWORD dwCertEncodingType
,
4546 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
4547 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
4551 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
4552 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
4556 ret
= CRYPT_AsnDecodePKCSSignerInfoInternal(pbEncoded
, cbEncoded
,
4557 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, pcbStructInfo
, NULL
);
4558 if (ret
&& pvStructInfo
)
4560 ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
, pvStructInfo
,
4561 pcbStructInfo
, *pcbStructInfo
);
4564 CMSG_SIGNER_INFO
*info
;
4566 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
4567 pvStructInfo
= *(BYTE
**)pvStructInfo
;
4568 info
= (CMSG_SIGNER_INFO
*)pvStructInfo
;
4569 info
->Issuer
.pbData
= ((BYTE
*)info
+
4570 sizeof(CMSG_SIGNER_INFO
));
4571 ret
= CRYPT_AsnDecodePKCSSignerInfoInternal(pbEncoded
,
4572 cbEncoded
, dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
4573 pcbStructInfo
, NULL
);
4579 SetLastError(STATUS_ACCESS_VIOLATION
);
4582 TRACE("returning %d\n", ret
);
4586 static BOOL
CRYPT_AsnDecodeCMSSignerId(const BYTE
*pbEncoded
,
4587 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
4590 CERT_ID
*id
= (CERT_ID
*)pvStructInfo
;
4593 if (*pbEncoded
== ASN_SEQUENCEOF
)
4595 ret
= CRYPT_AsnDecodeIssuerSerialNumber(pbEncoded
, cbEncoded
, dwFlags
,
4596 id
? &id
->u
.IssuerSerialNumber
: NULL
, pcbStructInfo
, pcbDecoded
);
4600 id
->dwIdChoice
= CERT_ID_ISSUER_SERIAL_NUMBER
;
4601 if (*pcbStructInfo
> sizeof(CERT_ISSUER_SERIAL_NUMBER
))
4602 *pcbStructInfo
= sizeof(CERT_ID
) + *pcbStructInfo
-
4603 sizeof(CERT_ISSUER_SERIAL_NUMBER
);
4605 *pcbStructInfo
= sizeof(CERT_ID
);
4608 else if (*pbEncoded
== (ASN_CONTEXT
| 0))
4610 ret
= CRYPT_AsnDecodeOctetsInternal(pbEncoded
, cbEncoded
, dwFlags
,
4611 id
? &id
->u
.KeyId
: NULL
, pcbStructInfo
, pcbDecoded
);
4615 id
->dwIdChoice
= CERT_ID_KEY_IDENTIFIER
;
4616 if (*pcbStructInfo
> sizeof(CRYPT_DATA_BLOB
))
4617 *pcbStructInfo
= sizeof(CERT_ID
) + *pcbStructInfo
-
4618 sizeof(CRYPT_DATA_BLOB
);
4620 *pcbStructInfo
= sizeof(CERT_ID
);
4624 SetLastError(CRYPT_E_ASN1_BADTAG
);
4628 static BOOL
CRYPT_AsnDecodeCMSSignerInfoInternal(const BYTE
*pbEncoded
,
4629 DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
,
4632 CMSG_CMS_SIGNER_INFO
*info
= (CMSG_CMS_SIGNER_INFO
*)pvStructInfo
;
4633 struct AsnDecodeSequenceItem items
[] = {
4634 { ASN_INTEGER
, offsetof(CMSG_CMS_SIGNER_INFO
, dwVersion
),
4635 CRYPT_AsnDecodeIntInternal
, sizeof(DWORD
), FALSE
, FALSE
, 0, 0 },
4636 { 0, offsetof(CMSG_CMS_SIGNER_INFO
, SignerId
),
4637 CRYPT_AsnDecodeCMSSignerId
, sizeof(CERT_ID
), FALSE
, TRUE
,
4638 offsetof(CMSG_CMS_SIGNER_INFO
, SignerId
.u
.KeyId
.pbData
), 0 },
4639 { ASN_SEQUENCEOF
, offsetof(CMSG_CMS_SIGNER_INFO
, HashAlgorithm
),
4640 CRYPT_AsnDecodeAlgorithmId
, sizeof(CRYPT_ALGORITHM_IDENTIFIER
),
4641 FALSE
, TRUE
, offsetof(CMSG_CMS_SIGNER_INFO
, HashAlgorithm
.pszObjId
), 0 },
4642 { ASN_CONSTRUCTOR
| ASN_CONTEXT
| 0,
4643 offsetof(CMSG_CMS_SIGNER_INFO
, AuthAttrs
),
4644 CRYPT_AsnDecodePKCSAttributesInternal
, sizeof(CRYPT_ATTRIBUTES
),
4645 TRUE
, TRUE
, offsetof(CMSG_CMS_SIGNER_INFO
, AuthAttrs
.rgAttr
), 0 },
4646 { ASN_SEQUENCEOF
, offsetof(CMSG_CMS_SIGNER_INFO
, HashEncryptionAlgorithm
),
4647 CRYPT_AsnDecodeAlgorithmId
, sizeof(CRYPT_ALGORITHM_IDENTIFIER
),
4648 FALSE
, TRUE
, offsetof(CMSG_CMS_SIGNER_INFO
,
4649 HashEncryptionAlgorithm
.pszObjId
), 0 },
4650 { ASN_OCTETSTRING
, offsetof(CMSG_CMS_SIGNER_INFO
, EncryptedHash
),
4651 CRYPT_AsnDecodeOctetsInternal
, sizeof(CRYPT_DER_BLOB
),
4652 FALSE
, TRUE
, offsetof(CMSG_CMS_SIGNER_INFO
, EncryptedHash
.pbData
), 0 },
4653 { ASN_CONSTRUCTOR
| ASN_CONTEXT
| 1,
4654 offsetof(CMSG_CMS_SIGNER_INFO
, UnauthAttrs
),
4655 CRYPT_AsnDecodePKCSAttributesInternal
, sizeof(CRYPT_ATTRIBUTES
),
4656 TRUE
, TRUE
, offsetof(CMSG_CMS_SIGNER_INFO
, UnauthAttrs
.rgAttr
), 0 },
4660 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
4661 pvStructInfo
, *pcbStructInfo
);
4663 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
4664 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pvStructInfo
, pcbStructInfo
,
4665 pcbDecoded
, info
? info
->SignerId
.u
.KeyId
.pbData
: NULL
);
4669 static BOOL WINAPI
CRYPT_AsnDecodeCMSSignerInfo(DWORD dwCertEncodingType
,
4670 LPCSTR lpszStructType
, const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
4671 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
4675 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
4676 pDecodePara
, pvStructInfo
, *pcbStructInfo
);
4680 ret
= CRYPT_AsnDecodeCMSSignerInfoInternal(pbEncoded
, cbEncoded
,
4681 dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
, pcbStructInfo
, NULL
);
4682 if (ret
&& pvStructInfo
)
4684 ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
, pvStructInfo
,
4685 pcbStructInfo
, *pcbStructInfo
);
4688 CMSG_CMS_SIGNER_INFO
*info
;
4690 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
4691 pvStructInfo
= *(BYTE
**)pvStructInfo
;
4692 info
= (CMSG_CMS_SIGNER_INFO
*)pvStructInfo
;
4693 info
->SignerId
.u
.KeyId
.pbData
= ((BYTE
*)info
+
4694 sizeof(CMSG_CMS_SIGNER_INFO
));
4695 ret
= CRYPT_AsnDecodeCMSSignerInfoInternal(pbEncoded
,
4696 cbEncoded
, dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, pvStructInfo
,
4697 pcbStructInfo
, NULL
);
4703 SetLastError(STATUS_ACCESS_VIOLATION
);
4706 TRACE("returning %d\n", ret
);
4710 static BOOL
CRYPT_DecodeSignerArray(const BYTE
*pbEncoded
, DWORD cbEncoded
,
4711 DWORD dwFlags
, void *pvStructInfo
, DWORD
*pcbStructInfo
, DWORD
*pcbDecoded
)
4714 struct AsnArrayDescriptor arrayDesc
= { ASN_CONSTRUCTOR
| ASN_SETOF
,
4715 CRYPT_AsnDecodeCMSSignerInfoInternal
, sizeof(CMSG_CMS_SIGNER_INFO
), TRUE
,
4716 offsetof(CMSG_CMS_SIGNER_INFO
, SignerId
.u
.KeyId
.pbData
) };
4717 struct GenericArray
*array
= (struct GenericArray
*)pvStructInfo
;
4719 TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded
, cbEncoded
, dwFlags
,
4720 pvStructInfo
, *pcbStructInfo
, pcbDecoded
);
4722 ret
= CRYPT_AsnDecodeArray(&arrayDesc
, pbEncoded
, cbEncoded
, dwFlags
,
4723 NULL
, pvStructInfo
, pcbStructInfo
, pcbDecoded
,
4724 array
? array
->rgItems
: NULL
);
4728 BOOL
CRYPT_AsnDecodeCMSSignedInfo(const BYTE
*pbEncoded
, DWORD cbEncoded
,
4729 DWORD dwFlags
, PCRYPT_DECODE_PARA pDecodePara
,
4730 CRYPT_SIGNED_INFO
*signedInfo
, DWORD
*pcbSignedInfo
)
4733 struct AsnDecodeSequenceItem items
[] = {
4734 { ASN_INTEGER
, offsetof(CRYPT_SIGNED_INFO
, version
),
4735 CRYPT_AsnDecodeIntInternal
, sizeof(DWORD
), FALSE
, FALSE
, 0, 0 },
4736 /* Placeholder for the hash algorithms - redundant with those in the
4737 * signers, so just ignore them.
4739 { ASN_CONSTRUCTOR
| ASN_SETOF
, 0, NULL
, 0, TRUE
, FALSE
, 0, 0 },
4740 { ASN_SEQUENCE
, offsetof(CRYPT_SIGNED_INFO
, content
),
4741 CRYPT_AsnDecodePKCSContentInfoInternal
, sizeof(CRYPT_CONTENT_INFO
),
4742 FALSE
, TRUE
, offsetof(CRYPT_SIGNED_INFO
, content
.pszObjId
), 0 },
4743 { ASN_CONSTRUCTOR
| ASN_CONTEXT
| 0,
4744 offsetof(CRYPT_SIGNED_INFO
, cCertEncoded
),
4745 CRYPT_DecodeDERArray
, sizeof(struct GenericArray
), TRUE
, TRUE
,
4746 offsetof(CRYPT_SIGNED_INFO
, rgCertEncoded
), 0 },
4747 { ASN_CONSTRUCTOR
| ASN_CONTEXT
| 1,
4748 offsetof(CRYPT_SIGNED_INFO
, cCrlEncoded
), CRYPT_DecodeDERArray
,
4749 sizeof(struct GenericArray
), TRUE
, TRUE
,
4750 offsetof(CRYPT_SIGNED_INFO
, rgCrlEncoded
), 0 },
4751 { ASN_CONSTRUCTOR
| ASN_SETOF
, offsetof(CRYPT_SIGNED_INFO
, cSignerInfo
),
4752 CRYPT_DecodeSignerArray
, sizeof(struct GenericArray
), TRUE
, TRUE
,
4753 offsetof(CRYPT_SIGNED_INFO
, rgSignerInfo
), 0 },
4756 TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded
, cbEncoded
, dwFlags
,
4757 pDecodePara
, signedInfo
, *pcbSignedInfo
);
4759 ret
= CRYPT_AsnDecodeSequence(items
, sizeof(items
) / sizeof(items
[0]),
4760 pbEncoded
, cbEncoded
, dwFlags
, pDecodePara
, signedInfo
, pcbSignedInfo
,
4762 TRACE("returning %d\n", ret
);
4766 static CryptDecodeObjectExFunc
CRYPT_GetBuiltinDecoder(DWORD dwCertEncodingType
,
4767 LPCSTR lpszStructType
)
4769 CryptDecodeObjectExFunc decodeFunc
= NULL
;
4771 if ((dwCertEncodingType
& CERT_ENCODING_TYPE_MASK
) != X509_ASN_ENCODING
4772 && (dwCertEncodingType
& CMSG_ENCODING_TYPE_MASK
) != PKCS_7_ASN_ENCODING
)
4774 SetLastError(ERROR_FILE_NOT_FOUND
);
4777 if (!HIWORD(lpszStructType
))
4779 switch (LOWORD(lpszStructType
))
4781 case LOWORD(X509_CERT
):
4782 decodeFunc
= CRYPT_AsnDecodeCertSignedContent
;
4784 case LOWORD(X509_CERT_TO_BE_SIGNED
):
4785 decodeFunc
= CRYPT_AsnDecodeCert
;
4787 case LOWORD(X509_CERT_CRL_TO_BE_SIGNED
):
4788 decodeFunc
= CRYPT_AsnDecodeCRL
;
4790 case LOWORD(X509_EXTENSIONS
):
4791 decodeFunc
= CRYPT_AsnDecodeExtensions
;
4793 case LOWORD(X509_NAME_VALUE
):
4794 decodeFunc
= CRYPT_AsnDecodeNameValue
;
4796 case LOWORD(X509_NAME
):
4797 decodeFunc
= CRYPT_AsnDecodeName
;
4799 case LOWORD(X509_PUBLIC_KEY_INFO
):
4800 decodeFunc
= CRYPT_AsnDecodePubKeyInfo
;
4802 case LOWORD(X509_AUTHORITY_KEY_ID
):
4803 decodeFunc
= CRYPT_AsnDecodeAuthorityKeyId
;
4805 case LOWORD(X509_ALTERNATE_NAME
):
4806 decodeFunc
= CRYPT_AsnDecodeAltName
;
4808 case LOWORD(X509_BASIC_CONSTRAINTS
):
4809 decodeFunc
= CRYPT_AsnDecodeBasicConstraints
;
4811 case LOWORD(X509_BASIC_CONSTRAINTS2
):
4812 decodeFunc
= CRYPT_AsnDecodeBasicConstraints2
;
4814 case LOWORD(RSA_CSP_PUBLICKEYBLOB
):
4815 decodeFunc
= CRYPT_AsnDecodeRsaPubKey
;
4817 case LOWORD(X509_UNICODE_NAME
):
4818 decodeFunc
= CRYPT_AsnDecodeUnicodeName
;
4820 case LOWORD(PKCS_ATTRIBUTE
):
4821 decodeFunc
= CRYPT_AsnDecodePKCSAttribute
;
4823 case LOWORD(X509_UNICODE_NAME_VALUE
):
4824 decodeFunc
= CRYPT_AsnDecodeUnicodeNameValue
;
4826 case LOWORD(X509_OCTET_STRING
):
4827 decodeFunc
= CRYPT_AsnDecodeOctets
;
4829 case LOWORD(X509_BITS
):
4830 case LOWORD(X509_KEY_USAGE
):
4831 decodeFunc
= CRYPT_AsnDecodeBits
;
4833 case LOWORD(X509_INTEGER
):
4834 decodeFunc
= CRYPT_AsnDecodeInt
;
4836 case LOWORD(X509_MULTI_BYTE_INTEGER
):
4837 decodeFunc
= CRYPT_AsnDecodeInteger
;
4839 case LOWORD(X509_MULTI_BYTE_UINT
):
4840 decodeFunc
= CRYPT_AsnDecodeUnsignedInteger
;
4842 case LOWORD(X509_ENUMERATED
):
4843 decodeFunc
= CRYPT_AsnDecodeEnumerated
;
4845 case LOWORD(X509_CHOICE_OF_TIME
):
4846 decodeFunc
= CRYPT_AsnDecodeChoiceOfTime
;
4848 case LOWORD(X509_AUTHORITY_KEY_ID2
):
4849 decodeFunc
= CRYPT_AsnDecodeAuthorityKeyId2
;
4851 case LOWORD(X509_AUTHORITY_INFO_ACCESS
):
4852 decodeFunc
= CRYPT_AsnDecodeAuthorityInfoAccess
;
4854 case LOWORD(PKCS_CONTENT_INFO
):
4855 decodeFunc
= CRYPT_AsnDecodePKCSContentInfo
;
4857 case LOWORD(X509_SEQUENCE_OF_ANY
):
4858 decodeFunc
= CRYPT_AsnDecodeSequenceOfAny
;
4860 case LOWORD(PKCS_UTC_TIME
):
4861 decodeFunc
= CRYPT_AsnDecodeUtcTime
;
4863 case LOWORD(X509_CRL_DIST_POINTS
):
4864 decodeFunc
= CRYPT_AsnDecodeCRLDistPoints
;
4866 case LOWORD(X509_ENHANCED_KEY_USAGE
):
4867 decodeFunc
= CRYPT_AsnDecodeEnhancedKeyUsage
;
4869 case LOWORD(PKCS_CTL
):
4870 decodeFunc
= CRYPT_AsnDecodeCTL
;
4872 case LOWORD(PKCS_SMIME_CAPABILITIES
):
4873 decodeFunc
= CRYPT_AsnDecodeSMIMECapabilities
;
4875 case LOWORD(PKCS_ATTRIBUTES
):
4876 decodeFunc
= CRYPT_AsnDecodePKCSAttributes
;
4878 case LOWORD(X509_ISSUING_DIST_POINT
):
4879 decodeFunc
= CRYPT_AsnDecodeIssuingDistPoint
;
4881 case LOWORD(X509_NAME_CONSTRAINTS
):
4882 decodeFunc
= CRYPT_AsnDecodeNameConstraints
;
4884 case LOWORD(PKCS7_SIGNER_INFO
):
4885 decodeFunc
= CRYPT_AsnDecodePKCSSignerInfo
;
4887 case LOWORD(CMS_SIGNER_INFO
):
4888 decodeFunc
= CRYPT_AsnDecodeCMSSignerInfo
;
4892 else if (!strcmp(lpszStructType
, szOID_CERT_EXTENSIONS
))
4893 decodeFunc
= CRYPT_AsnDecodeExtensions
;
4894 else if (!strcmp(lpszStructType
, szOID_RSA_signingTime
))
4895 decodeFunc
= CRYPT_AsnDecodeUtcTime
;
4896 else if (!strcmp(lpszStructType
, szOID_RSA_SMIMECapabilities
))
4897 decodeFunc
= CRYPT_AsnDecodeSMIMECapabilities
;
4898 else if (!strcmp(lpszStructType
, szOID_AUTHORITY_KEY_IDENTIFIER
))
4899 decodeFunc
= CRYPT_AsnDecodeAuthorityKeyId
;
4900 else if (!strcmp(lpszStructType
, szOID_AUTHORITY_KEY_IDENTIFIER2
))
4901 decodeFunc
= CRYPT_AsnDecodeAuthorityKeyId2
;
4902 else if (!strcmp(lpszStructType
, szOID_CRL_REASON_CODE
))
4903 decodeFunc
= CRYPT_AsnDecodeEnumerated
;
4904 else if (!strcmp(lpszStructType
, szOID_KEY_USAGE
))
4905 decodeFunc
= CRYPT_AsnDecodeBits
;
4906 else if (!strcmp(lpszStructType
, szOID_SUBJECT_KEY_IDENTIFIER
))
4907 decodeFunc
= CRYPT_AsnDecodeOctets
;
4908 else if (!strcmp(lpszStructType
, szOID_BASIC_CONSTRAINTS
))
4909 decodeFunc
= CRYPT_AsnDecodeBasicConstraints
;
4910 else if (!strcmp(lpszStructType
, szOID_BASIC_CONSTRAINTS2
))
4911 decodeFunc
= CRYPT_AsnDecodeBasicConstraints2
;
4912 else if (!strcmp(lpszStructType
, szOID_ISSUER_ALT_NAME
))
4913 decodeFunc
= CRYPT_AsnDecodeAltName
;
4914 else if (!strcmp(lpszStructType
, szOID_ISSUER_ALT_NAME2
))
4915 decodeFunc
= CRYPT_AsnDecodeAltName
;
4916 else if (!strcmp(lpszStructType
, szOID_NEXT_UPDATE_LOCATION
))
4917 decodeFunc
= CRYPT_AsnDecodeAltName
;
4918 else if (!strcmp(lpszStructType
, szOID_SUBJECT_ALT_NAME
))
4919 decodeFunc
= CRYPT_AsnDecodeAltName
;
4920 else if (!strcmp(lpszStructType
, szOID_SUBJECT_ALT_NAME2
))
4921 decodeFunc
= CRYPT_AsnDecodeAltName
;
4922 else if (!strcmp(lpszStructType
, szOID_CRL_DIST_POINTS
))
4923 decodeFunc
= CRYPT_AsnDecodeCRLDistPoints
;
4924 else if (!strcmp(lpszStructType
, szOID_ENHANCED_KEY_USAGE
))
4925 decodeFunc
= CRYPT_AsnDecodeEnhancedKeyUsage
;
4926 else if (!strcmp(lpszStructType
, szOID_ISSUING_DIST_POINT
))
4927 decodeFunc
= CRYPT_AsnDecodeIssuingDistPoint
;
4928 else if (!strcmp(lpszStructType
, szOID_NAME_CONSTRAINTS
))
4929 decodeFunc
= CRYPT_AsnDecodeNameConstraints
;
4930 else if (!strcmp(lpszStructType
, szOID_AUTHORITY_INFO_ACCESS
))
4931 decodeFunc
= CRYPT_AsnDecodeAuthorityInfoAccess
;
4932 else if (!strcmp(lpszStructType
, szOID_CTL
))
4933 decodeFunc
= CRYPT_AsnDecodeCTL
;
4937 static CryptDecodeObjectFunc
CRYPT_LoadDecoderFunc(DWORD dwCertEncodingType
,
4938 LPCSTR lpszStructType
, HCRYPTOIDFUNCADDR
*hFunc
)
4940 static HCRYPTOIDFUNCSET set
= NULL
;
4941 CryptDecodeObjectFunc decodeFunc
= NULL
;
4944 set
= CryptInitOIDFunctionSet(CRYPT_OID_DECODE_OBJECT_FUNC
, 0);
4945 CryptGetOIDFunctionAddress(set
, dwCertEncodingType
, lpszStructType
, 0,
4946 (void **)&decodeFunc
, hFunc
);
4950 static CryptDecodeObjectExFunc
CRYPT_LoadDecoderExFunc(DWORD dwCertEncodingType
,
4951 LPCSTR lpszStructType
, HCRYPTOIDFUNCADDR
*hFunc
)
4953 static HCRYPTOIDFUNCSET set
= NULL
;
4954 CryptDecodeObjectExFunc decodeFunc
= NULL
;
4957 set
= CryptInitOIDFunctionSet(CRYPT_OID_DECODE_OBJECT_EX_FUNC
, 0);
4958 CryptGetOIDFunctionAddress(set
, dwCertEncodingType
, lpszStructType
, 0,
4959 (void **)&decodeFunc
, hFunc
);
4963 BOOL WINAPI
CryptDecodeObject(DWORD dwCertEncodingType
, LPCSTR lpszStructType
,
4964 const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
, void *pvStructInfo
,
4965 DWORD
*pcbStructInfo
)
4968 CryptDecodeObjectFunc pCryptDecodeObject
= NULL
;
4969 CryptDecodeObjectExFunc pCryptDecodeObjectEx
= NULL
;
4970 HCRYPTOIDFUNCADDR hFunc
= NULL
;
4972 TRACE_(crypt
)("(0x%08x, %s, %p, %d, 0x%08x, %p, %p)\n", dwCertEncodingType
,
4973 debugstr_a(lpszStructType
), pbEncoded
, cbEncoded
, dwFlags
,
4974 pvStructInfo
, pcbStructInfo
);
4976 if (!pvStructInfo
&& !pcbStructInfo
)
4978 SetLastError(ERROR_INVALID_PARAMETER
);
4981 if (cbEncoded
> MAX_ENCODED_LEN
)
4983 SetLastError(CRYPT_E_ASN1_LARGE
);
4987 if (!(pCryptDecodeObjectEx
= CRYPT_GetBuiltinDecoder(dwCertEncodingType
,
4990 TRACE_(crypt
)("OID %s not found or unimplemented, looking for DLL\n",
4991 debugstr_a(lpszStructType
));
4992 pCryptDecodeObject
= CRYPT_LoadDecoderFunc(dwCertEncodingType
,
4993 lpszStructType
, &hFunc
);
4994 if (!pCryptDecodeObject
)
4995 pCryptDecodeObjectEx
= CRYPT_LoadDecoderExFunc(dwCertEncodingType
,
4996 lpszStructType
, &hFunc
);
4998 if (pCryptDecodeObject
)
4999 ret
= pCryptDecodeObject(dwCertEncodingType
, lpszStructType
,
5000 pbEncoded
, cbEncoded
, dwFlags
, pvStructInfo
, pcbStructInfo
);
5001 else if (pCryptDecodeObjectEx
)
5002 ret
= pCryptDecodeObjectEx(dwCertEncodingType
, lpszStructType
,
5003 pbEncoded
, cbEncoded
, dwFlags
& ~CRYPT_DECODE_ALLOC_FLAG
, NULL
,
5004 pvStructInfo
, pcbStructInfo
);
5006 CryptFreeOIDFunctionAddress(hFunc
, 0);
5007 TRACE_(crypt
)("returning %d\n", ret
);
5011 BOOL WINAPI
CryptDecodeObjectEx(DWORD dwCertEncodingType
, LPCSTR lpszStructType
,
5012 const BYTE
*pbEncoded
, DWORD cbEncoded
, DWORD dwFlags
,
5013 PCRYPT_DECODE_PARA pDecodePara
, void *pvStructInfo
, DWORD
*pcbStructInfo
)
5016 CryptDecodeObjectExFunc decodeFunc
;
5017 HCRYPTOIDFUNCADDR hFunc
= NULL
;
5019 TRACE_(crypt
)("(0x%08x, %s, %p, %d, 0x%08x, %p, %p, %p)\n",
5020 dwCertEncodingType
, debugstr_a(lpszStructType
), pbEncoded
,
5021 cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
, pcbStructInfo
);
5023 if (!pvStructInfo
&& !pcbStructInfo
)
5025 SetLastError(ERROR_INVALID_PARAMETER
);
5028 if (cbEncoded
> MAX_ENCODED_LEN
)
5030 SetLastError(CRYPT_E_ASN1_LARGE
);
5034 SetLastError(NOERROR
);
5035 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
&& pvStructInfo
)
5036 *(BYTE
**)pvStructInfo
= NULL
;
5037 decodeFunc
= CRYPT_GetBuiltinDecoder(dwCertEncodingType
, lpszStructType
);
5040 TRACE_(crypt
)("OID %s not found or unimplemented, looking for DLL\n",
5041 debugstr_a(lpszStructType
));
5042 decodeFunc
= CRYPT_LoadDecoderExFunc(dwCertEncodingType
, lpszStructType
,
5046 ret
= decodeFunc(dwCertEncodingType
, lpszStructType
, pbEncoded
,
5047 cbEncoded
, dwFlags
, pDecodePara
, pvStructInfo
, pcbStructInfo
);
5050 CryptDecodeObjectFunc pCryptDecodeObject
=
5051 CRYPT_LoadDecoderFunc(dwCertEncodingType
, lpszStructType
, &hFunc
);
5053 /* Try CryptDecodeObject function. Don't call CryptDecodeObject
5054 * directly, as that could cause an infinite loop.
5056 if (pCryptDecodeObject
)
5058 if (dwFlags
& CRYPT_DECODE_ALLOC_FLAG
)
5060 ret
= pCryptDecodeObject(dwCertEncodingType
, lpszStructType
,
5061 pbEncoded
, cbEncoded
, dwFlags
, NULL
, pcbStructInfo
);
5062 if (ret
&& (ret
= CRYPT_DecodeEnsureSpace(dwFlags
, pDecodePara
,
5063 pvStructInfo
, pcbStructInfo
, *pcbStructInfo
)))
5064 ret
= pCryptDecodeObject(dwCertEncodingType
,
5065 lpszStructType
, pbEncoded
, cbEncoded
, dwFlags
,
5066 *(BYTE
**)pvStructInfo
, pcbStructInfo
);
5069 ret
= pCryptDecodeObject(dwCertEncodingType
, lpszStructType
,
5070 pbEncoded
, cbEncoded
, dwFlags
, pvStructInfo
, pcbStructInfo
);
5074 CryptFreeOIDFunctionAddress(hFunc
, 0);
5075 TRACE_(crypt
)("returning %d\n", ret
);