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