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