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