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