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