msxml3: Fix parameter validation for endElement().
[wine] / dlls / wintrust / asn.c
1 /* wintrust asn functions
2  *
3  * Copyright 2007 Juan Lang
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  *
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <assert.h>
27 #define NONAMELESSUNION
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winerror.h"
31 #include "wincrypt.h"
32 #include "wintrust.h"
33 #include "snmp.h"
34 #include "winternl.h"
35 #include "wine/debug.h"
36 #include "wine/exception.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(cryptasn);
39
40 #ifdef WORDS_BIGENDIAN
41
42 #define hton16(x) (x)
43 #define n16toh(x) (x)
44
45 #else
46
47 #define hton16(x) RtlUshortByteSwap(x)
48 #define n16toh(x) RtlUshortByteSwap(x)
49
50 #endif
51
52 #define ASN_BOOL            (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x01)
53 #define ASN_BITSTRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x03)
54 #define ASN_BMPSTRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1e)
55
56 static BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded)
57 {
58     DWORD bytesNeeded, significantBytes = 0;
59
60     if (len <= 0x7f)
61         bytesNeeded = 1;
62     else
63     {
64         DWORD temp;
65
66         for (temp = len, significantBytes = sizeof(temp); !(temp & 0xff000000);
67          temp <<= 8, significantBytes--)
68             ;
69         bytesNeeded = significantBytes + 1;
70     }
71     if (!pbEncoded)
72     {
73         *pcbEncoded = bytesNeeded;
74         return TRUE;
75     }
76     if (*pcbEncoded < bytesNeeded)
77     {
78         SetLastError(ERROR_MORE_DATA);
79         return FALSE;
80     }
81     if (len <= 0x7f)
82         *pbEncoded = (BYTE)len;
83     else
84     {
85         DWORD i;
86
87         *pbEncoded++ = significantBytes | 0x80;
88         for (i = 0; i < significantBytes; i++)
89         {
90             *(pbEncoded + significantBytes - i - 1) = (BYTE)(len & 0xff);
91             len >>= 8;
92         }
93     }
94     *pcbEncoded = bytesNeeded;
95     return TRUE;
96 }
97
98 static BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
99  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
100  DWORD *pcbEncoded)
101 {
102     BOOL ret = TRUE;
103     const CRYPT_DATA_BLOB *blob = pvStructInfo;
104     DWORD bytesNeeded, lenBytes;
105
106     TRACE("(%d, %p), %p, %d\n", blob->cbData, blob->pbData, pbEncoded,
107      *pcbEncoded);
108
109     CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes);
110     bytesNeeded = 1 + lenBytes + blob->cbData;
111     if (!pbEncoded)
112         *pcbEncoded = bytesNeeded;
113     else if (*pcbEncoded < bytesNeeded)
114     {
115         *pcbEncoded = bytesNeeded;
116         SetLastError(ERROR_MORE_DATA);
117         ret = FALSE;
118     }
119     else
120     {
121         *pbEncoded++ = ASN_OCTETSTRING;
122         CRYPT_EncodeLen(blob->cbData, pbEncoded, &lenBytes);
123         pbEncoded += lenBytes;
124         if (blob->cbData)
125             memcpy(pbEncoded, blob->pbData, blob->cbData);
126     }
127     TRACE("returning %d\n", ret);
128     return ret;
129 }
130
131 BOOL WINAPI WVTAsn1SpcLinkEncode(DWORD dwCertEncodingType,
132  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
133  DWORD *pcbEncoded)
134 {
135     BOOL ret = FALSE;
136
137     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
138      debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
139      pcbEncoded);
140
141     __TRY
142     {
143         const SPC_LINK *link = pvStructInfo;
144         DWORD bytesNeeded, lenBytes;
145
146         switch (link->dwLinkChoice)
147         {
148         case SPC_FILE_LINK_CHOICE:
149         {
150             DWORD fileNameLen, fileNameLenBytes;
151             LPWSTR ptr;
152
153             fileNameLen = link->u.pwszFile ?
154              lstrlenW(link->u.pwszFile) * sizeof(WCHAR) : 0;
155             CRYPT_EncodeLen(fileNameLen, NULL, &fileNameLenBytes);
156             CRYPT_EncodeLen(1 + fileNameLenBytes + fileNameLen, NULL,
157              &lenBytes);
158             bytesNeeded = 2 + lenBytes + fileNameLenBytes + fileNameLen;
159             if (!pbEncoded)
160             {
161                 *pcbEncoded = bytesNeeded;
162                 ret = TRUE;
163             }
164             else if (*pcbEncoded < bytesNeeded)
165             {
166                 SetLastError(ERROR_MORE_DATA);
167                 *pcbEncoded = bytesNeeded;
168             }
169             else
170             {
171                 *pcbEncoded = bytesNeeded;
172                 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_CONTEXT | 2;
173                 CRYPT_EncodeLen(1 + fileNameLenBytes + fileNameLen, pbEncoded,
174                  &lenBytes);
175                 pbEncoded += lenBytes;
176                 *pbEncoded++ = ASN_CONTEXT;
177                 CRYPT_EncodeLen(fileNameLen, pbEncoded, &fileNameLenBytes);
178                 pbEncoded += fileNameLenBytes;
179                 for (ptr = link->u.pwszFile; ptr && *ptr; ptr++)
180                 {
181                     *(WCHAR *)pbEncoded = hton16(*ptr);
182                     pbEncoded += sizeof(WCHAR);
183                 }
184                 ret = TRUE;
185             }
186             break;
187         }
188         case SPC_MONIKER_LINK_CHOICE:
189         {
190             DWORD classIdLenBytes, dataLenBytes, dataLen;
191             CRYPT_DATA_BLOB classId = { sizeof(link->u.Moniker.ClassId),
192              (BYTE *)link->u.Moniker.ClassId };
193
194             CRYPT_EncodeLen(classId.cbData, NULL, &classIdLenBytes);
195             CRYPT_EncodeLen(link->u.Moniker.SerializedData.cbData, NULL,
196              &dataLenBytes);
197             dataLen = 2 + classIdLenBytes + classId.cbData +
198              dataLenBytes + link->u.Moniker.SerializedData.cbData;
199             CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
200             bytesNeeded = 1 + dataLen + lenBytes;
201             if (!pbEncoded)
202             {
203                 *pcbEncoded = bytesNeeded;
204                 ret = TRUE;
205             }
206             else if (*pcbEncoded < bytesNeeded)
207             {
208                 SetLastError(ERROR_MORE_DATA);
209                 *pcbEncoded = bytesNeeded;
210             }
211             else
212             {
213                 DWORD size;
214
215                 *pcbEncoded = bytesNeeded;
216                 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_CONTEXT | 1;
217                 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
218                 pbEncoded += lenBytes;
219                 size = 1 + classIdLenBytes + classId.cbData;
220                 CRYPT_AsnEncodeOctets(X509_ASN_ENCODING, NULL, &classId,
221                  pbEncoded, &size);
222                 pbEncoded += size;
223                 size = 1 + dataLenBytes + link->u.Moniker.SerializedData.cbData;
224                 CRYPT_AsnEncodeOctets(X509_ASN_ENCODING, NULL,
225                  &link->u.Moniker.SerializedData, pbEncoded, &size);
226                 pbEncoded += size;
227                 ret = TRUE;
228             }
229             break;
230         }
231         case SPC_URL_LINK_CHOICE:
232         {
233             LPWSTR ptr;
234             DWORD urlLen;
235
236             /* Check for invalid characters in URL */
237             ret = TRUE;
238             urlLen = 0;
239             for (ptr = link->u.pwszUrl; ptr && *ptr && ret; ptr++)
240                 if (*ptr > 0x7f)
241                 {
242                     *pcbEncoded = 0;
243                     SetLastError(CRYPT_E_INVALID_IA5_STRING);
244                     ret = FALSE;
245                 }
246                 else
247                     urlLen++;
248             if (ret)
249             {
250                 CRYPT_EncodeLen(urlLen, NULL, &lenBytes);
251                 bytesNeeded = 1 + lenBytes + urlLen;
252                 if (!pbEncoded)
253                     *pcbEncoded = bytesNeeded;
254                 else if (*pcbEncoded < bytesNeeded)
255                 {
256                     SetLastError(ERROR_MORE_DATA);
257                     *pcbEncoded = bytesNeeded;
258                     ret = FALSE;
259                 }
260                 else
261                 {
262                     *pcbEncoded = bytesNeeded;
263                     *pbEncoded++ = ASN_CONTEXT;
264                     CRYPT_EncodeLen(urlLen, pbEncoded, &lenBytes);
265                     pbEncoded += lenBytes;
266                     for (ptr = link->u.pwszUrl; ptr && *ptr; ptr++)
267                         *pbEncoded++ = (BYTE)*ptr;
268                 }
269             }
270             break;
271         }
272         default:
273             SetLastError(E_INVALIDARG);
274         }
275     }
276     __EXCEPT_PAGE_FAULT
277     {
278         SetLastError(STATUS_ACCESS_VIOLATION);
279     }
280     __ENDTRY
281     TRACE("returning %d\n", ret);
282     return ret;
283 }
284
285 typedef BOOL (WINAPI *CryptEncodeObjectFunc)(DWORD, LPCSTR, const void *,
286  BYTE *, DWORD *);
287
288 struct AsnEncodeSequenceItem
289 {
290     const void           *pvStructInfo;
291     CryptEncodeObjectFunc encodeFunc;
292     DWORD                 size; /* used during encoding, not for your use */
293 };
294
295 static BOOL CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
296  struct AsnEncodeSequenceItem items[], DWORD cItem, BYTE *pbEncoded,
297  DWORD *pcbEncoded)
298 {
299     BOOL ret;
300     DWORD i, dataLen = 0;
301
302     TRACE("%p, %d, %p, %d\n", items, cItem, pbEncoded, *pcbEncoded);
303     for (i = 0, ret = TRUE; ret && i < cItem; i++)
304     {
305         ret = items[i].encodeFunc(dwCertEncodingType, NULL,
306          items[i].pvStructInfo, NULL, &items[i].size);
307         /* Some functions propagate their errors through the size */
308         if (!ret)
309             *pcbEncoded = items[i].size;
310         dataLen += items[i].size;
311     }
312     if (ret)
313     {
314         DWORD lenBytes, bytesNeeded;
315
316         CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
317         bytesNeeded = 1 + lenBytes + dataLen;
318         if (!pbEncoded)
319             *pcbEncoded = bytesNeeded;
320         else if (*pcbEncoded < bytesNeeded)
321         {
322             *pcbEncoded = bytesNeeded;
323             SetLastError(ERROR_MORE_DATA);
324             ret = FALSE;
325         }
326         else
327         {
328             *pcbEncoded = bytesNeeded;
329             *pbEncoded++ = ASN_SEQUENCE;
330             CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
331             pbEncoded += lenBytes;
332             for (i = 0; ret && i < cItem; i++)
333             {
334                 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
335                  items[i].pvStructInfo, pbEncoded, &items[i].size);
336                 /* Some functions propagate their errors through the size */
337                 if (!ret)
338                     *pcbEncoded = items[i].size;
339                 pbEncoded += items[i].size;
340             }
341         }
342     }
343     TRACE("returning %d\n", ret);
344     return ret;
345 }
346
347 static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType,
348  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
349  DWORD *pcbEncoded)
350 {
351     BOOL ret = FALSE;
352
353     __TRY
354     {
355         const CRYPT_BIT_BLOB *blob = pvStructInfo;
356         DWORD bytesNeeded, lenBytes, dataBytes;
357         BYTE unusedBits;
358
359         /* yep, MS allows cUnusedBits to be >= 8 */
360         if (!blob->cUnusedBits)
361         {
362             dataBytes = blob->cbData;
363             unusedBits = 0;
364         }
365         else if (blob->cbData * 8 > blob->cUnusedBits)
366         {
367             dataBytes = (blob->cbData * 8 - blob->cUnusedBits) / 8 + 1;
368             unusedBits = blob->cUnusedBits >= 8 ? blob->cUnusedBits / 8 :
369              blob->cUnusedBits;
370         }
371         else
372         {
373             dataBytes = 0;
374             unusedBits = 0;
375         }
376         CRYPT_EncodeLen(dataBytes + 1, NULL, &lenBytes);
377         bytesNeeded = 1 + lenBytes + dataBytes + 1;
378         if (!pbEncoded)
379         {
380             *pcbEncoded = bytesNeeded;
381             ret = TRUE;
382         }
383         else if (*pcbEncoded < bytesNeeded)
384         {
385             *pcbEncoded = bytesNeeded;
386             SetLastError(ERROR_MORE_DATA);
387         }
388         else
389         {
390             ret = TRUE;
391             *pcbEncoded = bytesNeeded;
392             *pbEncoded++ = ASN_BITSTRING;
393             CRYPT_EncodeLen(dataBytes + 1, pbEncoded, &lenBytes);
394             pbEncoded += lenBytes;
395             *pbEncoded++ = unusedBits;
396             if (dataBytes)
397             {
398                 BYTE mask = 0xff << unusedBits;
399
400                 if (dataBytes > 1)
401                 {
402                     memcpy(pbEncoded, blob->pbData, dataBytes - 1);
403                     pbEncoded += dataBytes - 1;
404                 }
405                 *pbEncoded = *(blob->pbData + dataBytes - 1) & mask;
406             }
407         }
408     }
409     __EXCEPT_PAGE_FAULT
410     {
411         SetLastError(STATUS_ACCESS_VIOLATION);
412     }
413     __ENDTRY
414     return ret;
415 }
416
417 struct AsnConstructedItem
418 {
419     BYTE                  tag;
420     const void           *pvStructInfo;
421     CryptEncodeObjectFunc encodeFunc;
422 };
423
424 static BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType,
425  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
426  DWORD *pcbEncoded)
427 {
428     BOOL ret;
429     const struct AsnConstructedItem *item = pvStructInfo;
430     DWORD len;
431
432     if ((ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
433      item->pvStructInfo, NULL, &len)))
434     {
435         DWORD dataLen, bytesNeeded;
436
437         CRYPT_EncodeLen(len, NULL, &dataLen);
438         bytesNeeded = 1 + dataLen + len;
439         if (!pbEncoded)
440             *pcbEncoded = bytesNeeded;
441         else if (*pcbEncoded < bytesNeeded)
442         {
443             *pcbEncoded = bytesNeeded;
444             SetLastError(ERROR_MORE_DATA);
445             ret = FALSE;
446         }
447         else
448         {
449             *pcbEncoded = bytesNeeded;
450             *pbEncoded++ = ASN_CONTEXT | ASN_CONSTRUCTOR | item->tag;
451             CRYPT_EncodeLen(len, pbEncoded, &dataLen);
452             pbEncoded += dataLen;
453             ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
454              item->pvStructInfo, pbEncoded, &len);
455             if (!ret)
456             {
457                 /* Some functions propagate their errors through the size */
458                 *pcbEncoded = len;
459             }
460         }
461     }
462     else
463     {
464         /* Some functions propagate their errors through the size */
465         *pcbEncoded = len;
466     }
467     return ret;
468 }
469
470
471 BOOL WINAPI WVTAsn1SpcPeImageDataEncode(DWORD dwCertEncodingType,
472  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
473  DWORD *pcbEncoded)
474 {
475     const SPC_PE_IMAGE_DATA *imageData = pvStructInfo;
476     BOOL ret = FALSE;
477
478     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
479      debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
480      pcbEncoded);
481
482     __TRY
483     {
484         struct AsnEncodeSequenceItem items[2] = {
485          { 0 }
486         };
487         struct AsnConstructedItem constructed = { 0, imageData->pFile,
488          WVTAsn1SpcLinkEncode };
489         DWORD cItem = 0;
490
491         if (imageData->Flags.cbData)
492         {
493             items[cItem].pvStructInfo = &imageData->Flags;
494             items[cItem].encodeFunc = CRYPT_AsnEncodeBits;
495             cItem++;
496         }
497         if (imageData->pFile)
498         {
499             items[cItem].pvStructInfo = &constructed;
500             items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
501             cItem++;
502         }
503
504         ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
505          pbEncoded, pcbEncoded);
506     }
507     __EXCEPT_PAGE_FAULT
508     {
509         SetLastError(STATUS_ACCESS_VIOLATION);
510     }
511     __ENDTRY
512     TRACE("returning %d\n", ret);
513     return ret;
514 }
515
516 static BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
517  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
518  DWORD *pcbEncoded)
519 {
520     LPCSTR pszObjId = pvStructInfo;
521     DWORD bytesNeeded = 0, lenBytes;
522     BOOL ret = TRUE;
523     int firstPos = 0;
524     BYTE firstByte = 0;
525
526     TRACE("%s\n", debugstr_a(pszObjId));
527
528     if (pszObjId)
529     {
530         const char *ptr;
531         int val1, val2;
532
533         if (sscanf(pszObjId, "%d.%d%n", &val1, &val2, &firstPos) != 2)
534         {
535             SetLastError(CRYPT_E_ASN1_ERROR);
536             return FALSE;
537         }
538         bytesNeeded++;
539         firstByte = val1 * 40 + val2;
540         ptr = pszObjId + firstPos;
541         if (*ptr == '.')
542         {
543             ptr++;
544             firstPos++;
545         }
546         while (ret && *ptr)
547         {
548             int pos;
549
550             /* note I assume each component is at most 32-bits long in base 2 */
551             if (sscanf(ptr, "%d%n", &val1, &pos) == 1)
552             {
553                 if (val1 >= 0x10000000)
554                     bytesNeeded += 5;
555                 else if (val1 >= 0x200000)
556                     bytesNeeded += 4;
557                 else if (val1 >= 0x4000)
558                     bytesNeeded += 3;
559                 else if (val1 >= 0x80)
560                     bytesNeeded += 2;
561                 else
562                     bytesNeeded += 1;
563                 ptr += pos;
564                 if (*ptr == '.')
565                     ptr++;
566             }
567             else
568             {
569                 SetLastError(CRYPT_E_ASN1_ERROR);
570                 return FALSE;
571             }
572         }
573         CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
574     }
575     else
576         lenBytes = 1;
577     bytesNeeded += 1 + lenBytes;
578     if (pbEncoded)
579     {
580         if (*pcbEncoded < bytesNeeded)
581         {
582             SetLastError(ERROR_MORE_DATA);
583             ret = FALSE;
584         }
585         else
586         {
587             *pbEncoded++ = ASN_OBJECTIDENTIFIER;
588             CRYPT_EncodeLen(bytesNeeded - 1 - lenBytes, pbEncoded, &lenBytes);
589             pbEncoded += lenBytes;
590             if (pszObjId)
591             {
592                 const char *ptr;
593                 int val, pos;
594
595                 *pbEncoded++ = firstByte;
596                 ptr = pszObjId + firstPos;
597                 while (ret && *ptr)
598                 {
599                     sscanf(ptr, "%d%n", &val, &pos);
600                     {
601                         unsigned char outBytes[5];
602                         int numBytes, i;
603
604                         if (val >= 0x10000000)
605                             numBytes = 5;
606                         else if (val >= 0x200000)
607                             numBytes = 4;
608                         else if (val >= 0x4000)
609                             numBytes = 3;
610                         else if (val >= 0x80)
611                             numBytes = 2;
612                         else
613                             numBytes = 1;
614                         for (i = numBytes; i > 0; i--)
615                         {
616                             outBytes[i - 1] = val & 0x7f;
617                             val >>= 7;
618                         }
619                         for (i = 0; i < numBytes - 1; i++)
620                             *pbEncoded++ = outBytes[i] | 0x80;
621                         *pbEncoded++ = outBytes[i];
622                         ptr += pos;
623                         if (*ptr == '.')
624                             ptr++;
625                     }
626                 }
627             }
628         }
629     }
630     *pcbEncoded = bytesNeeded;
631     return ret;
632 }
633
634 static BOOL WINAPI CRYPT_CopyEncodedBlob(DWORD dwCertEncodingType,
635  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
636  DWORD *pcbEncoded)
637 {
638     const CRYPT_DER_BLOB *blob = pvStructInfo;
639     BOOL ret = TRUE;
640
641     if (!pbEncoded)
642         *pcbEncoded = blob->cbData;
643     else if (*pcbEncoded < blob->cbData)
644     {
645         *pcbEncoded = blob->cbData;
646         SetLastError(ERROR_MORE_DATA);
647         ret = FALSE;
648     }
649     else
650     {
651         if (blob->cbData)
652             memcpy(pbEncoded, blob->pbData, blob->cbData);
653         *pcbEncoded = blob->cbData;
654     }
655     return ret;
656 }
657
658 static BOOL WINAPI CRYPT_AsnEncodeAlgorithmIdWithNullParams(
659  DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
660  BYTE *pbEncoded, DWORD *pcbEncoded)
661 {
662     const CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
663     static const BYTE asn1Null[] = { ASN_NULL, 0 };
664     static const CRYPT_DATA_BLOB nullBlob = { sizeof(asn1Null),
665      (LPBYTE)asn1Null };
666     BOOL ret;
667     struct AsnEncodeSequenceItem items[2] = {
668      { algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
669      { NULL,           CRYPT_CopyEncodedBlob, 0 },
670     };
671
672     if (algo->Parameters.cbData)
673         items[1].pvStructInfo = &algo->Parameters;
674     else
675         items[1].pvStructInfo = &nullBlob;
676     ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
677      sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
678     return ret;
679 }
680
681 static BOOL WINAPI CRYPT_AsnEncodeAttributeTypeValue(DWORD dwCertEncodingType,
682  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
683  DWORD *pcbEncoded)
684 {
685     const CRYPT_ATTRIBUTE_TYPE_VALUE *typeValue = pvStructInfo;
686     struct AsnEncodeSequenceItem items[] = {
687      { &typeValue->pszObjId, CRYPT_AsnEncodeOid, 0 },
688      { &typeValue->Value,    CRYPT_CopyEncodedBlob, 0 },
689     };
690
691     return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
692      items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
693 }
694
695 struct SPCDigest
696 {
697     CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm;
698     CRYPT_HASH_BLOB            Digest;
699 };
700
701 static BOOL WINAPI CRYPT_AsnEncodeSPCDigest(DWORD dwCertEncodingType,
702  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
703  DWORD *pcbEncoded)
704 {
705     const struct SPCDigest *digest = pvStructInfo;
706     struct AsnEncodeSequenceItem items[] = {
707      { &digest->DigestAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams, 0 },
708      { &digest->Digest,          CRYPT_CopyEncodedBlob, 0 },
709     };
710
711     return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
712      items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
713 }
714
715 BOOL WINAPI WVTAsn1SpcIndirectDataContentEncode(DWORD dwCertEncodingType,
716  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
717  DWORD *pcbEncoded)
718 {
719     BOOL ret = FALSE;
720
721     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
722      debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
723
724     __TRY
725     {
726         const SPC_INDIRECT_DATA_CONTENT *data = pvStructInfo;
727         struct AsnEncodeSequenceItem items[] = {
728          { &data->Data,            CRYPT_AsnEncodeAttributeTypeValue, 0 },
729          { &data->DigestAlgorithm, CRYPT_AsnEncodeSPCDigest, 0 },
730         };
731
732         ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
733          items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
734     }
735     __EXCEPT_PAGE_FAULT
736     {
737         SetLastError(STATUS_ACCESS_VIOLATION);
738     }
739     __ENDTRY
740     return ret;
741 }
742
743 static BOOL WINAPI CRYPT_AsnEncodeBMPString(DWORD dwCertEncodingType,
744  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
745  DWORD *pcbEncoded)
746 {
747     BOOL ret = TRUE;
748     LPCWSTR str = pvStructInfo;
749     DWORD bytesNeeded, lenBytes, strLen;
750
751     if (str)
752         strLen = lstrlenW(str);
753     else
754         strLen = 0;
755     CRYPT_EncodeLen(strLen * 2, NULL, &lenBytes);
756     bytesNeeded = 1 + lenBytes + strLen * 2;
757     if (!pbEncoded)
758         *pcbEncoded = bytesNeeded;
759     else if (*pcbEncoded < bytesNeeded)
760     {
761         *pcbEncoded = bytesNeeded;
762         SetLastError(ERROR_MORE_DATA);
763         ret = FALSE;
764     }
765     else
766     {
767         DWORD i;
768
769         *pcbEncoded = bytesNeeded;
770         *pbEncoded++ = ASN_BMPSTRING;
771         CRYPT_EncodeLen(strLen * 2, pbEncoded, &lenBytes);
772         pbEncoded += lenBytes;
773         for (i = 0; i < strLen; i++)
774         {
775             *pbEncoded++ = (str[i] & 0xff00) >> 8;
776             *pbEncoded++ = str[i] & 0x00ff;
777         }
778     }
779     return ret;
780 }
781
782 struct AsnEncodeTagSwappedItem
783 {
784     BYTE                  tag;
785     const void           *pvStructInfo;
786     CryptEncodeObjectFunc encodeFunc;
787 };
788
789 /* Sort of a wacky hack, it encodes something using the struct
790  * AsnEncodeTagSwappedItem's encodeFunc, then replaces the tag byte with the tag
791  * given in the struct AsnEncodeTagSwappedItem.
792  */
793 static BOOL WINAPI CRYPT_AsnEncodeSwapTag(DWORD dwCertEncodingType,
794  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
795  DWORD *pcbEncoded)
796 {
797     BOOL ret;
798     const struct AsnEncodeTagSwappedItem *item = pvStructInfo;
799
800     ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
801      item->pvStructInfo, pbEncoded, pcbEncoded);
802     if (ret && pbEncoded)
803         *pbEncoded = item->tag;
804     return ret;
805 }
806
807 BOOL WINAPI WVTAsn1SpcSpOpusInfoEncode(DWORD dwCertEncodingType,
808  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
809  DWORD *pcbEncoded)
810 {
811     BOOL ret = FALSE;
812
813     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
814      debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
815
816     __TRY
817     {
818         const SPC_SP_OPUS_INFO *info = pvStructInfo;
819
820         if (info->pMoreInfo &&
821          info->pMoreInfo->dwLinkChoice != SPC_URL_LINK_CHOICE &&
822          info->pMoreInfo->dwLinkChoice != SPC_MONIKER_LINK_CHOICE &&
823          info->pMoreInfo->dwLinkChoice != SPC_FILE_LINK_CHOICE)
824             SetLastError(E_INVALIDARG);
825         else if (info->pPublisherInfo &&
826          info->pPublisherInfo->dwLinkChoice != SPC_URL_LINK_CHOICE &&
827          info->pPublisherInfo->dwLinkChoice != SPC_MONIKER_LINK_CHOICE &&
828          info->pPublisherInfo->dwLinkChoice != SPC_FILE_LINK_CHOICE)
829             SetLastError(E_INVALIDARG);
830         else
831         {
832             struct AsnEncodeSequenceItem items[3] = { { 0 } };
833             struct AsnConstructedItem constructed[3] = { { 0 } };
834             struct AsnEncodeTagSwappedItem swapped;
835             DWORD cItem = 0, cConstructed = 0;
836
837             if (info->pwszProgramName)
838             {
839                 swapped.tag = ASN_CONTEXT;
840                 swapped.pvStructInfo = info->pwszProgramName;
841                 swapped.encodeFunc = CRYPT_AsnEncodeBMPString;
842                 constructed[cConstructed].tag = 0;
843                 constructed[cConstructed].pvStructInfo = &swapped;
844                 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeSwapTag;
845                 items[cItem].pvStructInfo = &constructed[cConstructed];
846                 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
847                 cConstructed++;
848                 cItem++;
849             }
850             if (info->pMoreInfo)
851             {
852                 constructed[cConstructed].tag = 1;
853                 constructed[cConstructed].pvStructInfo = info->pMoreInfo;
854                 constructed[cConstructed].encodeFunc = WVTAsn1SpcLinkEncode;
855                 items[cItem].pvStructInfo = &constructed[cConstructed];
856                 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
857                 cConstructed++;
858                 cItem++;
859             }
860             if (info->pPublisherInfo)
861             {
862                 constructed[cConstructed].tag = 2;
863                 constructed[cConstructed].pvStructInfo = info->pPublisherInfo;
864                 constructed[cConstructed].encodeFunc = WVTAsn1SpcLinkEncode;
865                 items[cItem].pvStructInfo = &constructed[cConstructed];
866                 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
867                 cConstructed++;
868                 cItem++;
869             }
870             ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
871              items, cItem, pbEncoded, pcbEncoded);
872         }
873     }
874     __EXCEPT_PAGE_FAULT
875     {
876         SetLastError(STATUS_ACCESS_VIOLATION);
877     }
878     __ENDTRY
879     return ret;
880 }
881
882 static BOOL CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType,
883  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
884  DWORD *pcbEncoded)
885 {
886     BOOL ret;
887
888     __TRY
889     {
890         DWORD significantBytes, lenBytes, bytesNeeded;
891         BYTE padByte = 0;
892         BOOL pad = FALSE;
893         const CRYPT_INTEGER_BLOB *blob = pvStructInfo;
894
895         significantBytes = blob->cbData;
896         if (significantBytes)
897         {
898             if (blob->pbData[significantBytes - 1] & 0x80)
899             {
900                 /* negative, lop off leading (little-endian) 0xffs */
901                 for (; significantBytes > 0 &&
902                  blob->pbData[significantBytes - 1] == 0xff; significantBytes--)
903                     ;
904                 if (blob->pbData[significantBytes - 1] < 0x80)
905                 {
906                     padByte = 0xff;
907                     pad = TRUE;
908                 }
909             }
910             else
911             {
912                 /* positive, lop off leading (little-endian) zeroes */
913                 for (; significantBytes > 0 &&
914                  !blob->pbData[significantBytes - 1]; significantBytes--)
915                     ;
916                 if (significantBytes == 0)
917                     significantBytes = 1;
918                 if (blob->pbData[significantBytes - 1] > 0x7f)
919                 {
920                     padByte = 0;
921                     pad = TRUE;
922                 }
923             }
924         }
925         if (pad)
926             CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes);
927         else
928             CRYPT_EncodeLen(significantBytes, NULL, &lenBytes);
929         bytesNeeded = 1 + lenBytes + significantBytes;
930         if (pad)
931             bytesNeeded++;
932         if (!pbEncoded)
933         {
934             *pcbEncoded = bytesNeeded;
935             ret = TRUE;
936         }
937         else if (*pcbEncoded < bytesNeeded)
938         {
939             *pcbEncoded = bytesNeeded;
940             SetLastError(ERROR_MORE_DATA);
941             ret = FALSE;
942         }
943         else
944         {
945             *pcbEncoded = bytesNeeded;
946             *pbEncoded++ = ASN_INTEGER;
947             if (pad)
948             {
949                 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
950                 pbEncoded += lenBytes;
951                 *pbEncoded++ = padByte;
952             }
953             else
954             {
955                 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
956                 pbEncoded += lenBytes;
957             }
958             for (; significantBytes > 0; significantBytes--)
959                 *(pbEncoded++) = blob->pbData[significantBytes - 1];
960             ret = TRUE;
961         }
962     }
963     __EXCEPT_PAGE_FAULT
964     {
965         SetLastError(STATUS_ACCESS_VIOLATION);
966         ret = FALSE;
967     }
968     __ENDTRY
969     return ret;
970 }
971
972 static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType,
973  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
974  DWORD *pcbEncoded)
975 {
976     CRYPT_INTEGER_BLOB blob = { sizeof(INT), (BYTE *)pvStructInfo };
977
978     return CRYPT_AsnEncodeInteger(dwCertEncodingType, X509_MULTI_BYTE_INTEGER,
979      &blob, pbEncoded, pcbEncoded);
980 }
981
982 BOOL WINAPI WVTAsn1CatMemberInfoEncode(DWORD dwCertEncodingType,
983  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
984  DWORD *pcbEncoded)
985 {
986     BOOL ret = FALSE;
987
988     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
989      debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
990
991     __TRY
992     {
993         const CAT_MEMBERINFO *info = pvStructInfo;
994         struct AsnEncodeSequenceItem items[] = {
995          { info->pwszSubjGuid, CRYPT_AsnEncodeBMPString, 0 },
996          { &info->dwCertVersion, CRYPT_AsnEncodeInt, 0 },
997         };
998
999         ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
1000          items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
1001     }
1002     __EXCEPT_PAGE_FAULT
1003     {
1004         SetLastError(STATUS_ACCESS_VIOLATION);
1005     }
1006     __ENDTRY
1007     return ret;
1008 }
1009
1010 BOOL WINAPI WVTAsn1CatNameValueEncode(DWORD dwCertEncodingType,
1011  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
1012  DWORD *pcbEncoded)
1013 {
1014     BOOL ret = FALSE;
1015
1016     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
1017      debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
1018
1019     __TRY
1020     {
1021         const CAT_NAMEVALUE *value = pvStructInfo;
1022         struct AsnEncodeSequenceItem items[] = {
1023          { value->pwszTag,   CRYPT_AsnEncodeBMPString, 0 },
1024          { &value->fdwFlags, CRYPT_AsnEncodeInt, 0 },
1025          { &value->Value,    CRYPT_AsnEncodeOctets, 0 },
1026         };
1027
1028         ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
1029          items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
1030     }
1031     __EXCEPT_PAGE_FAULT
1032     {
1033         SetLastError(STATUS_ACCESS_VIOLATION);
1034     }
1035     __ENDTRY
1036     return ret;
1037 }
1038
1039 static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
1040  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
1041  DWORD *pcbEncoded)
1042 {
1043     BOOL val = *(const BOOL *)pvStructInfo, ret;
1044
1045     TRACE("%d\n", val);
1046
1047     if (!pbEncoded)
1048     {
1049         *pcbEncoded = 3;
1050         ret = TRUE;
1051     }
1052     else if (*pcbEncoded < 3)
1053     {
1054         *pcbEncoded = 3;
1055         SetLastError(ERROR_MORE_DATA);
1056         ret = FALSE;
1057     }
1058     else
1059     {
1060         *pcbEncoded = 3;
1061         *pbEncoded++ = ASN_BOOL;
1062         *pbEncoded++ = 1;
1063         *pbEncoded++ = val ? 0xff : 0;
1064         ret = TRUE;
1065     }
1066     TRACE("returning %d (%08x)\n", ret, GetLastError());
1067     return ret;
1068 }
1069
1070 BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoEncode(DWORD dwCertEncodingType,
1071  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
1072  DWORD *pcbEncoded)
1073 {
1074     BOOL ret = FALSE;
1075
1076     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
1077      debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
1078
1079     __TRY
1080     {
1081         const SPC_FINANCIAL_CRITERIA *criteria = pvStructInfo;
1082         struct AsnEncodeSequenceItem items[] = {
1083          { &criteria->fFinancialInfoAvailable, CRYPT_AsnEncodeBool, 0 },
1084          { &criteria->fMeetsCriteria,          CRYPT_AsnEncodeBool, 0 },
1085         };
1086
1087         ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
1088          items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
1089     }
1090     __EXCEPT_PAGE_FAULT
1091     {
1092         SetLastError(STATUS_ACCESS_VIOLATION);
1093     }
1094     __ENDTRY
1095     return ret;
1096 }
1097
1098 /* Gets the number of length bytes from the given (leading) length byte */
1099 #define GET_LEN_BYTES(b) ((b) <= 0x7f ? 1 : 1 + ((b) & 0x7f))
1100
1101 /* Helper function to get the encoded length of the data starting at pbEncoded,
1102  * where pbEncoded[0] is the tag.  If the data are too short to contain a
1103  * length or if the length is too large for cbEncoded, sets an appropriate
1104  * error code and returns FALSE.
1105  */
1106 static BOOL CRYPT_GetLen(const BYTE *pbEncoded, DWORD cbEncoded, DWORD *len)
1107 {
1108     BOOL ret;
1109
1110     if (cbEncoded <= 1)
1111     {
1112         SetLastError(CRYPT_E_ASN1_CORRUPT);
1113         ret = FALSE;
1114     }
1115     else if (pbEncoded[1] <= 0x7f)
1116     {
1117         if (pbEncoded[1] + 1 > cbEncoded)
1118         {
1119             SetLastError(CRYPT_E_ASN1_EOD);
1120             ret = FALSE;
1121         }
1122         else
1123         {
1124             *len = pbEncoded[1];
1125             ret = TRUE;
1126         }
1127     }
1128     else if (pbEncoded[1] == 0x80)
1129     {
1130         FIXME("unimplemented for indefinite-length encoding\n");
1131         SetLastError(CRYPT_E_ASN1_CORRUPT);
1132         ret = FALSE;
1133     }
1134     else
1135     {
1136         BYTE lenLen = GET_LEN_BYTES(pbEncoded[1]);
1137
1138         if (lenLen > sizeof(DWORD) + 1)
1139         {
1140             SetLastError(CRYPT_E_ASN1_LARGE);
1141             ret = FALSE;
1142         }
1143         else if (lenLen + 2 > cbEncoded)
1144         {
1145             SetLastError(CRYPT_E_ASN1_CORRUPT);
1146             ret = FALSE;
1147         }
1148         else
1149         {
1150             DWORD out = 0;
1151
1152             pbEncoded += 2;
1153             while (--lenLen)
1154             {
1155                 out <<= 8;
1156                 out |= *pbEncoded++;
1157             }
1158             if (out + lenLen + 1 > cbEncoded)
1159             {
1160                 SetLastError(CRYPT_E_ASN1_EOD);
1161                 ret = FALSE;
1162             }
1163             else
1164             {
1165                 *len = out;
1166                 ret = TRUE;
1167             }
1168         }
1169     }
1170     return ret;
1171 }
1172
1173 static BOOL WINAPI CRYPT_AsnDecodeOctets(DWORD dwCertEncodingType,
1174  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1175  void *pvStructInfo, DWORD *pcbStructInfo)
1176 {
1177     BOOL ret;
1178     DWORD bytesNeeded, dataLen;
1179
1180     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1181      pvStructInfo, *pcbStructInfo);
1182
1183     if (!cbEncoded)
1184     {
1185         SetLastError(CRYPT_E_ASN1_CORRUPT);
1186         ret = FALSE;
1187     }
1188     else if (pbEncoded[0] != ASN_OCTETSTRING)
1189     {
1190         SetLastError(CRYPT_E_ASN1_BADTAG);
1191         ret = FALSE;
1192     }
1193     else if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1194     {
1195         if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1196             bytesNeeded = sizeof(CRYPT_DATA_BLOB);
1197         else
1198             bytesNeeded = dataLen + sizeof(CRYPT_DATA_BLOB);
1199         if (!pvStructInfo)
1200             *pcbStructInfo = bytesNeeded;
1201         else if (*pcbStructInfo < bytesNeeded)
1202         {
1203             SetLastError(ERROR_MORE_DATA);
1204             *pcbStructInfo = bytesNeeded;
1205             ret = FALSE;
1206         }
1207         else
1208         {
1209             CRYPT_DATA_BLOB *blob;
1210             BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1211
1212             blob = pvStructInfo;
1213             blob->cbData = dataLen;
1214             if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1215                 blob->pbData = (BYTE *)pbEncoded + 1 + lenBytes;
1216             else
1217             {
1218                 assert(blob->pbData);
1219                 if (blob->cbData)
1220                     memcpy(blob->pbData, pbEncoded + 1 + lenBytes,
1221                      blob->cbData);
1222             }
1223         }
1224     }
1225     return ret;
1226 }
1227
1228 static BOOL CRYPT_AsnDecodeSPCLinkInternal(DWORD dwCertEncodingType,
1229  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1230  void *pvStructInfo, DWORD *pcbStructInfo)
1231 {
1232     BOOL ret = FALSE;
1233     DWORD bytesNeeded = sizeof(SPC_LINK), dataLen;
1234
1235     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1236      pvStructInfo, *pcbStructInfo);
1237
1238     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1239     {
1240         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1241         DWORD realDataLen;
1242
1243         switch (pbEncoded[0])
1244         {
1245         case ASN_CONTEXT:
1246             bytesNeeded += (dataLen + 1) * sizeof(WCHAR);
1247             if (!pvStructInfo)
1248                 *pcbStructInfo = bytesNeeded;
1249             else if (*pcbStructInfo < bytesNeeded)
1250             {
1251                 *pcbStructInfo = bytesNeeded;
1252                 SetLastError(ERROR_MORE_DATA);
1253                 ret = FALSE;
1254             }
1255             else
1256             {
1257                 PSPC_LINK link = pvStructInfo;
1258                 DWORD i;
1259
1260                 link->dwLinkChoice = SPC_URL_LINK_CHOICE;
1261                 for (i = 0; i < dataLen; i++)
1262                     link->u.pwszUrl[i] =
1263                      *(pbEncoded + 1 + lenBytes + i);
1264                 link->u.pwszUrl[i] = '\0';
1265                 TRACE("returning url %s\n", debugstr_w(link->u.pwszUrl));
1266             }
1267             break;
1268         case ASN_CONSTRUCTOR | ASN_CONTEXT | 1:
1269         {
1270             CRYPT_DATA_BLOB classId;
1271             DWORD size = sizeof(classId);
1272
1273             if ((ret = CRYPT_AsnDecodeOctets(dwCertEncodingType, NULL,
1274              pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
1275              CRYPT_DECODE_NOCOPY_FLAG, &classId, &size)))
1276             {
1277                 if (classId.cbData != sizeof(SPC_UUID))
1278                 {
1279                     SetLastError(CRYPT_E_BAD_ENCODE);
1280                     ret = FALSE;
1281                 }
1282                 else
1283                 {
1284                     CRYPT_DATA_BLOB data;
1285
1286                     /* The tag length for the classId must be 1 since the
1287                      * length is correct.
1288                      */
1289                     size = sizeof(data);
1290                     if ((ret = CRYPT_AsnDecodeOctets(dwCertEncodingType, NULL,
1291                      pbEncoded + 3 + lenBytes + classId.cbData,
1292                      cbEncoded - 3 - lenBytes - classId.cbData,
1293                      CRYPT_DECODE_NOCOPY_FLAG, &data, &size)))
1294                     {
1295                         bytesNeeded += data.cbData;
1296                         if (!pvStructInfo)
1297                             *pcbStructInfo = bytesNeeded;
1298                         else if (*pcbStructInfo < bytesNeeded)
1299                         {
1300                             *pcbStructInfo = bytesNeeded;
1301                             SetLastError(ERROR_MORE_DATA);
1302                             ret = FALSE;
1303                         }
1304                         else
1305                         {
1306                             PSPC_LINK link = pvStructInfo;
1307
1308                             link->dwLinkChoice = SPC_MONIKER_LINK_CHOICE;
1309                             /* pwszFile pointer was set by caller, copy it
1310                              * before overwriting it
1311                              */
1312                             link->u.Moniker.SerializedData.pbData =
1313                              (BYTE *)link->u.pwszFile;
1314                             memcpy(link->u.Moniker.ClassId, classId.pbData,
1315                              classId.cbData);
1316                             memcpy(link->u.Moniker.SerializedData.pbData,
1317                              data.pbData, data.cbData);
1318                             link->u.Moniker.SerializedData.cbData = data.cbData;
1319                         }
1320                     }
1321                 }
1322             }
1323             break;
1324         }
1325         case ASN_CONSTRUCTOR | ASN_CONTEXT | 2:
1326             if (dataLen && pbEncoded[1 + lenBytes] != ASN_CONTEXT)
1327                 SetLastError(CRYPT_E_ASN1_BADTAG);
1328             else if ((ret = CRYPT_GetLen(pbEncoded + 1 + lenBytes, dataLen,
1329              &realDataLen)))
1330             {
1331                 BYTE realLenBytes = GET_LEN_BYTES(pbEncoded[2 + lenBytes]);
1332
1333                 bytesNeeded += realDataLen + sizeof(WCHAR);
1334                 if (!pvStructInfo)
1335                     *pcbStructInfo = bytesNeeded;
1336                 else if (*pcbStructInfo < bytesNeeded)
1337                 {
1338                     *pcbStructInfo = bytesNeeded;
1339                     SetLastError(ERROR_MORE_DATA);
1340                     ret = FALSE;
1341                 }
1342                 else
1343                 {
1344                     PSPC_LINK link = pvStructInfo;
1345                     DWORD i;
1346                     const BYTE *ptr = pbEncoded + 2 + lenBytes + realLenBytes;
1347
1348                     link->dwLinkChoice = SPC_FILE_LINK_CHOICE;
1349                     for (i = 0; i < dataLen / sizeof(WCHAR); i++)
1350                         link->u.pwszFile[i] =
1351                          hton16(*(const WORD *)(ptr + i * sizeof(WCHAR)));
1352                     link->u.pwszFile[realDataLen / sizeof(WCHAR)] = '\0';
1353                     TRACE("returning file %s\n", debugstr_w(link->u.pwszFile));
1354                 }
1355             }
1356             else
1357             {
1358                 bytesNeeded += sizeof(WCHAR);
1359                 if (!pvStructInfo)
1360                     *pcbStructInfo = bytesNeeded;
1361                 else if (*pcbStructInfo < bytesNeeded)
1362                 {
1363                     *pcbStructInfo = bytesNeeded;
1364                     SetLastError(ERROR_MORE_DATA);
1365                     ret = FALSE;
1366                 }
1367                 else
1368                 {
1369                     PSPC_LINK link = pvStructInfo;
1370
1371                     link->dwLinkChoice = SPC_FILE_LINK_CHOICE;
1372                     link->u.pwszFile[0] = '\0';
1373                     ret = TRUE;
1374                 }
1375             }
1376             break;
1377         default:
1378             SetLastError(CRYPT_E_ASN1_BADTAG);
1379         }
1380     }
1381     TRACE("returning %d\n", ret);
1382     return ret;
1383 }
1384
1385 BOOL WINAPI WVTAsn1SpcLinkDecode(DWORD dwCertEncodingType,
1386  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1387  void *pvStructInfo, DWORD *pcbStructInfo)
1388 {
1389     BOOL ret = FALSE;
1390
1391     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1392      pvStructInfo, *pcbStructInfo);
1393
1394     __TRY
1395     {
1396         DWORD bytesNeeded;
1397
1398         ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
1399          lpszStructType, pbEncoded, cbEncoded, dwFlags, NULL, &bytesNeeded);
1400         if (ret)
1401         {
1402             if (!pvStructInfo)
1403                 *pcbStructInfo = bytesNeeded;
1404             else if (*pcbStructInfo < bytesNeeded)
1405             {
1406                 *pcbStructInfo = bytesNeeded;
1407                 SetLastError(ERROR_MORE_DATA);
1408                 ret = FALSE;
1409             }
1410             else
1411             {
1412                 SPC_LINK *link = pvStructInfo;
1413
1414                 link->u.pwszFile =
1415                  (LPWSTR)((BYTE *)pvStructInfo + sizeof(SPC_LINK));
1416                 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
1417                  lpszStructType, pbEncoded, cbEncoded, dwFlags, pvStructInfo,
1418                  pcbStructInfo);
1419             }
1420         }
1421     }
1422     __EXCEPT_PAGE_FAULT
1423     {
1424         SetLastError(STATUS_ACCESS_VIOLATION);
1425     }
1426     __ENDTRY
1427     TRACE("returning %d\n", ret);
1428     return ret;
1429 }
1430
1431 typedef BOOL (WINAPI *CryptDecodeObjectFunc)(DWORD, LPCSTR, const BYTE *,
1432  DWORD, DWORD, void *, DWORD *);
1433
1434 /* tag:
1435  *     The expected tag of the item.  If tag is 0, decodeFunc is called
1436  *     regardless of the tag value seen.
1437  * offset:
1438  *     A sequence is decoded into a struct.  The offset member is the
1439  *     offset of this item within that struct.
1440  * decodeFunc:
1441  *     The decoder function to use.  If this is NULL, then the member isn't
1442  *     decoded, but minSize space is reserved for it.
1443  * minSize:
1444  *     The minimum amount of space occupied after decoding.  You must set this.
1445  * optional:
1446  *     If true, and the tag doesn't match the expected tag for this item,
1447  *     or the decodeFunc fails with CRYPT_E_ASN1_BADTAG, then minSize space is
1448  *     filled with 0 for this member.
1449  * hasPointer, pointerOffset:
1450  *     If the item has dynamic data, set hasPointer to TRUE, pointerOffset to
1451  *     the offset within the struct of the data pointer (or to the
1452  *     first data pointer, if more than one exist).
1453  * size:
1454  *     Used by CRYPT_AsnDecodeSequence, not for your use.
1455  */
1456 struct AsnDecodeSequenceItem
1457 {
1458     BYTE                  tag;
1459     DWORD                 offset;
1460     CryptDecodeObjectFunc decodeFunc;
1461     DWORD                 minSize;
1462     BOOL                  optional;
1463     BOOL                  hasPointer;
1464     DWORD                 pointerOffset;
1465     DWORD                 size;
1466 };
1467
1468 /* Align up to a DWORD_PTR boundary
1469  */
1470 #define ALIGN_DWORD_PTR(x) (((x) + sizeof(DWORD_PTR) - 1) & ~(sizeof(DWORD_PTR) - 1))
1471
1472 #define FINALMEMBERSIZE(s, member) (sizeof(s) - offsetof(s, member))
1473 #define MEMBERSIZE(s, member, nextmember) \
1474     (offsetof(s, nextmember) - offsetof(s, member))
1475
1476
1477 /* Decodes the items in a sequence, where the items are described in items,
1478  * the encoded data are in pbEncoded with length cbEncoded.  Decodes into
1479  * pvStructInfo.  nextData is a pointer to the memory location at which the
1480  * first decoded item with a dynamic pointer should point.
1481  * Upon decoding, *cbDecoded is the total number of bytes decoded.
1482  */
1483 static BOOL CRYPT_AsnDecodeSequenceItems(DWORD dwCertEncodingType,
1484  struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded,
1485  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, BYTE *nextData,
1486  DWORD *cbDecoded)
1487 {
1488     BOOL ret;
1489     DWORD i, decoded = 0;
1490     const BYTE *ptr = pbEncoded;
1491
1492     TRACE("%p, %d, %p, %d, %08x, %p, %p, %p\n", items, cItem, pbEncoded,
1493      cbEncoded, dwFlags, pvStructInfo, nextData, cbDecoded);
1494
1495     for (i = 0, ret = TRUE; ret && i < cItem; i++)
1496     {
1497         if (cbEncoded - (ptr - pbEncoded) != 0)
1498         {
1499             DWORD nextItemLen;
1500
1501             if ((ret = CRYPT_GetLen(ptr, cbEncoded - (ptr - pbEncoded),
1502              &nextItemLen)))
1503             {
1504                 BYTE nextItemLenBytes = GET_LEN_BYTES(ptr[1]);
1505
1506                 if (ptr[0] == items[i].tag || !items[i].tag)
1507                 {
1508                     if (nextData && pvStructInfo && items[i].hasPointer)
1509                     {
1510                         TRACE("Setting next pointer to %p\n",
1511                          nextData);
1512                         *(BYTE **)((BYTE *)pvStructInfo +
1513                          items[i].pointerOffset) = nextData;
1514                     }
1515                     if (items[i].decodeFunc)
1516                     {
1517                         if (pvStructInfo)
1518                             TRACE("decoding item %d\n", i);
1519                         else
1520                             TRACE("sizing item %d\n", i);
1521                         ret = items[i].decodeFunc(dwCertEncodingType,
1522                          NULL, ptr, 1 + nextItemLenBytes + nextItemLen,
1523                          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
1524                          pvStructInfo ?  (BYTE *)pvStructInfo + items[i].offset
1525                          : NULL, &items[i].size);
1526                         if (ret)
1527                         {
1528                             if (items[i].size < items[i].minSize)
1529                                 items[i].size = items[i].minSize;
1530                             else if (items[i].size > items[i].minSize)
1531                             {
1532                                 /* Account for alignment padding */
1533                                 items[i].size = ALIGN_DWORD_PTR(items[i].size);
1534                             }
1535                             TRACE("item %d size: %d\n", i, items[i].size);
1536                             if (nextData && items[i].hasPointer &&
1537                              items[i].size > items[i].minSize)
1538                                 nextData += items[i].size - items[i].minSize;
1539                             ptr += 1 + nextItemLenBytes + nextItemLen;
1540                             decoded += 1 + nextItemLenBytes + nextItemLen;
1541                             TRACE("item %d: decoded %d bytes\n", i,
1542                              1 + nextItemLenBytes + nextItemLen);
1543                         }
1544                         else if (items[i].optional &&
1545                          GetLastError() == CRYPT_E_ASN1_BADTAG)
1546                         {
1547                             TRACE("skipping optional item %d\n", i);
1548                             items[i].size = items[i].minSize;
1549                             SetLastError(NOERROR);
1550                             ret = TRUE;
1551                         }
1552                         else
1553                             TRACE("item %d failed: %08x\n", i,
1554                              GetLastError());
1555                     }
1556                     else
1557                     {
1558                         TRACE("item %d: decoded %d bytes\n", i,
1559                          1 + nextItemLenBytes + nextItemLen);
1560                         ptr += 1 + nextItemLenBytes + nextItemLen;
1561                         decoded += 1 + nextItemLenBytes + nextItemLen;
1562                         items[i].size = items[i].minSize;
1563                     }
1564                 }
1565                 else if (items[i].optional)
1566                 {
1567                     TRACE("skipping optional item %d\n", i);
1568                     items[i].size = items[i].minSize;
1569                 }
1570                 else
1571                 {
1572                     TRACE("item %d: tag %02x doesn't match expected %02x\n",
1573                      i, ptr[0], items[i].tag);
1574                     SetLastError(CRYPT_E_ASN1_BADTAG);
1575                     ret = FALSE;
1576                 }
1577             }
1578         }
1579         else if (items[i].optional)
1580         {
1581             TRACE("missing optional item %d, skipping\n", i);
1582             items[i].size = items[i].minSize;
1583         }
1584         else
1585         {
1586             TRACE("not enough bytes for item %d, failing\n", i);
1587             SetLastError(CRYPT_E_ASN1_CORRUPT);
1588             ret = FALSE;
1589         }
1590     }
1591     if (ret)
1592         *cbDecoded = decoded;
1593     TRACE("returning %d\n", ret);
1594     return ret;
1595 }
1596
1597 /* This decodes an arbitrary sequence into a contiguous block of memory
1598  * (basically, a struct.)  Each element being decoded is described by a struct
1599  * AsnDecodeSequenceItem, see above.
1600  * startingPointer is an optional pointer to the first place where dynamic
1601  * data will be stored.  If you know the starting offset, you may pass it
1602  * here.  Otherwise, pass NULL, and one will be inferred from the items.
1603  */
1604 static BOOL CRYPT_AsnDecodeSequence(DWORD dwCertEncodingType,
1605  struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded,
1606  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1607  void *startingPointer)
1608 {
1609     BOOL ret;
1610
1611     TRACE("%p, %d, %p, %d, %08x, %p, %d, %p\n", items, cItem, pbEncoded,
1612      cbEncoded, dwFlags, pvStructInfo, *pcbStructInfo, startingPointer);
1613
1614     if (pbEncoded[0] == ASN_SEQUENCE)
1615     {
1616         DWORD dataLen;
1617
1618         if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1619         {
1620             DWORD lenBytes = GET_LEN_BYTES(pbEncoded[1]), cbDecoded;
1621             const BYTE *ptr = pbEncoded + 1 + lenBytes;
1622
1623             cbEncoded -= 1 + lenBytes;
1624             if (cbEncoded < dataLen)
1625             {
1626                 TRACE("dataLen %d exceeds cbEncoded %d, failing\n", dataLen,
1627                  cbEncoded);
1628                 SetLastError(CRYPT_E_ASN1_CORRUPT);
1629                 ret = FALSE;
1630             }
1631             else
1632                 ret = CRYPT_AsnDecodeSequenceItems(dwFlags, items, cItem, ptr,
1633                  cbEncoded, dwFlags, NULL, NULL, &cbDecoded);
1634             if (ret && cbDecoded != dataLen)
1635             {
1636                 TRACE("expected %d decoded, got %d, failing\n", dataLen,
1637                  cbDecoded);
1638                 SetLastError(CRYPT_E_ASN1_CORRUPT);
1639                 ret = FALSE;
1640             }
1641             if (ret)
1642             {
1643                 DWORD i, bytesNeeded = 0, structSize = 0;
1644
1645                 for (i = 0; i < cItem; i++)
1646                 {
1647                     bytesNeeded += items[i].size;
1648                     structSize += items[i].minSize;
1649                 }
1650                 if (!pvStructInfo)
1651                     *pcbStructInfo = bytesNeeded;
1652                 else if (*pcbStructInfo < bytesNeeded)
1653                 {
1654                     SetLastError(ERROR_MORE_DATA);
1655                     *pcbStructInfo = bytesNeeded;
1656                     ret = FALSE;
1657                 }
1658                 else
1659                 {
1660                     BYTE *nextData;
1661
1662                     *pcbStructInfo = bytesNeeded;
1663                     if (startingPointer)
1664                         nextData = startingPointer;
1665                     else
1666                         nextData = (BYTE *)pvStructInfo + structSize;
1667                     memset(pvStructInfo, 0, structSize);
1668                     ret = CRYPT_AsnDecodeSequenceItems(dwFlags, items, cItem,
1669                      ptr, cbEncoded, dwFlags, pvStructInfo, nextData,
1670                      &cbDecoded);
1671                 }
1672             }
1673         }
1674     }
1675     else
1676     {
1677         SetLastError(CRYPT_E_ASN1_BADTAG);
1678         ret = FALSE;
1679     }
1680     TRACE("returning %d (%08x)\n", ret, GetLastError());
1681     return ret;
1682 }
1683
1684 static BOOL WINAPI CRYPT_AsnDecodeBitsInternal(DWORD dwCertEncodingType,
1685  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1686  void *pvStructInfo, DWORD *pcbStructInfo)
1687 {
1688     BOOL ret;
1689
1690     TRACE("(%p, %d, 0x%08x, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
1691      pvStructInfo, *pcbStructInfo);
1692
1693     if (pbEncoded[0] == ASN_BITSTRING)
1694     {
1695         DWORD bytesNeeded, dataLen;
1696
1697         if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1698         {
1699             if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1700                 bytesNeeded = sizeof(CRYPT_BIT_BLOB);
1701             else
1702                 bytesNeeded = dataLen - 1 + sizeof(CRYPT_BIT_BLOB);
1703             if (!pvStructInfo)
1704                 *pcbStructInfo = bytesNeeded;
1705             else if (*pcbStructInfo < bytesNeeded)
1706             {
1707                 *pcbStructInfo = bytesNeeded;
1708                 SetLastError(ERROR_MORE_DATA);
1709                 ret = FALSE;
1710             }
1711             else
1712             {
1713                 CRYPT_BIT_BLOB *blob;
1714
1715                 blob = pvStructInfo;
1716                 blob->cbData = dataLen - 1;
1717                 blob->cUnusedBits = *(pbEncoded + 1 +
1718                  GET_LEN_BYTES(pbEncoded[1]));
1719                 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1720                 {
1721                     blob->pbData = (BYTE *)pbEncoded + 2 +
1722                      GET_LEN_BYTES(pbEncoded[1]);
1723                 }
1724                 else
1725                 {
1726                     assert(blob->pbData);
1727                     if (blob->cbData)
1728                     {
1729                         BYTE mask = 0xff << blob->cUnusedBits;
1730
1731                         memcpy(blob->pbData, pbEncoded + 2 +
1732                          GET_LEN_BYTES(pbEncoded[1]), blob->cbData);
1733                         blob->pbData[blob->cbData - 1] &= mask;
1734                     }
1735                 }
1736             }
1737         }
1738     }
1739     else
1740     {
1741         SetLastError(CRYPT_E_ASN1_BADTAG);
1742         ret = FALSE;
1743     }
1744     TRACE("returning %d (%08x)\n", ret, GetLastError());
1745     return ret;
1746 }
1747
1748 static BOOL WINAPI CRYPT_AsnDecodeSPCLinkPointer(DWORD dwCertEncodingType,
1749  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1750  void *pvStructInfo, DWORD *pcbStructInfo)
1751 {
1752     BOOL ret = FALSE;
1753     DWORD dataLen;
1754
1755     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1756     {
1757         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1758         DWORD size;
1759         SPC_LINK **pLink = pvStructInfo;
1760
1761         ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType, lpszStructType,
1762          pbEncoded + 1 + lenBytes, dataLen, dwFlags, NULL, &size);
1763         if (ret)
1764         {
1765             if (!pvStructInfo)
1766                 *pcbStructInfo = size + sizeof(PSPC_LINK);
1767             else if (*pcbStructInfo < size + sizeof(PSPC_LINK))
1768             {
1769                 *pcbStructInfo = size + sizeof(PSPC_LINK);
1770                 SetLastError(ERROR_MORE_DATA);
1771                 ret = FALSE;
1772             }
1773             else
1774             {
1775                 *pcbStructInfo = size + sizeof(PSPC_LINK);
1776                 /* Set imageData's pointer if necessary */
1777                 if (size > sizeof(SPC_LINK))
1778                 {
1779                     (*pLink)->u.pwszUrl =
1780                      (LPWSTR)((BYTE *)*pLink + sizeof(SPC_LINK));
1781                 }
1782                 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
1783                  lpszStructType, pbEncoded + 1 + lenBytes, dataLen, dwFlags,
1784                  *pLink, pcbStructInfo);
1785             }
1786         }
1787     }
1788     return ret;
1789 }
1790
1791 BOOL WINAPI WVTAsn1SpcPeImageDataDecode(DWORD dwCertEncodingType,
1792  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1793  void *pvStructInfo, DWORD *pcbStructInfo)
1794 {
1795     BOOL ret = FALSE;
1796
1797     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1798      pvStructInfo, *pcbStructInfo);
1799
1800     __TRY
1801     {
1802         struct AsnDecodeSequenceItem items[] = {
1803          { ASN_BITSTRING, offsetof(SPC_PE_IMAGE_DATA, Flags),
1804            CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
1805            offsetof(SPC_PE_IMAGE_DATA, Flags.pbData), 0 },
1806          { ASN_CONSTRUCTOR | ASN_CONTEXT, offsetof(SPC_PE_IMAGE_DATA, pFile),
1807            CRYPT_AsnDecodeSPCLinkPointer, sizeof(PSPC_LINK), TRUE, TRUE,
1808            offsetof(SPC_PE_IMAGE_DATA, pFile), 0 },
1809         };
1810
1811         ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
1812          sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
1813          pvStructInfo, pcbStructInfo, NULL);
1814     }
1815     __EXCEPT_PAGE_FAULT
1816     {
1817         SetLastError(STATUS_ACCESS_VIOLATION);
1818     }
1819     __ENDTRY
1820     TRACE("returning %d\n", ret);
1821     return ret;
1822 }
1823
1824 static BOOL WINAPI CRYPT_AsnDecodeOidIgnoreTag(DWORD dwCertEncodingType,
1825  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1826  void *pvStructInfo, DWORD *pcbStructInfo)
1827 {
1828     BOOL ret = TRUE;
1829     DWORD dataLen;
1830
1831     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1832      pvStructInfo, *pcbStructInfo);
1833
1834     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1835     {
1836         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1837         DWORD bytesNeeded = sizeof(LPSTR);
1838
1839         if (dataLen)
1840         {
1841             /* The largest possible string for the first two components
1842              * is 2.175 (= 2 * 40 + 175 = 255), so this is big enough.
1843              */
1844             char firstTwo[6];
1845             const BYTE *ptr;
1846
1847             snprintf(firstTwo, sizeof(firstTwo), "%d.%d",
1848              pbEncoded[1 + lenBytes] / 40,
1849              pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] / 40)
1850              * 40);
1851             bytesNeeded += strlen(firstTwo) + 1;
1852             for (ptr = pbEncoded + 2 + lenBytes; ret &&
1853              ptr - pbEncoded - 1 - lenBytes < dataLen; )
1854             {
1855                 /* large enough for ".4000000" */
1856                 char str[9];
1857                 int val = 0;
1858
1859                 while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1860                  (*ptr & 0x80))
1861                 {
1862                     val <<= 7;
1863                     val |= *ptr & 0x7f;
1864                     ptr++;
1865                 }
1866                 if (ptr - pbEncoded - 1 - lenBytes >= dataLen ||
1867                  (*ptr & 0x80))
1868                 {
1869                     SetLastError(CRYPT_E_ASN1_CORRUPT);
1870                     ret = FALSE;
1871                 }
1872                 else
1873                 {
1874                     val <<= 7;
1875                     val |= *ptr++;
1876                     snprintf(str, sizeof(str), ".%d", val);
1877                     bytesNeeded += strlen(str);
1878                 }
1879             }
1880         }
1881         if (!pvStructInfo)
1882             *pcbStructInfo = bytesNeeded;
1883         else if (*pcbStructInfo < bytesNeeded)
1884         {
1885             *pcbStructInfo = bytesNeeded;
1886             SetLastError(ERROR_MORE_DATA);
1887             ret = FALSE;
1888         }
1889         else
1890         {
1891             if (dataLen)
1892             {
1893                 const BYTE *ptr;
1894                 LPSTR pszObjId = *(LPSTR *)pvStructInfo;
1895
1896                 *pszObjId = 0;
1897                 sprintf(pszObjId, "%d.%d", pbEncoded[1 + lenBytes] / 40,
1898                  pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] /
1899                  40) * 40);
1900                 pszObjId += strlen(pszObjId);
1901                 for (ptr = pbEncoded + 2 + lenBytes; ret &&
1902                  ptr - pbEncoded - 1 - lenBytes < dataLen; )
1903                 {
1904                     int val = 0;
1905
1906                     while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1907                      (*ptr & 0x80))
1908                     {
1909                         val <<= 7;
1910                         val |= *ptr & 0x7f;
1911                         ptr++;
1912                     }
1913                     val <<= 7;
1914                     val |= *ptr++;
1915                     sprintf(pszObjId, ".%d", val);
1916                     pszObjId += strlen(pszObjId);
1917                 }
1918             }
1919             else
1920                 *(LPSTR *)pvStructInfo = NULL;
1921             *pcbStructInfo = bytesNeeded;
1922         }
1923     }
1924     return ret;
1925 }
1926
1927 static BOOL WINAPI CRYPT_AsnDecodeOid(DWORD dwCertEncodingType,
1928  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1929  void *pvStructInfo, DWORD *pcbStructInfo)
1930 {
1931     BOOL ret = FALSE;
1932
1933     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1934      pvStructInfo, *pcbStructInfo);
1935
1936     if (!cbEncoded)
1937         SetLastError(CRYPT_E_ASN1_CORRUPT);
1938     else if (pbEncoded[0] == ASN_OBJECTIDENTIFIER)
1939         ret = CRYPT_AsnDecodeOidIgnoreTag(dwCertEncodingType, lpszStructType,
1940          pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo);
1941     else
1942         SetLastError(CRYPT_E_ASN1_BADTAG);
1943     return ret;
1944 }
1945
1946 static BOOL WINAPI CRYPT_AsnDecodeCopyBytes(DWORD dwCertEncodingType,
1947  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1948  void *pvStructInfo, DWORD *pcbStructInfo)
1949 {
1950     BOOL ret = TRUE;
1951     DWORD bytesNeeded = sizeof(CRYPT_OBJID_BLOB);
1952
1953     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1954      pvStructInfo, *pcbStructInfo);
1955
1956     if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1957         bytesNeeded += cbEncoded;
1958     if (!pvStructInfo)
1959         *pcbStructInfo = bytesNeeded;
1960     else if (*pcbStructInfo < bytesNeeded)
1961     {
1962         SetLastError(ERROR_MORE_DATA);
1963         *pcbStructInfo = bytesNeeded;
1964         ret = FALSE;
1965     }
1966     else
1967     {
1968         PCRYPT_OBJID_BLOB blob = pvStructInfo;
1969
1970         *pcbStructInfo = bytesNeeded;
1971         blob->cbData = cbEncoded;
1972         if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1973             blob->pbData = (LPBYTE)pbEncoded;
1974         else
1975         {
1976             assert(blob->pbData);
1977             memcpy(blob->pbData, pbEncoded, blob->cbData);
1978         }
1979     }
1980     return ret;
1981 }
1982
1983 static BOOL WINAPI CRYPT_AsnDecodeAttributeTypeValue(DWORD dwCertEncodingType,
1984  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1985  void *pvStructInfo, DWORD *pcbStructInfo)
1986 {
1987     CRYPT_ATTRIBUTE_TYPE_VALUE *typeValue = pvStructInfo;
1988     struct AsnDecodeSequenceItem items[] = {
1989      { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, pszObjId),
1990        CRYPT_AsnDecodeOid, sizeof(LPSTR), FALSE, TRUE,
1991        offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, pszObjId), 0 },
1992      { 0, offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, Value),
1993        CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_DATA_BLOB), TRUE, TRUE,
1994        offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, Value.pbData), 0 },
1995     };
1996
1997     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1998      pvStructInfo, *pcbStructInfo);
1999
2000     return CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2001      sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2002      pvStructInfo, pcbStructInfo,
2003      typeValue ? typeValue->pszObjId : NULL);
2004 }
2005
2006 static BOOL WINAPI CRYPT_AsnDecodeAlgorithmId(DWORD dwCertEncodingType,
2007  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2008  void *pvStructInfo, DWORD *pcbStructInfo)
2009 {
2010     CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
2011     BOOL ret = TRUE;
2012     struct AsnDecodeSequenceItem items[] = {
2013      { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId),
2014        CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2015        offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId), 0 },
2016      { 0, offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters),
2017        CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
2018        offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters.pbData), 0 },
2019     };
2020
2021     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2022      pvStructInfo, *pcbStructInfo);
2023
2024     ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2025      sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2026      pvStructInfo, pcbStructInfo, algo ? algo->pszObjId : NULL);
2027     if (ret && pvStructInfo)
2028     {
2029         TRACE("pszObjId is %p (%s)\n", algo->pszObjId,
2030          debugstr_a(algo->pszObjId));
2031     }
2032     return ret;
2033 }
2034
2035 static BOOL WINAPI CRYPT_AsnDecodeSPCDigest(DWORD dwCertEncodingType,
2036  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2037  void *pvStructInfo, DWORD *pcbStructInfo)
2038 {
2039     struct SPCDigest *digest = pvStructInfo;
2040     struct AsnDecodeSequenceItem items[] = {
2041      { ASN_SEQUENCEOF, offsetof(struct SPCDigest, DigestAlgorithm),
2042        CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
2043        FALSE, TRUE,
2044        offsetof(struct SPCDigest, DigestAlgorithm.pszObjId), 0 },
2045      { ASN_OCTETSTRING, offsetof(struct SPCDigest, Digest),
2046        CRYPT_AsnDecodeOctets, sizeof(CRYPT_DER_BLOB),
2047        FALSE, TRUE, offsetof(struct SPCDigest, Digest.pbData), 0 },
2048     };
2049
2050     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2051      pvStructInfo, *pcbStructInfo);
2052
2053     return CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2054      sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2055      pvStructInfo, pcbStructInfo,
2056      digest ? digest->DigestAlgorithm.pszObjId : NULL);
2057 }
2058
2059 BOOL WINAPI WVTAsn1SpcIndirectDataContentDecode(DWORD dwCertEncodingType,
2060  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2061  void *pvStructInfo, DWORD *pcbStructInfo)
2062 {
2063     BOOL ret = FALSE;
2064
2065     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2066      pvStructInfo, *pcbStructInfo);
2067
2068     __TRY
2069     {
2070         struct AsnDecodeSequenceItem items[] = {
2071          { ASN_SEQUENCEOF, offsetof(SPC_INDIRECT_DATA_CONTENT, Data),
2072            CRYPT_AsnDecodeAttributeTypeValue,
2073            sizeof(CRYPT_ATTRIBUTE_TYPE_VALUE), FALSE, TRUE,
2074            offsetof(SPC_INDIRECT_DATA_CONTENT, Data.pszObjId), 0 },
2075          { ASN_SEQUENCEOF, offsetof(SPC_INDIRECT_DATA_CONTENT, DigestAlgorithm),
2076            CRYPT_AsnDecodeSPCDigest, sizeof(struct SPCDigest),
2077            FALSE, TRUE,
2078            offsetof(SPC_INDIRECT_DATA_CONTENT, DigestAlgorithm.pszObjId), 0 },
2079         };
2080
2081         ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2082          sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2083          pvStructInfo, pcbStructInfo, NULL);
2084     }
2085     __EXCEPT_PAGE_FAULT
2086     {
2087         SetLastError(STATUS_ACCESS_VIOLATION);
2088     }
2089     __ENDTRY
2090     TRACE("returning %d\n", ret);
2091     return ret;
2092 }
2093
2094 static BOOL WINAPI CRYPT_AsnDecodeBMPString(DWORD dwCertEncodingType,
2095  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2096  void *pvStructInfo, DWORD *pcbStructInfo)
2097 {
2098     BOOL ret;
2099     DWORD bytesNeeded, dataLen;
2100
2101     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2102     {
2103         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2104
2105         bytesNeeded = dataLen + 2 + sizeof(LPWSTR);
2106         if (!pvStructInfo)
2107             *pcbStructInfo = bytesNeeded;
2108         else if (*pcbStructInfo < bytesNeeded)
2109         {
2110             *pcbStructInfo = bytesNeeded;
2111             SetLastError(ERROR_MORE_DATA);
2112             ret = FALSE;
2113         }
2114         else
2115         {
2116             LPWSTR str;
2117             DWORD i;
2118
2119             *pcbStructInfo = bytesNeeded;
2120             assert(pvStructInfo);
2121             str = *(LPWSTR *)pvStructInfo;
2122             for (i = 0; i < dataLen / 2; i++)
2123                 str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
2124                  pbEncoded[1 + lenBytes + 2 * i + 1];
2125             /* Decoded string is always NULL-terminated */
2126             str[i] = '\0';
2127         }
2128     }
2129     return ret;
2130 }
2131
2132 static BOOL WINAPI CRYPT_AsnDecodeProgramName(DWORD dwCertEncodingType,
2133  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2134  void *pvStructInfo, DWORD *pcbStructInfo)
2135 {
2136     BOOL ret = FALSE;
2137     DWORD dataLen;
2138
2139     TRACE("(%p, %d, %08x, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
2140      pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
2141
2142     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2143     {
2144         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2145
2146         ret = CRYPT_AsnDecodeBMPString(dwCertEncodingType, lpszStructType,
2147          pbEncoded + 1 + lenBytes, dataLen, dwFlags, pvStructInfo,
2148          pcbStructInfo);
2149     }
2150     return ret;
2151 }
2152
2153 BOOL WINAPI WVTAsn1SpcSpOpusInfoDecode(DWORD dwCertEncodingType,
2154  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2155  void *pvStructInfo, DWORD *pcbStructInfo)
2156 {
2157     BOOL ret = FALSE;
2158
2159     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2160      pvStructInfo, *pcbStructInfo);
2161
2162     __TRY
2163     {
2164         struct AsnDecodeSequenceItem items[] = {
2165          { ASN_CONSTRUCTOR | ASN_CONTEXT,
2166            offsetof(SPC_SP_OPUS_INFO, pwszProgramName),
2167            CRYPT_AsnDecodeProgramName, sizeof(LPCWSTR), TRUE, TRUE,
2168            offsetof(SPC_SP_OPUS_INFO, pwszProgramName), 0 },
2169          { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
2170            offsetof(SPC_SP_OPUS_INFO, pMoreInfo),
2171            CRYPT_AsnDecodeSPCLinkPointer, sizeof(PSPC_LINK), TRUE, TRUE,
2172            offsetof(SPC_SP_OPUS_INFO, pMoreInfo), 0 },
2173          { ASN_CONSTRUCTOR | ASN_CONTEXT | 2,
2174            offsetof(SPC_SP_OPUS_INFO, pPublisherInfo),
2175            CRYPT_AsnDecodeSPCLinkPointer, sizeof(PSPC_LINK), TRUE, TRUE,
2176            offsetof(SPC_SP_OPUS_INFO, pPublisherInfo), 0 },
2177         };
2178
2179         ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2180          sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2181          pvStructInfo, pcbStructInfo, NULL);
2182     }
2183     __EXCEPT_PAGE_FAULT
2184     {
2185         SetLastError(STATUS_ACCESS_VIOLATION);
2186     }
2187     __ENDTRY
2188     TRACE("returning %d\n", ret);
2189     return ret;
2190 }
2191
2192 /* Ignores tag.  Only allows integers 4 bytes or smaller in size. */
2193 static BOOL WINAPI CRYPT_AsnDecodeInt(DWORD dwCertEncodingType,
2194  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2195  void *pvStructInfo, DWORD *pcbStructInfo)
2196 {
2197     BOOL ret;
2198     DWORD dataLen;
2199
2200     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2201     {
2202         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2203
2204         if (dataLen > sizeof(int))
2205         {
2206             SetLastError(CRYPT_E_ASN1_LARGE);
2207             ret = FALSE;
2208         }
2209         else if (!pvStructInfo)
2210             *pcbStructInfo = sizeof(int);
2211         else if (*pcbStructInfo < sizeof(int))
2212         {
2213             *pcbStructInfo = sizeof(int);
2214             SetLastError(ERROR_MORE_DATA);
2215             ret = FALSE;
2216         }
2217         else
2218         {
2219             int val;
2220             DWORD i;
2221
2222             *pcbStructInfo = sizeof(int);
2223             if (dataLen && pbEncoded[1 + lenBytes] & 0x80)
2224             {
2225                 /* initialize to a negative value to sign-extend */
2226                 val = -1;
2227             }
2228             else
2229                 val = 0;
2230             for (i = 0; i < dataLen; i++)
2231             {
2232                 val <<= 8;
2233                 val |= pbEncoded[1 + lenBytes + i];
2234             }
2235             memcpy(pvStructInfo, &val, sizeof(int));
2236         }
2237     }
2238     return ret;
2239 }
2240
2241 BOOL WINAPI WVTAsn1CatMemberInfoDecode(DWORD dwCertEncodingType,
2242  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2243  void *pvStructInfo, DWORD *pcbStructInfo)
2244 {
2245     BOOL ret = FALSE;
2246
2247     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2248      pvStructInfo, *pcbStructInfo);
2249
2250     __TRY
2251     {
2252         struct AsnDecodeSequenceItem items[] = {
2253          { ASN_BMPSTRING, offsetof(CAT_MEMBERINFO, pwszSubjGuid),
2254            CRYPT_AsnDecodeBMPString, sizeof(LPWSTR), FALSE, TRUE,
2255            offsetof(CAT_MEMBERINFO, pwszSubjGuid), 0 },
2256          { ASN_INTEGER, offsetof(CAT_MEMBERINFO, dwCertVersion),
2257            CRYPT_AsnDecodeInt, FINALMEMBERSIZE(CAT_MEMBERINFO, dwCertVersion),
2258            FALSE, FALSE, 0, 0 },
2259         };
2260
2261         ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2262          sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2263          pvStructInfo, pcbStructInfo, NULL);
2264     }
2265     __EXCEPT_PAGE_FAULT
2266     {
2267         SetLastError(STATUS_ACCESS_VIOLATION);
2268     }
2269     __ENDTRY
2270     TRACE("returning %d\n", ret);
2271     return ret;
2272 }
2273
2274 BOOL WINAPI WVTAsn1CatNameValueDecode(DWORD dwCertEncodingType,
2275  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2276  void *pvStructInfo, DWORD *pcbStructInfo)
2277 {
2278     BOOL ret = FALSE;
2279
2280     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2281      pvStructInfo, *pcbStructInfo);
2282
2283     __TRY
2284     {
2285         struct AsnDecodeSequenceItem items[] = {
2286          { ASN_BMPSTRING, offsetof(CAT_NAMEVALUE, pwszTag),
2287            CRYPT_AsnDecodeBMPString, sizeof(LPWSTR), FALSE, TRUE,
2288            offsetof(CAT_NAMEVALUE, pwszTag), 0 },
2289          { ASN_INTEGER, offsetof(CAT_NAMEVALUE, fdwFlags),
2290            CRYPT_AsnDecodeInt, MEMBERSIZE(CAT_NAMEVALUE, fdwFlags, Value),
2291            FALSE, FALSE, 0, 0 },
2292          { ASN_OCTETSTRING, offsetof(CAT_NAMEVALUE, Value),
2293            CRYPT_AsnDecodeOctets, sizeof(CRYPT_DER_BLOB), FALSE, TRUE,
2294            offsetof(CAT_NAMEVALUE, Value.pbData), 0 },
2295         };
2296
2297         ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2298          sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2299          pvStructInfo, pcbStructInfo, NULL);
2300     }
2301     __EXCEPT_PAGE_FAULT
2302     {
2303         SetLastError(STATUS_ACCESS_VIOLATION);
2304     }
2305     __ENDTRY
2306     TRACE("returning %d\n", ret);
2307     return ret;
2308 }
2309
2310 static BOOL WINAPI CRYPT_AsnDecodeBool(DWORD dwCertEncodingType,
2311  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2312  void *pvStructInfo, DWORD *pcbStructInfo)
2313 {
2314     BOOL ret;
2315
2316     if (cbEncoded < 3)
2317     {
2318         SetLastError(CRYPT_E_ASN1_CORRUPT);
2319         return FALSE;
2320     }
2321     if (GET_LEN_BYTES(pbEncoded[1]) > 1)
2322     {
2323         SetLastError(CRYPT_E_ASN1_CORRUPT);
2324         return FALSE;
2325     }
2326     if (pbEncoded[1] > 1)
2327     {
2328         SetLastError(CRYPT_E_ASN1_CORRUPT);
2329         return FALSE;
2330     }
2331     if (!pvStructInfo)
2332     {
2333         *pcbStructInfo = sizeof(BOOL);
2334         ret = TRUE;
2335     }
2336     else if (*pcbStructInfo < sizeof(BOOL))
2337     {
2338         *pcbStructInfo = sizeof(BOOL);
2339         SetLastError(ERROR_MORE_DATA);
2340         ret = FALSE;
2341     }
2342     else
2343     {
2344         *pcbStructInfo = sizeof(BOOL);
2345         *(BOOL *)pvStructInfo = pbEncoded[2] ? TRUE : FALSE;
2346         ret = TRUE;
2347     }
2348     TRACE("returning %d (%08x)\n", ret, GetLastError());
2349     return ret;
2350 }
2351
2352 BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoDecode(DWORD dwCertEncodingType,
2353  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2354  void *pvStructInfo, DWORD *pcbStructInfo)
2355 {
2356     BOOL ret = FALSE;
2357
2358     TRACE("(%p, %d, %08x, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
2359      pvStructInfo, *pcbStructInfo);
2360
2361     __TRY
2362     {
2363         struct AsnDecodeSequenceItem items[] = {
2364          { ASN_BOOL, offsetof(SPC_FINANCIAL_CRITERIA, fFinancialInfoAvailable),
2365            CRYPT_AsnDecodeBool, MEMBERSIZE(SPC_FINANCIAL_CRITERIA,
2366            fFinancialInfoAvailable, fMeetsCriteria), FALSE, FALSE, 0, 0 },
2367          { ASN_BOOL, offsetof(SPC_FINANCIAL_CRITERIA, fMeetsCriteria),
2368            CRYPT_AsnDecodeBool, FINALMEMBERSIZE(SPC_FINANCIAL_CRITERIA,
2369            fMeetsCriteria), FALSE, FALSE, 0, 0 },
2370         };
2371
2372         ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2373          sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2374          pvStructInfo, pcbStructInfo, NULL);
2375     }
2376     __EXCEPT_PAGE_FAULT
2377     {
2378         SetLastError(STATUS_ACCESS_VIOLATION);
2379     }
2380     __ENDTRY
2381     TRACE("returning %d\n", ret);
2382     return ret;
2383 }