git.oblomov.eu Git - wine/blob - dlls/crypt32/decode.c

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