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