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