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

   1 /*
   2  * Copyright 2005-2008 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 isn't
  21  * implemented, 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 "Constants for CryptEncodeObject and CryptDecodeObject"
  31  */
  32
  33 #include "config.h"
  34 #include "wine/port.h"
  35
  36 #include <assert.h>
  37 #include <stdarg.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40
  41 #define NONAMELESSUNION
  42
  43 #include "windef.h"
  44 #include "winbase.h"
  45 #include "wincrypt.h"
  46 #include "winnls.h"
  47 #include "snmp.h"
  48 #include "wine/debug.h"
  49 #include "wine/exception.h"
  50 #include "crypt32_private.h"
  51
  52 /* This is a bit arbitrary, but to set some limit: */
  53 #define MAX_ENCODED_LEN 0x02000000
  54
  55 #define ASN_FLAGS_MASK 0xe0
  56 #define ASN_TYPE_MASK  0x1f
  57
  58 WINE_DEFAULT_DEBUG_CHANNEL(cryptasn);
  59 WINE_DECLARE_DEBUG_CHANNEL(crypt);
  60
  61 struct GenericArray
  62 {
  63     DWORD cItems;
  64     BYTE *rgItems;
  65 };
  66
  67 typedef BOOL (WINAPI *CryptDecodeObjectFunc)(DWORD, LPCSTR, const BYTE *,
  68  DWORD, DWORD, void *, DWORD *);
  69 typedef BOOL (WINAPI *CryptDecodeObjectExFunc)(DWORD, LPCSTR, const BYTE *,
  70  DWORD, DWORD, PCRYPT_DECODE_PARA, void *, DWORD *);
  71
  72 /* Internal decoders don't do memory allocation or exception handling, and
  73  * they report how many bytes they decoded.
  74  */
  75 typedef BOOL (*InternalDecodeFunc)(const BYTE *pbEncoded, DWORD cbEncoded,
  76  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded);
  77
  78 static BOOL CRYPT_AsnDecodeChoiceOfTimeInternal(const BYTE *pbEncoded,
  79  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
  80  DWORD *pcbDecoded);
  81 static BOOL CRYPT_AsnDecodePubKeyInfoInternal(const BYTE *pbEncoded,
  82  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
  83  DWORD *pcbDecoded);
  84 /* Like CRYPT_AsnDecodeExtensions, except assumes rgExtension is set ahead of
  85  * time, doesn't do memory allocation, and doesn't do exception handling.
  86  */
  87 static BOOL CRYPT_AsnDecodeExtensionsInternal(const BYTE *pbEncoded,
  88  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
  89  DWORD *pcbDecoded);
  90 /* Assumes algo->Parameters.pbData is set ahead of time. */
  91 static BOOL CRYPT_AsnDecodeAlgorithmId(const BYTE *pbEncoded, DWORD cbEncoded,
  92  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded);
  93 static BOOL CRYPT_AsnDecodeBool(const BYTE *pbEncoded, DWORD cbEncoded,
  94  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded);
  95 /* Assumes the CRYPT_DATA_BLOB's pbData member has been initialized */
  96 static BOOL CRYPT_AsnDecodeOctetsInternal(const BYTE *pbEncoded,
  97  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
  98  DWORD *pcbDecoded);
  99 /* Doesn't check the tag, assumes the caller does so */
 100 static BOOL CRYPT_AsnDecodeBitsInternal(const BYTE *pbEncoded, DWORD cbEncoded,
 101  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded);
 102 static BOOL CRYPT_AsnDecodeIntInternal(const BYTE *pbEncoded, DWORD cbEncoded,
 103  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded);
 104 /* Like CRYPT_AsnDecodeInteger, but assumes the CRYPT_INTEGER_BLOB's pbData
 105  * member has been initialized, doesn't do exception handling, and doesn't do
 106  * memory allocation.  Also doesn't check tag, assumes the caller has checked
 107  * it.
 108  */
 109 static BOOL CRYPT_AsnDecodeIntegerInternal(const BYTE *pbEncoded,
 110  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
 111  DWORD *pcbDecoded);
 112 /* Like CRYPT_AsnDecodeInteger, but unsigned.  */
 113 static BOOL CRYPT_AsnDecodeUnsignedIntegerInternal(const BYTE *pbEncoded,
 114  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
 115  DWORD *pcbDecoded);
 116 static BOOL CRYPT_AsnDecodePKCSAttributesInternal(const BYTE *pbEncoded,
 117  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
 118  DWORD *pcbDecoded);
 119
 120 /* Gets the number of length bytes from the given (leading) length byte */
 121 #define GET_LEN_BYTES(b) ((b) <= 0x80 ? 1 : 1 + ((b) & 0x7f))
 122
 123 /* Helper function to get the encoded length of the data starting at pbEncoded,
 124  * where pbEncoded[0] is the tag.  If the data are too short to contain a
 125  * length or if the length is too large for cbEncoded, sets an appropriate
 126  * error code and returns FALSE.  If the encoded length is unknown due to
 127  * indefinite length encoding, *len is set to CMSG_INDEFINITE_LENGTH.
 128  */
 129 static BOOL CRYPT_GetLengthIndefinite(const BYTE *pbEncoded, DWORD cbEncoded,
 130  DWORD *len)
 131 {
 132     BOOL ret;
 133
 134     if (cbEncoded <= 1)
 135     {
 136         SetLastError(CRYPT_E_ASN1_CORRUPT);
 137         ret = FALSE;
 138     }
 139     else if (pbEncoded[1] <= 0x7f)
 140     {
 141         if (pbEncoded[1] + 1 > cbEncoded)
 142         {
 143             SetLastError(CRYPT_E_ASN1_EOD);
 144             ret = FALSE;
 145         }
 146         else
 147         {
 148             *len = pbEncoded[1];
 149             ret = TRUE;
 150         }
 151     }
 152     else if (pbEncoded[1] == 0x80)
 153     {
 154         *len = CMSG_INDEFINITE_LENGTH;
 155         ret = TRUE;
 156     }
 157     else
 158     {
 159         BYTE lenLen = GET_LEN_BYTES(pbEncoded[1]);
 160
 161         if (lenLen > sizeof(DWORD) + 1)
 162         {
 163             SetLastError(CRYPT_E_ASN1_LARGE);
 164             ret = FALSE;
 165         }
 166         else if (lenLen + 2 > cbEncoded)
 167         {
 168             SetLastError(CRYPT_E_ASN1_CORRUPT);
 169             ret = FALSE;
 170         }
 171         else
 172         {
 173             DWORD out = 0;
 174
 175             pbEncoded += 2;
 176             while (--lenLen)
 177             {
 178                 out <<= 8;
 179                 out |= *pbEncoded++;
 180             }
 181             if (out + lenLen + 1 > cbEncoded)
 182             {
 183                 SetLastError(CRYPT_E_ASN1_EOD);
 184                 ret = FALSE;
 185             }
 186             else
 187             {
 188                 *len = out;
 189                 ret = TRUE;
 190             }
 191         }
 192     }
 193     return ret;
 194 }
 195
 196 /* Like CRYPT_GetLengthIndefinite, but disallows indefinite-length encoding. */
 197 static BOOL CRYPT_GetLen(const BYTE *pbEncoded, DWORD cbEncoded, DWORD *len)
 198 {
 199     BOOL ret;
 200
 201     if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, len)) &&
 202      *len == CMSG_INDEFINITE_LENGTH)
 203     {
 204         SetLastError(CRYPT_E_ASN1_CORRUPT);
 205         ret = FALSE;
 206     }
 207     return ret;
 208 }
 209
 210 /* Helper function to check *pcbStructInfo, set it to the required size, and
 211  * optionally to allocate memory.  Assumes pvStructInfo is not NULL.
 212  * If CRYPT_DECODE_ALLOC_FLAG is set in dwFlags, *pvStructInfo will be set to a
 213  * pointer to the newly allocated memory.
 214  */
 215 static BOOL CRYPT_DecodeEnsureSpace(DWORD dwFlags,
 216  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo,
 217  DWORD bytesNeeded)
 218 {
 219     BOOL ret = TRUE;
 220
 221     if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
 222     {
 223         if (pDecodePara && pDecodePara->pfnAlloc)
 224             *(BYTE **)pvStructInfo = pDecodePara->pfnAlloc(bytesNeeded);
 225         else
 226             *(BYTE **)pvStructInfo = LocalAlloc(0, bytesNeeded);
 227         if (!*(BYTE **)pvStructInfo)
 228             ret = FALSE;
 229         else
 230             *pcbStructInfo = bytesNeeded;
 231     }
 232     else if (*pcbStructInfo < bytesNeeded)
 233     {
 234         *pcbStructInfo = bytesNeeded;
 235         SetLastError(ERROR_MORE_DATA);
 236         ret = FALSE;
 237     }
 238     else
 239         *pcbStructInfo = bytesNeeded;
 240     return ret;
 241 }
 242
 243 static void CRYPT_FreeSpace(PCRYPT_DECODE_PARA pDecodePara, LPVOID pv)
 244 {
 245     if (pDecodePara && pDecodePara->pfnFree)
 246         pDecodePara->pfnFree(pv);
 247     else
 248         LocalFree(pv);
 249 }
 250
 251 /* Helper function to check *pcbStructInfo and set it to the required size.
 252  * Assumes pvStructInfo is not NULL.
 253  */
 254 static BOOL CRYPT_DecodeCheckSpace(DWORD *pcbStructInfo, DWORD bytesNeeded)
 255 {
 256     BOOL ret;
 257
 258     if (*pcbStructInfo < bytesNeeded)
 259     {
 260         *pcbStructInfo = bytesNeeded;
 261         SetLastError(ERROR_MORE_DATA);
 262         ret = FALSE;
 263     }
 264     else
 265     {
 266         *pcbStructInfo = bytesNeeded;
 267         ret = TRUE;
 268     }
 269     return ret;
 270 }
 271
 272 /* tag:
 273  *     The expected tag of the item.  If tag is 0, decodeFunc is called
 274  *     regardless of the tag value seen.
 275  * offset:
 276  *     A sequence is decoded into a struct.  The offset member is the
 277  *     offset of this item within that struct.
 278  * decodeFunc:
 279  *     The decoder function to use.  If this is NULL, then the member isn't
 280  *     decoded, but minSize space is reserved for it.
 281  * minSize:
 282  *     The minimum amount of space occupied after decoding.  You must set this.
 283  * optional:
 284  *     If true, and the tag doesn't match the expected tag for this item,
 285  *     or the decodeFunc fails with CRYPT_E_ASN1_BADTAG, then minSize space is
 286  *     filled with 0 for this member.
 287  * hasPointer, pointerOffset:
 288  *     If the item has dynamic data, set hasPointer to TRUE, pointerOffset to
 289  *     the offset within the struct of the data pointer (or to the
 290  *     first data pointer, if more than one exist).
 291  * size:
 292  *     Used by CRYPT_AsnDecodeSequence, not for your use.
 293  */
 294 struct AsnDecodeSequenceItem
 295 {
 296     BYTE               tag;
 297     DWORD              offset;
 298     InternalDecodeFunc decodeFunc;
 299     DWORD              minSize;
 300     BOOL               optional;
 301     BOOL               hasPointer;
 302     DWORD              pointerOffset;
 303     DWORD              size;
 304 };
 305
 306 /* Decodes the items in a sequence, where the items are described in items,
 307  * the encoded data are in pbEncoded with length cbEncoded.  Decodes into
 308  * pvStructInfo.  nextData is a pointer to the memory location at which the
 309  * first decoded item with a dynamic pointer should point.
 310  * Upon decoding, *cbDecoded is the total number of bytes decoded.
 311  * Each item decoder is never called with CRYPT_DECODE_ALLOC_FLAG set.
 312  */
 313 static BOOL CRYPT_AsnDecodeSequenceItems(struct AsnDecodeSequenceItem items[],
 314  DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
 315  void *pvStructInfo, BYTE *nextData, DWORD *cbDecoded)
 316 {
 317     BOOL ret;
 318     DWORD i, decoded = 0;
 319     const BYTE *ptr = pbEncoded;
 320
 321     TRACE("%p, %d, %p, %d, %08x, %p, %p, %p\n", items, cItem, pbEncoded,
 322      cbEncoded, dwFlags, pvStructInfo, nextData, cbDecoded);
 323
 324     for (i = 0, ret = TRUE; ret && i < cItem; i++)
 325     {
 326         if (cbEncoded - (ptr - pbEncoded) != 0)
 327         {
 328             DWORD itemLen;
 329
 330             if ((ret = CRYPT_GetLengthIndefinite(ptr,
 331              cbEncoded - (ptr - pbEncoded), &itemLen)))
 332             {
 333                 BYTE itemLenBytes = GET_LEN_BYTES(ptr[1]);
 334
 335                 if (ptr[0] == items[i].tag || !items[i].tag)
 336                 {
 337                     DWORD itemEncodedLen;
 338
 339                     if (itemLen == CMSG_INDEFINITE_LENGTH)
 340                         itemEncodedLen = cbEncoded - (ptr - pbEncoded);
 341                     else
 342                         itemEncodedLen = 1 + itemLenBytes + itemLen;
 343                     if (nextData && pvStructInfo && items[i].hasPointer)
 344                     {
 345                         TRACE("Setting next pointer to %p\n",
 346                          nextData);
 347                         *(BYTE **)((BYTE *)pvStructInfo +
 348                          items[i].pointerOffset) = nextData;
 349                     }
 350                     if (items[i].decodeFunc)
 351                     {
 352                         DWORD itemDecoded;
 353
 354                         if (pvStructInfo)
 355                             TRACE("decoding item %d\n", i);
 356                         else
 357                             TRACE("sizing item %d\n", i);
 358                         ret = items[i].decodeFunc(ptr, itemEncodedLen,
 359                          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
 360                          pvStructInfo ?  (BYTE *)pvStructInfo + items[i].offset
 361                          : NULL, &items[i].size, &itemDecoded);
 362                         if (ret)
 363                         {
 364                             /* Account for alignment padding */
 365                             items[i].size = ALIGN_DWORD_PTR(items[i].size);
 366                             TRACE("item %d size: %d\n", i, items[i].size);
 367                             if (nextData && items[i].hasPointer &&
 368                              items[i].size > items[i].minSize)
 369                                 nextData += items[i].size - items[i].minSize;
 370                             if (itemDecoded > itemEncodedLen)
 371                             {
 372                                 WARN("decoded length %d exceeds encoded %d\n",
 373                                  itemDecoded, itemEncodedLen);
 374                                 SetLastError(CRYPT_E_ASN1_CORRUPT);
 375                                 ret = FALSE;
 376                             }
 377                             else
 378                             {
 379                                 ptr += itemDecoded;
 380                                 decoded += itemDecoded;
 381                                 TRACE("item %d: decoded %d bytes\n", i,
 382                                  itemDecoded);
 383                             }
 384                         }
 385                         else if (items[i].optional &&
 386                          GetLastError() == CRYPT_E_ASN1_BADTAG)
 387                         {
 388                             TRACE("skipping optional item %d\n", i);
 389                             items[i].size = items[i].minSize;
 390                             SetLastError(NOERROR);
 391                             ret = TRUE;
 392                         }
 393                         else
 394                             TRACE("item %d failed: %08x\n", i,
 395                              GetLastError());
 396                     }
 397                     else if (itemLen == CMSG_INDEFINITE_LENGTH)
 398                     {
 399                         ERR("can't use indefinite length encoding without a decoder\n");
 400                         SetLastError(CRYPT_E_ASN1_CORRUPT);
 401                         ret = FALSE;
 402                     }
 403                     else
 404                     {
 405                         TRACE("item %d: decoded %d bytes\n", i, itemEncodedLen);
 406                         ptr += itemEncodedLen;
 407                         decoded += itemEncodedLen;
 408                         items[i].size = items[i].minSize;
 409                     }
 410                 }
 411                 else if (items[i].optional)
 412                 {
 413                     TRACE("skipping optional item %d\n", i);
 414                     items[i].size = items[i].minSize;
 415                 }
 416                 else
 417                 {
 418                     TRACE("item %d: tag %02x doesn't match expected %02x\n",
 419                      i, ptr[0], items[i].tag);
 420                     SetLastError(CRYPT_E_ASN1_BADTAG);
 421                     ret = FALSE;
 422                 }
 423             }
 424         }
 425         else if (items[i].optional)
 426         {
 427             TRACE("missing optional item %d, skipping\n", i);
 428             items[i].size = items[i].minSize;
 429         }
 430         else
 431         {
 432             TRACE("not enough bytes for item %d, failing\n", i);
 433             SetLastError(CRYPT_E_ASN1_CORRUPT);
 434             ret = FALSE;
 435         }
 436     }
 437     if (cbDecoded)
 438         *cbDecoded = decoded;
 439     TRACE("returning %d\n", ret);
 440     return ret;
 441 }
 442
 443 /* This decodes an arbitrary sequence into a contiguous block of memory
 444  * (basically, a struct.)  Each element being decoded is described by a struct
 445  * AsnDecodeSequenceItem, see above.
 446  * startingPointer is an optional pointer to the first place where dynamic
 447  * data will be stored.  If you know the starting offset, you may pass it
 448  * here.  Otherwise, pass NULL, and one will be inferred from the items.
 449  */
 450 static BOOL CRYPT_AsnDecodeSequence(struct AsnDecodeSequenceItem items[],
 451  DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
 452  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo,
 453  DWORD *pcbDecoded, void *startingPointer)
 454 {
 455     BOOL ret;
 456
 457     TRACE("%p, %d, %p, %d, %08x, %p, %p, %d, %p\n", items, cItem, pbEncoded,
 458      cbEncoded, dwFlags, pDecodePara, pvStructInfo, *pcbStructInfo,
 459      startingPointer);
 460
 461     if (!cbEncoded)
 462     {
 463         SetLastError(CRYPT_E_ASN1_EOD);
 464         return FALSE;
 465     }
 466     if (pbEncoded[0] == ASN_SEQUENCE)
 467     {
 468         DWORD dataLen;
 469
 470         if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
 471         {
 472             DWORD lenBytes = GET_LEN_BYTES(pbEncoded[1]), cbDecoded;
 473             const BYTE *ptr = pbEncoded + 1 + lenBytes;
 474             BOOL indefinite = FALSE;
 475
 476             cbEncoded -= 1 + lenBytes;
 477             if (dataLen == CMSG_INDEFINITE_LENGTH)
 478             {
 479                 dataLen = cbEncoded;
 480                 indefinite = TRUE;
 481             }
 482             else if (cbEncoded < dataLen)
 483             {
 484                 TRACE("dataLen %d exceeds cbEncoded %d, failing\n", dataLen,
 485                  cbEncoded);
 486                 SetLastError(CRYPT_E_ASN1_CORRUPT);
 487                 ret = FALSE;
 488             }
 489             if (ret)
 490             {
 491                 ret = CRYPT_AsnDecodeSequenceItems(items, cItem,
 492                  ptr, dataLen, dwFlags, NULL, NULL, &cbDecoded);
 493                 if (ret && dataLen == CMSG_INDEFINITE_LENGTH)
 494                 {
 495                     if (cbDecoded > cbEncoded - 2)
 496                     {
 497                         /* Not enough space for 0 TLV */
 498                         SetLastError(CRYPT_E_ASN1_CORRUPT);
 499                         ret = FALSE;
 500                     }
 501                     else if (*(ptr + cbDecoded) != 0 ||
 502                      *(ptr + cbDecoded + 1) != 0)
 503                     {
 504                         TRACE("expected 0 TLV\n");
 505                         SetLastError(CRYPT_E_ASN1_CORRUPT);
 506                         ret = FALSE;
 507                     }
 508                     else
 509                         cbDecoded += 2;
 510                 }
 511             }
 512             if (ret && !indefinite && cbDecoded != dataLen)
 513             {
 514                 TRACE("expected %d decoded, got %d, failing\n", dataLen,
 515                  cbDecoded);
 516                 SetLastError(CRYPT_E_ASN1_CORRUPT);
 517                 ret = FALSE;
 518             }
 519             if (ret)
 520             {
 521                 DWORD i, bytesNeeded = 0, structSize = 0;
 522
 523                 for (i = 0; i < cItem; i++)
 524                 {
 525                     bytesNeeded += items[i].size;
 526                     structSize += items[i].minSize;
 527                 }
 528                 if (pcbDecoded)
 529                     *pcbDecoded = 1 + lenBytes + cbDecoded;
 530                 if (!pvStructInfo)
 531                     *pcbStructInfo = bytesNeeded;
 532                 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags,
 533                  pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
 534                 {
 535                     BYTE *nextData;
 536
 537                     if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
 538                         pvStructInfo = *(BYTE **)pvStructInfo;
 539                     if (startingPointer)
 540                         nextData = startingPointer;
 541                     else
 542                         nextData = (BYTE *)pvStructInfo + structSize;
 543                     memset(pvStructInfo, 0, structSize);
 544                     ret = CRYPT_AsnDecodeSequenceItems(items, cItem,
 545                      ptr, dataLen, dwFlags, pvStructInfo, nextData,
 546                      &cbDecoded);
 547                     if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
 548                         CRYPT_FreeSpace(pDecodePara, pvStructInfo);
 549                 }
 550             }
 551         }
 552     }
 553     else
 554     {
 555         SetLastError(CRYPT_E_ASN1_BADTAG);
 556         ret = FALSE;
 557     }
 558     TRACE("returning %d (%08x)\n", ret, GetLastError());
 559     return ret;
 560 }
 561
 562 /* tag:
 563  *     The expected tag of the entire encoded array (usually a variant
 564  *     of ASN_SETOF or ASN_SEQUENCEOF.)  If tag is 0, decodeFunc is called
 565  *     regardless of the tag seen.
 566  * decodeFunc:
 567  *     used to decode each item in the array
 568  * itemSize:
 569  *      is the minimum size of each decoded item
 570  * hasPointer:
 571  *      indicates whether each item has a dynamic pointer
 572  * pointerOffset:
 573  *     indicates the offset within itemSize at which the pointer exists
 574  */
 575 struct AsnArrayDescriptor
 576 {
 577     BYTE               tag;
 578     InternalDecodeFunc decodeFunc;
 579     DWORD              itemSize;
 580     BOOL               hasPointer;
 581     DWORD              pointerOffset;
 582 };
 583
 584 struct AsnArrayItemSize
 585 {
 586     DWORD encodedLen;
 587     DWORD size;
 588 };
 589
 590 /* Decodes an array of like types into a struct GenericArray.
 591  * The layout and decoding of the array are described by a struct
 592  * AsnArrayDescriptor.
 593  */
 594 static BOOL CRYPT_AsnDecodeArray(const struct AsnArrayDescriptor *arrayDesc,
 595  const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
 596  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo,
 597  DWORD *pcbDecoded, void *startingPointer)
 598 {
 599     BOOL ret = TRUE;
 600
 601     TRACE("%p, %p, %d, %08x, %p, %p, %d, %p\n", arrayDesc, pbEncoded,
 602      cbEncoded, dwFlags, pDecodePara, pvStructInfo, *pcbStructInfo,
 603      startingPointer);
 604
 605     if (!arrayDesc->tag || pbEncoded[0] == arrayDesc->tag)
 606     {
 607         DWORD dataLen;
 608
 609         if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
 610         {
 611             DWORD bytesNeeded, cItems = 0, decoded;
 612             BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
 613             /* There can be arbitrarily many items, but there is often only one.
 614              */
 615             struct AsnArrayItemSize itemSize = { 0 }, *itemSizes = &itemSize;
 616
 617             decoded = 1 + lenBytes;
 618             bytesNeeded = sizeof(struct GenericArray);
 619             if (dataLen)
 620             {
 621                 const BYTE *ptr;
 622                 BOOL doneDecoding = FALSE;
 623
 624                 for (ptr = pbEncoded + 1 + lenBytes; ret && !doneDecoding; )
 625                 {
 626                     if (dataLen == CMSG_INDEFINITE_LENGTH)
 627                     {
 628                         if (ptr[0] == 0)
 629                         {
 630                             doneDecoding = TRUE;
 631                             if (ptr[1] != 0)
 632                             {
 633                                 SetLastError(CRYPT_E_ASN1_CORRUPT);
 634                                 ret = FALSE;
 635                             }
 636                             else
 637                                 decoded += 2;
 638                         }
 639                     }
 640                     else if (ptr - pbEncoded - 1 - lenBytes >= dataLen)
 641                         doneDecoding = TRUE;
 642                     if (!doneDecoding)
 643                     {
 644                         DWORD itemEncoded, itemDataLen, itemDecoded, size = 0;
 645
 646                         /* Each item decoded may not tolerate extraneous bytes,
 647                          * so get the length of the next element if known.
 648                          */
 649                         if ((ret = CRYPT_GetLengthIndefinite(ptr,
 650                          cbEncoded - (ptr - pbEncoded), &itemDataLen)))
 651                         {
 652                             if (itemDataLen == CMSG_INDEFINITE_LENGTH)
 653                                 itemEncoded = cbEncoded - (ptr - pbEncoded);
 654                             else
 655                                 itemEncoded = 1 + GET_LEN_BYTES(ptr[1]) +
 656                                  itemDataLen;
 657                         }
 658                         if (ret)
 659                             ret = arrayDesc->decodeFunc(ptr, itemEncoded,
 660                              dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &size,
 661                              &itemDecoded);
 662                         if (ret)
 663                         {
 664                             cItems++;
 665                             if (itemSizes != &itemSize)
 666                                 itemSizes = CryptMemRealloc(itemSizes,
 667                                  cItems * sizeof(struct AsnArrayItemSize));
 668                             else if (cItems > 1)
 669                             {
 670                                 itemSizes =
 671                                  CryptMemAlloc(
 672                                  cItems * sizeof(struct AsnArrayItemSize));
 673                                 if (itemSizes)
 674                                     memcpy(itemSizes, &itemSize,
 675                                      sizeof(itemSize));
 676                             }
 677                             if (itemSizes)
 678                             {
 679                                 decoded += itemDecoded;
 680                                 itemSizes[cItems - 1].encodedLen = itemEncoded;
 681                                 itemSizes[cItems - 1].size = size;
 682                                 bytesNeeded += size;
 683                                 ptr += itemEncoded;
 684                             }
 685                             else
 686                                 ret = FALSE;
 687                         }
 688                     }
 689                 }
 690             }
 691             if (ret)
 692             {
 693                 if (pcbDecoded)
 694                     *pcbDecoded = decoded;
 695                 if (!pvStructInfo)
 696                     *pcbStructInfo = bytesNeeded;
 697                 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags,
 698                  pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
 699                 {
 700                     DWORD i;
 701                     BYTE *nextData;
 702                     const BYTE *ptr;
 703                     struct GenericArray *array;
 704
 705                     if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
 706                         pvStructInfo = *(BYTE **)pvStructInfo;
 707                     array = pvStructInfo;
 708                     array->cItems = cItems;
 709                     if (startingPointer)
 710                         array->rgItems = startingPointer;
 711                     else
 712                         array->rgItems = (BYTE *)array +
 713                          sizeof(struct GenericArray);
 714                     nextData = array->rgItems +
 715                      array->cItems * arrayDesc->itemSize;
 716                     for (i = 0, ptr = pbEncoded + 1 + lenBytes; ret &&
 717                      i < cItems && ptr - pbEncoded - 1 - lenBytes <
 718                      dataLen; i++)
 719                     {
 720                         DWORD itemDecoded;
 721
 722                         if (arrayDesc->hasPointer)
 723                             *(BYTE **)(array->rgItems + i * arrayDesc->itemSize
 724                              + arrayDesc->pointerOffset) = nextData;
 725                         ret = arrayDesc->decodeFunc(ptr,
 726                          itemSizes[i].encodedLen,
 727                          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
 728                          array->rgItems + i * arrayDesc->itemSize,
 729                          &itemSizes[i].size, &itemDecoded);
 730                         if (ret)
 731                         {
 732                             nextData += itemSizes[i].size - arrayDesc->itemSize;
 733                             ptr += itemDecoded;
 734                         }
 735                     }
 736                     if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
 737                         CRYPT_FreeSpace(pDecodePara, pvStructInfo);
 738                 }
 739             }
 740             if (itemSizes != &itemSize)
 741                 CryptMemFree(itemSizes);
 742         }
 743     }
 744     else
 745     {
 746         SetLastError(CRYPT_E_ASN1_BADTAG);
 747         ret = FALSE;
 748     }
 749     return ret;
 750 }
 751
 752 /* Decodes a DER-encoded BLOB into a CRYPT_DER_BLOB struct pointed to by
 753  * pvStructInfo.  The BLOB must be non-empty, otherwise the last error is set
 754  * to CRYPT_E_ASN1_CORRUPT.
 755  * Warning: assumes the CRYPT_DER_BLOB pointed to by pvStructInfo has pbData
 756  * set!
 757  */
 758 static BOOL CRYPT_AsnDecodeDerBlob(const BYTE *pbEncoded, DWORD cbEncoded,
 759  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 760 {
 761     BOOL ret;
 762     DWORD dataLen;
 763
 764     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
 765     {
 766         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
 767         DWORD bytesNeeded = sizeof(CRYPT_DER_BLOB);
 768
 769         if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
 770             bytesNeeded += 1 + lenBytes + dataLen;
 771
 772         if (pcbDecoded)
 773             *pcbDecoded = 1 + lenBytes + dataLen;
 774         if (!pvStructInfo)
 775             *pcbStructInfo = bytesNeeded;
 776         else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo, bytesNeeded)))
 777         {
 778             CRYPT_DER_BLOB *blob;
 779
 780             if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
 781                 pvStructInfo = *(BYTE **)pvStructInfo;
 782             blob = pvStructInfo;
 783             blob->cbData = 1 + lenBytes + dataLen;
 784             if (blob->cbData)
 785             {
 786                 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
 787                     blob->pbData = (BYTE *)pbEncoded;
 788                 else
 789                 {
 790                     assert(blob->pbData);
 791                     memcpy(blob->pbData, pbEncoded, blob->cbData);
 792                 }
 793             }
 794             else
 795             {
 796                 SetLastError(CRYPT_E_ASN1_CORRUPT);
 797                 ret = FALSE;
 798             }
 799         }
 800     }
 801     return ret;
 802 }
 803
 804 /* Like CRYPT_AsnDecodeBitsInternal, but swaps the bytes */
 805 static BOOL CRYPT_AsnDecodeBitsSwapBytes(const BYTE *pbEncoded,
 806  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
 807  DWORD *pcbDecoded)
 808 {
 809     BOOL ret;
 810
 811     TRACE("(%p, %d, 0x%08x, %p, %d, %p)\n", pbEncoded, cbEncoded, dwFlags,
 812      pvStructInfo, *pcbStructInfo, pcbDecoded);
 813
 814     /* Can't use the CRYPT_DECODE_NOCOPY_FLAG, because we modify the bytes in-
 815      * place.
 816      */
 817     ret = CRYPT_AsnDecodeBitsInternal(pbEncoded, cbEncoded,
 818      dwFlags & ~CRYPT_DECODE_NOCOPY_FLAG, pvStructInfo, pcbStructInfo,
 819      pcbDecoded);
 820     if (ret && pvStructInfo)
 821     {
 822         CRYPT_BIT_BLOB *blob = pvStructInfo;
 823
 824         if (blob->cbData)
 825         {
 826             DWORD i;
 827             BYTE temp;
 828
 829             for (i = 0; i < blob->cbData / 2; i++)
 830             {
 831                 temp = blob->pbData[i];
 832                 blob->pbData[i] = blob->pbData[blob->cbData - i - 1];
 833                 blob->pbData[blob->cbData - i - 1] = temp;
 834             }
 835         }
 836     }
 837     TRACE("returning %d (%08x)\n", ret, GetLastError());
 838     return ret;
 839 }
 840
 841 static BOOL WINAPI CRYPT_AsnDecodeCertSignedContent(DWORD dwCertEncodingType,
 842  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
 843  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 844 {
 845     BOOL ret = TRUE;
 846
 847     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
 848      pDecodePara, pvStructInfo, *pcbStructInfo);
 849
 850     __TRY
 851     {
 852         struct AsnDecodeSequenceItem items[] = {
 853          { 0, offsetof(CERT_SIGNED_CONTENT_INFO, ToBeSigned),
 854            CRYPT_AsnDecodeDerBlob, sizeof(CRYPT_DER_BLOB), FALSE, TRUE,
 855            offsetof(CERT_SIGNED_CONTENT_INFO, ToBeSigned.pbData), 0 },
 856          { ASN_SEQUENCEOF, offsetof(CERT_SIGNED_CONTENT_INFO,
 857            SignatureAlgorithm), CRYPT_AsnDecodeAlgorithmId,
 858            sizeof(CRYPT_ALGORITHM_IDENTIFIER), FALSE, TRUE,
 859            offsetof(CERT_SIGNED_CONTENT_INFO, SignatureAlgorithm.pszObjId), 0 },
 860          { ASN_BITSTRING, offsetof(CERT_SIGNED_CONTENT_INFO, Signature),
 861            CRYPT_AsnDecodeBitsSwapBytes, sizeof(CRYPT_BIT_BLOB), FALSE, TRUE,
 862            offsetof(CERT_SIGNED_CONTENT_INFO, Signature.pbData), 0 },
 863         };
 864
 865         if (dwFlags & CRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG)
 866             items[2].decodeFunc = CRYPT_AsnDecodeBitsInternal;
 867         ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
 868          pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
 869          pcbStructInfo, NULL, NULL);
 870     }
 871     __EXCEPT_PAGE_FAULT
 872     {
 873         SetLastError(STATUS_ACCESS_VIOLATION);
 874         ret = FALSE;
 875     }
 876     __ENDTRY
 877
 878     TRACE("Returning %d (%08x)\n", ret, GetLastError());
 879     return ret;
 880 }
 881
 882 static BOOL CRYPT_AsnDecodeCertVersion(const BYTE *pbEncoded, DWORD cbEncoded,
 883  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 884 {
 885     BOOL ret;
 886     DWORD dataLen;
 887
 888     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
 889     {
 890         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
 891
 892         ret = CRYPT_AsnDecodeIntInternal(pbEncoded + 1 + lenBytes, dataLen,
 893          dwFlags, pvStructInfo, pcbStructInfo, NULL);
 894         if (pcbDecoded)
 895             *pcbDecoded = 1 + lenBytes + dataLen;
 896     }
 897     return ret;
 898 }
 899
 900 static BOOL CRYPT_AsnDecodeValidity(const BYTE *pbEncoded, DWORD cbEncoded,
 901  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 902 {
 903     BOOL ret;
 904
 905     struct AsnDecodeSequenceItem items[] = {
 906      { 0, offsetof(CERT_PRIVATE_KEY_VALIDITY, NotBefore),
 907        CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE, 0 },
 908      { 0, offsetof(CERT_PRIVATE_KEY_VALIDITY, NotAfter),
 909        CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE, 0 },
 910     };
 911
 912     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
 913      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
 914      pcbDecoded, NULL);
 915     return ret;
 916 }
 917
 918 static BOOL CRYPT_AsnDecodeCertExtensions(const BYTE *pbEncoded,
 919  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
 920  DWORD *pcbDecoded)
 921 {
 922     BOOL ret;
 923     DWORD dataLen;
 924
 925     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
 926     {
 927         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
 928
 929         ret = CRYPT_AsnDecodeExtensionsInternal(pbEncoded + 1 + lenBytes,
 930          dataLen, dwFlags, pvStructInfo, pcbStructInfo, NULL);
 931         if (ret && pcbDecoded)
 932             *pcbDecoded = 1 + lenBytes + dataLen;
 933     }
 934     return ret;
 935 }
 936
 937 static BOOL CRYPT_AsnDecodeCertInfo(DWORD dwCertEncodingType,
 938  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
 939  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 940 {
 941     BOOL ret = TRUE;
 942     struct AsnDecodeSequenceItem items[] = {
 943      { ASN_CONTEXT | ASN_CONSTRUCTOR, offsetof(CERT_INFO, dwVersion),
 944        CRYPT_AsnDecodeCertVersion, sizeof(DWORD), TRUE, FALSE, 0, 0 },
 945      { ASN_INTEGER, offsetof(CERT_INFO, SerialNumber),
 946        CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), FALSE,
 947        TRUE, offsetof(CERT_INFO, SerialNumber.pbData), 0 },
 948      { ASN_SEQUENCEOF, offsetof(CERT_INFO, SignatureAlgorithm),
 949        CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
 950        FALSE, TRUE, offsetof(CERT_INFO, SignatureAlgorithm.pszObjId), 0 },
 951      { 0, offsetof(CERT_INFO, Issuer), CRYPT_AsnDecodeDerBlob,
 952        sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CERT_INFO,
 953        Issuer.pbData) },
 954      { ASN_SEQUENCEOF, offsetof(CERT_INFO, NotBefore),
 955        CRYPT_AsnDecodeValidity, sizeof(CERT_PRIVATE_KEY_VALIDITY), FALSE,
 956        FALSE, 0 },
 957      { 0, offsetof(CERT_INFO, Subject), CRYPT_AsnDecodeDerBlob,
 958        sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CERT_INFO,
 959        Subject.pbData) },
 960      { ASN_SEQUENCEOF, offsetof(CERT_INFO, SubjectPublicKeyInfo),
 961        CRYPT_AsnDecodePubKeyInfoInternal, sizeof(CERT_PUBLIC_KEY_INFO),
 962        FALSE, TRUE, offsetof(CERT_INFO,
 963        SubjectPublicKeyInfo.Algorithm.Parameters.pbData), 0 },
 964      { ASN_BITSTRING, offsetof(CERT_INFO, IssuerUniqueId),
 965        CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
 966        offsetof(CERT_INFO, IssuerUniqueId.pbData), 0 },
 967      { ASN_BITSTRING, offsetof(CERT_INFO, SubjectUniqueId),
 968        CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
 969        offsetof(CERT_INFO, SubjectUniqueId.pbData), 0 },
 970      { ASN_CONTEXT | ASN_CONSTRUCTOR | 3, offsetof(CERT_INFO, cExtension),
 971        CRYPT_AsnDecodeCertExtensions, sizeof(CERT_EXTENSIONS), TRUE, TRUE,
 972        offsetof(CERT_INFO, rgExtension), 0 },
 973     };
 974
 975     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
 976      pDecodePara, pvStructInfo, *pcbStructInfo);
 977
 978     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
 979      pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo,
 980      NULL, NULL);
 981     if (ret && pvStructInfo)
 982     {
 983         CERT_INFO *info;
 984
 985         if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
 986             info = *(CERT_INFO **)pvStructInfo;
 987         else
 988             info = pvStructInfo;
 989         if (!info->SerialNumber.cbData || !info->Issuer.cbData ||
 990          !info->Subject.cbData)
 991         {
 992             SetLastError(CRYPT_E_ASN1_CORRUPT);
 993             /* Don't need to deallocate, because it should have failed on the
 994              * first pass (and no memory was allocated.)
 995              */
 996             ret = FALSE;
 997         }
 998     }
 999
1000     TRACE("Returning %d (%08x)\n", ret, GetLastError());
1001     return ret;
1002 }
1003
1004 static BOOL WINAPI CRYPT_AsnDecodeCert(DWORD dwCertEncodingType,
1005  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1006  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1007 {
1008     BOOL ret = FALSE;
1009
1010     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1011      pDecodePara, pvStructInfo, *pcbStructInfo);
1012
1013     __TRY
1014     {
1015         DWORD size = 0;
1016
1017         /* Unless told not to, first try to decode it as a signed cert. */
1018         if (!(dwFlags & CRYPT_DECODE_TO_BE_SIGNED_FLAG))
1019         {
1020             PCERT_SIGNED_CONTENT_INFO signedCert = NULL;
1021
1022             ret = CRYPT_AsnDecodeCertSignedContent(dwCertEncodingType,
1023              X509_CERT, pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL,
1024              &signedCert, &size);
1025             if (ret)
1026             {
1027                 size = 0;
1028                 ret = CRYPT_AsnDecodeCertInfo(dwCertEncodingType,
1029                  X509_CERT_TO_BE_SIGNED, signedCert->ToBeSigned.pbData,
1030                  signedCert->ToBeSigned.cbData, dwFlags, pDecodePara,
1031                  pvStructInfo, pcbStructInfo);
1032                 LocalFree(signedCert);
1033             }
1034         }
1035         /* Failing that, try it as an unsigned cert */
1036         if (!ret)
1037         {
1038             size = 0;
1039             ret = CRYPT_AsnDecodeCertInfo(dwCertEncodingType,
1040              X509_CERT_TO_BE_SIGNED, pbEncoded, cbEncoded, dwFlags,
1041              pDecodePara, pvStructInfo, pcbStructInfo);
1042         }
1043     }
1044     __EXCEPT_PAGE_FAULT
1045     {
1046         SetLastError(STATUS_ACCESS_VIOLATION);
1047     }
1048     __ENDTRY
1049
1050     TRACE("Returning %d (%08x)\n", ret, GetLastError());
1051     return ret;
1052 }
1053
1054 static BOOL CRYPT_AsnDecodeCRLEntry(const BYTE *pbEncoded, DWORD cbEncoded,
1055  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1056 {
1057     BOOL ret;
1058     struct AsnDecodeSequenceItem items[] = {
1059      { ASN_INTEGER, offsetof(CRL_ENTRY, SerialNumber),
1060        CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), FALSE, TRUE,
1061        offsetof(CRL_ENTRY, SerialNumber.pbData), 0 },
1062      { 0, offsetof(CRL_ENTRY, RevocationDate),
1063        CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE, 0 },
1064      { ASN_SEQUENCEOF, offsetof(CRL_ENTRY, cExtension),
1065        CRYPT_AsnDecodeExtensionsInternal, sizeof(CERT_EXTENSIONS), TRUE, TRUE,
1066        offsetof(CRL_ENTRY, rgExtension), 0 },
1067     };
1068     PCRL_ENTRY entry = pvStructInfo;
1069
1070     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, entry,
1071      *pcbStructInfo);
1072
1073     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
1074      pbEncoded, cbEncoded, dwFlags, NULL, entry, pcbStructInfo, pcbDecoded,
1075      entry ? entry->SerialNumber.pbData : NULL);
1076     if (ret && entry && !entry->SerialNumber.cbData)
1077     {
1078         WARN("empty CRL entry serial number\n");
1079         SetLastError(CRYPT_E_ASN1_CORRUPT);
1080         ret = FALSE;
1081     }
1082     return ret;
1083 }
1084
1085 /* Warning: assumes pvStructInfo is a struct GenericArray whose rgItems has
1086  * been set prior to calling.
1087  */
1088 static BOOL CRYPT_AsnDecodeCRLEntries(const BYTE *pbEncoded, DWORD cbEncoded,
1089  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1090 {
1091     BOOL ret;
1092     struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1093      CRYPT_AsnDecodeCRLEntry, sizeof(CRL_ENTRY), TRUE,
1094      offsetof(CRL_ENTRY, SerialNumber.pbData) };
1095     struct GenericArray *entries = pvStructInfo;
1096
1097     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
1098      pvStructInfo, *pcbStructInfo, pcbDecoded);
1099
1100     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1101      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
1102      entries ? entries->rgItems : NULL);
1103     TRACE("Returning %d (%08x)\n", ret, GetLastError());
1104     return ret;
1105 }
1106
1107 static BOOL CRYPT_AsnDecodeCRLInfo(DWORD dwCertEncodingType,
1108  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1109  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1110 {
1111     struct AsnDecodeSequenceItem items[] = {
1112      { ASN_INTEGER, offsetof(CRL_INFO, dwVersion),
1113        CRYPT_AsnDecodeIntInternal, sizeof(DWORD), TRUE, FALSE, 0, 0 },
1114      { ASN_SEQUENCEOF, offsetof(CRL_INFO, SignatureAlgorithm),
1115        CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
1116        FALSE, TRUE, offsetof(CRL_INFO, SignatureAlgorithm.pszObjId), 0 },
1117      { 0, offsetof(CRL_INFO, Issuer), CRYPT_AsnDecodeDerBlob,
1118        sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CRL_INFO,
1119        Issuer.pbData) },
1120      { 0, offsetof(CRL_INFO, ThisUpdate), CRYPT_AsnDecodeChoiceOfTimeInternal,
1121        sizeof(FILETIME), FALSE, FALSE, 0 },
1122      { 0, offsetof(CRL_INFO, NextUpdate), CRYPT_AsnDecodeChoiceOfTimeInternal,
1123        sizeof(FILETIME), TRUE, FALSE, 0 },
1124      { ASN_SEQUENCEOF, offsetof(CRL_INFO, cCRLEntry),
1125        CRYPT_AsnDecodeCRLEntries, sizeof(struct GenericArray), TRUE, TRUE,
1126        offsetof(CRL_INFO, rgCRLEntry), 0 },
1127      { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CRL_INFO, cExtension),
1128        CRYPT_AsnDecodeCertExtensions, sizeof(CERT_EXTENSIONS), TRUE, TRUE,
1129        offsetof(CRL_INFO, rgExtension), 0 },
1130     };
1131     BOOL ret = TRUE;
1132
1133     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1134      pDecodePara, pvStructInfo, *pcbStructInfo);
1135
1136     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
1137      pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo,
1138      NULL, NULL);
1139
1140     TRACE("Returning %d (%08x)\n", ret, GetLastError());
1141     return ret;
1142 }
1143
1144 static BOOL WINAPI CRYPT_AsnDecodeCRL(DWORD dwCertEncodingType,
1145  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1146  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1147 {
1148     BOOL ret = FALSE;
1149
1150     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1151      pDecodePara, pvStructInfo, *pcbStructInfo);
1152
1153     __TRY
1154     {
1155         DWORD size = 0;
1156
1157         /* Unless told not to, first try to decode it as a signed crl. */
1158         if (!(dwFlags & CRYPT_DECODE_TO_BE_SIGNED_FLAG))
1159         {
1160             PCERT_SIGNED_CONTENT_INFO signedCrl = NULL;
1161
1162             ret = CRYPT_AsnDecodeCertSignedContent(dwCertEncodingType,
1163              X509_CERT, pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL,
1164              &signedCrl, &size);
1165             if (ret)
1166             {
1167                 size = 0;
1168                 ret = CRYPT_AsnDecodeCRLInfo(dwCertEncodingType,
1169                  X509_CERT_CRL_TO_BE_SIGNED, signedCrl->ToBeSigned.pbData,
1170                  signedCrl->ToBeSigned.cbData, dwFlags, pDecodePara,
1171                  pvStructInfo, pcbStructInfo);
1172                 LocalFree(signedCrl);
1173             }
1174         }
1175         /* Failing that, try it as an unsigned crl */
1176         if (!ret)
1177         {
1178             size = 0;
1179             ret = CRYPT_AsnDecodeCRLInfo(dwCertEncodingType,
1180              X509_CERT_CRL_TO_BE_SIGNED, pbEncoded, cbEncoded,
1181              dwFlags, pDecodePara, pvStructInfo, pcbStructInfo);
1182         }
1183     }
1184     __EXCEPT_PAGE_FAULT
1185     {
1186         SetLastError(STATUS_ACCESS_VIOLATION);
1187     }
1188     __ENDTRY
1189
1190     TRACE("Returning %d (%08x)\n", ret, GetLastError());
1191     return ret;
1192 }
1193
1194 static BOOL CRYPT_AsnDecodeOidIgnoreTag(const BYTE *pbEncoded, DWORD cbEncoded,
1195  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1196 {
1197     BOOL ret = TRUE;
1198     DWORD dataLen;
1199
1200     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1201      pvStructInfo, *pcbStructInfo);
1202
1203     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1204     {
1205         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1206         DWORD bytesNeeded = sizeof(LPSTR);
1207
1208         if (dataLen)
1209         {
1210             /* The largest possible string for the first two components
1211              * is 2.175 (= 2 * 40 + 175 = 255), so this is big enough.
1212              */
1213             char firstTwo[6];
1214             const BYTE *ptr;
1215
1216             snprintf(firstTwo, sizeof(firstTwo), "%d.%d",
1217              pbEncoded[1 + lenBytes] / 40,
1218              pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] / 40)
1219              * 40);
1220             bytesNeeded += strlen(firstTwo) + 1;
1221             for (ptr = pbEncoded + 2 + lenBytes; ret &&
1222              ptr - pbEncoded - 1 - lenBytes < dataLen; )
1223             {
1224                 /* large enough for ".4000000" */
1225                 char str[9];
1226                 int val = 0;
1227
1228                 while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1229                  (*ptr & 0x80))
1230                 {
1231                     val <<= 7;
1232                     val |= *ptr & 0x7f;
1233                     ptr++;
1234                 }
1235                 if (ptr - pbEncoded - 1 - lenBytes >= dataLen ||
1236                  (*ptr & 0x80))
1237                 {
1238                     SetLastError(CRYPT_E_ASN1_CORRUPT);
1239                     ret = FALSE;
1240                 }
1241                 else
1242                 {
1243                     val <<= 7;
1244                     val |= *ptr++;
1245                     snprintf(str, sizeof(str), ".%d", val);
1246                     bytesNeeded += strlen(str);
1247                 }
1248             }
1249         }
1250         if (pcbDecoded)
1251             *pcbDecoded = 1 + lenBytes + dataLen;
1252         if (!pvStructInfo)
1253             *pcbStructInfo = bytesNeeded;
1254         else if (*pcbStructInfo < bytesNeeded)
1255         {
1256             *pcbStructInfo = bytesNeeded;
1257             SetLastError(ERROR_MORE_DATA);
1258             ret = FALSE;
1259         }
1260         else
1261         {
1262             if (dataLen)
1263             {
1264                 const BYTE *ptr;
1265                 LPSTR pszObjId = *(LPSTR *)pvStructInfo;
1266
1267                 *pszObjId = 0;
1268                 sprintf(pszObjId, "%d.%d", pbEncoded[1 + lenBytes] / 40,
1269                  pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] /
1270                  40) * 40);
1271                 pszObjId += strlen(pszObjId);
1272                 for (ptr = pbEncoded + 2 + lenBytes; ret &&
1273                  ptr - pbEncoded - 1 - lenBytes < dataLen; )
1274                 {
1275                     int val = 0;
1276
1277                     while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1278                      (*ptr & 0x80))
1279                     {
1280                         val <<= 7;
1281                         val |= *ptr & 0x7f;
1282                         ptr++;
1283                     }
1284                     val <<= 7;
1285                     val |= *ptr++;
1286                     sprintf(pszObjId, ".%d", val);
1287                     pszObjId += strlen(pszObjId);
1288                 }
1289             }
1290             else
1291                 *(LPSTR *)pvStructInfo = NULL;
1292             *pcbStructInfo = bytesNeeded;
1293         }
1294     }
1295     return ret;
1296 }
1297
1298 static BOOL CRYPT_AsnDecodeOidInternal(const BYTE *pbEncoded, DWORD cbEncoded,
1299  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1300 {
1301     BOOL ret;
1302
1303     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1304      pvStructInfo, *pcbStructInfo);
1305
1306     if (pbEncoded[0] == ASN_OBJECTIDENTIFIER)
1307         ret = CRYPT_AsnDecodeOidIgnoreTag(pbEncoded, cbEncoded, dwFlags,
1308          pvStructInfo, pcbStructInfo, pcbDecoded);
1309     else
1310     {
1311         SetLastError(CRYPT_E_ASN1_BADTAG);
1312         ret = FALSE;
1313     }
1314     return ret;
1315 }
1316
1317 /* Warning:  assumes pvStructInfo is a CERT_EXTENSION whose pszObjId is set
1318  * ahead of time!
1319  */
1320 static BOOL CRYPT_AsnDecodeExtension(const BYTE *pbEncoded, DWORD cbEncoded,
1321  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1322 {
1323     struct AsnDecodeSequenceItem items[] = {
1324      { ASN_OBJECTIDENTIFIER, offsetof(CERT_EXTENSION, pszObjId),
1325        CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
1326        offsetof(CERT_EXTENSION, pszObjId), 0 },
1327      { ASN_BOOL, offsetof(CERT_EXTENSION, fCritical), CRYPT_AsnDecodeBool,
1328        sizeof(BOOL), TRUE, FALSE, 0, 0 },
1329      { ASN_OCTETSTRING, offsetof(CERT_EXTENSION, Value),
1330        CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_OBJID_BLOB), FALSE, TRUE,
1331        offsetof(CERT_EXTENSION, Value.pbData) },
1332     };
1333     BOOL ret = TRUE;
1334     PCERT_EXTENSION ext = pvStructInfo;
1335
1336     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, ext,
1337      *pcbStructInfo);
1338
1339     if (ext)
1340         TRACE("ext->pszObjId is %p\n", ext->pszObjId);
1341     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
1342      pbEncoded, cbEncoded, dwFlags, NULL, ext, pcbStructInfo,
1343      pcbDecoded, ext ? ext->pszObjId : NULL);
1344     if (ext)
1345         TRACE("ext->pszObjId is %p (%s)\n", ext->pszObjId,
1346          debugstr_a(ext->pszObjId));
1347     TRACE("returning %d (%08x)\n", ret, GetLastError());
1348     return ret;
1349 }
1350
1351 static BOOL CRYPT_AsnDecodeExtensionsInternal(const BYTE *pbEncoded,
1352  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1353  DWORD *pcbDecoded)
1354 {
1355     BOOL ret = TRUE;
1356     struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1357      CRYPT_AsnDecodeExtension, sizeof(CERT_EXTENSION), TRUE,
1358      offsetof(CERT_EXTENSION, pszObjId) };
1359     PCERT_EXTENSIONS exts = pvStructInfo;
1360
1361     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
1362      pvStructInfo, *pcbStructInfo, pcbDecoded);
1363
1364     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1365      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
1366      exts ? exts->rgExtension : NULL);
1367     return ret;
1368 }
1369
1370 static BOOL WINAPI CRYPT_AsnDecodeExtensions(DWORD dwCertEncodingType,
1371  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1372  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1373 {
1374     BOOL ret = TRUE;
1375
1376     __TRY
1377     {
1378         ret = CRYPT_AsnDecodeExtensionsInternal(pbEncoded, cbEncoded,
1379          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
1380         if (ret && pvStructInfo)
1381         {
1382             ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
1383              pcbStructInfo, *pcbStructInfo);
1384             if (ret)
1385             {
1386                 CERT_EXTENSIONS *exts;
1387
1388                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
1389                     pvStructInfo = *(BYTE **)pvStructInfo;
1390                 exts = pvStructInfo;
1391                 exts->rgExtension = (CERT_EXTENSION *)((BYTE *)exts +
1392                  sizeof(CERT_EXTENSIONS));
1393                 ret = CRYPT_AsnDecodeExtensionsInternal(pbEncoded, cbEncoded,
1394                  dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
1395                  pcbStructInfo, NULL);
1396             }
1397         }
1398     }
1399     __EXCEPT_PAGE_FAULT
1400     {
1401         SetLastError(STATUS_ACCESS_VIOLATION);
1402         ret = FALSE;
1403     }
1404     __ENDTRY
1405     return ret;
1406 }
1407
1408 /* Warning: this assumes the address of value->Value.pbData is already set, in
1409  * order to avoid overwriting memory.  (In some cases, it may change it, if it
1410  * doesn't copy anything to memory.)  Be sure to set it correctly!
1411  */
1412 static BOOL CRYPT_AsnDecodeNameValueInternal(const BYTE *pbEncoded,
1413  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1414  DWORD *pcbDecoded)
1415 {
1416     BOOL ret = TRUE;
1417     DWORD dataLen;
1418     CERT_NAME_VALUE *value = pvStructInfo;
1419
1420     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1421     {
1422         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1423         DWORD bytesNeeded = sizeof(CERT_NAME_VALUE), valueType;
1424
1425         switch (pbEncoded[0])
1426         {
1427         case ASN_OCTETSTRING:
1428             valueType = CERT_RDN_OCTET_STRING;
1429             if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1430                 bytesNeeded += dataLen;
1431             break;
1432         case ASN_NUMERICSTRING:
1433             valueType = CERT_RDN_NUMERIC_STRING;
1434             if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1435                 bytesNeeded += dataLen;
1436             break;
1437         case ASN_PRINTABLESTRING:
1438             valueType = CERT_RDN_PRINTABLE_STRING;
1439             if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1440                 bytesNeeded += dataLen;
1441             break;
1442         case ASN_IA5STRING:
1443             valueType = CERT_RDN_IA5_STRING;
1444             if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1445                 bytesNeeded += dataLen;
1446             break;
1447         case ASN_T61STRING:
1448             valueType = CERT_RDN_T61_STRING;
1449             if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1450                 bytesNeeded += dataLen;
1451             break;
1452         case ASN_VIDEOTEXSTRING:
1453             valueType = CERT_RDN_VIDEOTEX_STRING;
1454             if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1455                 bytesNeeded += dataLen;
1456             break;
1457         case ASN_GRAPHICSTRING:
1458             valueType = CERT_RDN_GRAPHIC_STRING;
1459             if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1460                 bytesNeeded += dataLen;
1461             break;
1462         case ASN_VISIBLESTRING:
1463             valueType = CERT_RDN_VISIBLE_STRING;
1464             if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1465                 bytesNeeded += dataLen;
1466             break;
1467         case ASN_GENERALSTRING:
1468             valueType = CERT_RDN_GENERAL_STRING;
1469             if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1470                 bytesNeeded += dataLen;
1471             break;
1472         case ASN_UNIVERSALSTRING:
1473             FIXME("ASN_UNIVERSALSTRING: unimplemented\n");
1474             SetLastError(CRYPT_E_ASN1_BADTAG);
1475             return FALSE;
1476         case ASN_BMPSTRING:
1477             valueType = CERT_RDN_BMP_STRING;
1478             bytesNeeded += dataLen;
1479             break;
1480         case ASN_UTF8STRING:
1481             valueType = CERT_RDN_UTF8_STRING;
1482             bytesNeeded += MultiByteToWideChar(CP_UTF8, 0,
1483              (LPCSTR)pbEncoded + 1 + lenBytes, dataLen, NULL, 0) * 2;
1484             break;
1485         default:
1486             SetLastError(CRYPT_E_ASN1_BADTAG);
1487             return FALSE;
1488         }
1489
1490         if (pcbDecoded)
1491             *pcbDecoded = 1 + lenBytes + dataLen;
1492         if (!value)
1493             *pcbStructInfo = bytesNeeded;
1494         else if (*pcbStructInfo < bytesNeeded)
1495         {
1496             *pcbStructInfo = bytesNeeded;
1497             SetLastError(ERROR_MORE_DATA);
1498             ret = FALSE;
1499         }
1500         else
1501         {
1502             *pcbStructInfo = bytesNeeded;
1503             value->dwValueType = valueType;
1504             if (dataLen)
1505             {
1506                 DWORD i;
1507
1508                 assert(value->Value.pbData);
1509                 switch (pbEncoded[0])
1510                 {
1511                 case ASN_OCTETSTRING:
1512                 case ASN_NUMERICSTRING:
1513                 case ASN_PRINTABLESTRING:
1514                 case ASN_IA5STRING:
1515                 case ASN_T61STRING:
1516                 case ASN_VIDEOTEXSTRING:
1517                 case ASN_GRAPHICSTRING:
1518                 case ASN_VISIBLESTRING:
1519                 case ASN_GENERALSTRING:
1520                     value->Value.cbData = dataLen;
1521                     if (dataLen)
1522                     {
1523                         if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1524                             memcpy(value->Value.pbData,
1525                              pbEncoded + 1 + lenBytes, dataLen);
1526                         else
1527                             value->Value.pbData = (LPBYTE)pbEncoded + 1 +
1528                              lenBytes;
1529                     }
1530                     break;
1531                 case ASN_BMPSTRING:
1532                 {
1533                     LPWSTR str = (LPWSTR)value->Value.pbData;
1534
1535                     value->Value.cbData = dataLen;
1536                     for (i = 0; i < dataLen / 2; i++)
1537                         str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
1538                          pbEncoded[1 + lenBytes + 2 * i + 1];
1539                     break;
1540                 }
1541                 case ASN_UTF8STRING:
1542                 {
1543                     LPWSTR str = (LPWSTR)value->Value.pbData;
1544
1545                     value->Value.cbData = MultiByteToWideChar(CP_UTF8, 0,
1546                      (LPCSTR)pbEncoded + 1 + lenBytes, dataLen,
1547                      str, bytesNeeded - sizeof(CERT_NAME_VALUE)) * 2;
1548                     break;
1549                 }
1550                 }
1551             }
1552             else
1553             {
1554                 value->Value.cbData = 0;
1555                 value->Value.pbData = NULL;
1556             }
1557         }
1558     }
1559     return ret;
1560 }
1561
1562 static BOOL WINAPI CRYPT_AsnDecodeNameValue(DWORD dwCertEncodingType,
1563  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1564  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1565 {
1566     BOOL ret = TRUE;
1567
1568     __TRY
1569     {
1570         ret = CRYPT_AsnDecodeNameValueInternal(pbEncoded, cbEncoded,
1571          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
1572         if (ret && pvStructInfo)
1573         {
1574             ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
1575              pcbStructInfo, *pcbStructInfo);
1576             if (ret)
1577             {
1578                 CERT_NAME_VALUE *value;
1579
1580                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
1581                     pvStructInfo = *(BYTE **)pvStructInfo;
1582                 value = pvStructInfo;
1583                 value->Value.pbData = ((BYTE *)value + sizeof(CERT_NAME_VALUE));
1584                 ret = CRYPT_AsnDecodeNameValueInternal( pbEncoded, cbEncoded,
1585                  dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
1586                  pcbStructInfo, NULL);
1587             }
1588         }
1589     }
1590     __EXCEPT_PAGE_FAULT
1591     {
1592         SetLastError(STATUS_ACCESS_VIOLATION);
1593         ret = FALSE;
1594     }
1595     __ENDTRY
1596     return ret;
1597 }
1598
1599 static BOOL CRYPT_AsnDecodeUnicodeNameValueInternal(const BYTE *pbEncoded,
1600  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1601  DWORD *pcbDecoded)
1602 {
1603     BOOL ret = TRUE;
1604     DWORD dataLen;
1605     CERT_NAME_VALUE *value = pvStructInfo;
1606
1607     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1608     {
1609         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1610         DWORD bytesNeeded = sizeof(CERT_NAME_VALUE), valueType;
1611
1612         switch (pbEncoded[0])
1613         {
1614         case ASN_NUMERICSTRING:
1615             valueType = CERT_RDN_NUMERIC_STRING;
1616             if (dataLen)
1617                 bytesNeeded += (dataLen + 1) * 2;
1618             break;
1619         case ASN_PRINTABLESTRING:
1620             valueType = CERT_RDN_PRINTABLE_STRING;
1621             if (dataLen)
1622                 bytesNeeded += (dataLen + 1) * 2;
1623             break;
1624         case ASN_IA5STRING:
1625             valueType = CERT_RDN_IA5_STRING;
1626             if (dataLen)
1627                 bytesNeeded += (dataLen + 1) * 2;
1628             break;
1629         case ASN_T61STRING:
1630             valueType = CERT_RDN_T61_STRING;
1631             if (dataLen)
1632                 bytesNeeded += (dataLen + 1) * 2;
1633             break;
1634         case ASN_VIDEOTEXSTRING:
1635             valueType = CERT_RDN_VIDEOTEX_STRING;
1636             if (dataLen)
1637                 bytesNeeded += (dataLen + 1) * 2;
1638             break;
1639         case ASN_GRAPHICSTRING:
1640             valueType = CERT_RDN_GRAPHIC_STRING;
1641             if (dataLen)
1642                 bytesNeeded += (dataLen + 1) * 2;
1643             break;
1644         case ASN_VISIBLESTRING:
1645             valueType = CERT_RDN_VISIBLE_STRING;
1646             if (dataLen)
1647                 bytesNeeded += (dataLen + 1) * 2;
1648             break;
1649         case ASN_GENERALSTRING:
1650             valueType = CERT_RDN_GENERAL_STRING;
1651             if (dataLen)
1652                 bytesNeeded += (dataLen + 1) * 2;
1653             break;
1654         case ASN_UNIVERSALSTRING:
1655             valueType = CERT_RDN_UNIVERSAL_STRING;
1656             if (dataLen)
1657                 bytesNeeded += dataLen / 2 + sizeof(WCHAR);
1658             break;
1659         case ASN_BMPSTRING:
1660             valueType = CERT_RDN_BMP_STRING;
1661             if (dataLen)
1662                 bytesNeeded += dataLen + sizeof(WCHAR);
1663             break;
1664         case ASN_UTF8STRING:
1665             valueType = CERT_RDN_UTF8_STRING;
1666             if (dataLen)
1667                 bytesNeeded += (MultiByteToWideChar(CP_UTF8, 0,
1668                  (LPCSTR)pbEncoded + 1 + lenBytes, dataLen, NULL, 0) + 1) * 2;
1669             break;
1670         default:
1671             SetLastError(CRYPT_E_ASN1_BADTAG);
1672             return FALSE;
1673         }
1674
1675         if (pcbDecoded)
1676             *pcbDecoded = 1 + lenBytes + dataLen;
1677         if (!value)
1678             *pcbStructInfo = bytesNeeded;
1679         else if (*pcbStructInfo < bytesNeeded)
1680         {
1681             *pcbStructInfo = bytesNeeded;
1682             SetLastError(ERROR_MORE_DATA);
1683             ret = FALSE;
1684         }
1685         else
1686         {
1687             *pcbStructInfo = bytesNeeded;
1688             value->dwValueType = valueType;
1689             if (dataLen)
1690             {
1691                 DWORD i;
1692                 LPWSTR str = (LPWSTR)value->Value.pbData;
1693
1694                 assert(value->Value.pbData);
1695                 switch (pbEncoded[0])
1696                 {
1697                 case ASN_NUMERICSTRING:
1698                 case ASN_PRINTABLESTRING:
1699                 case ASN_IA5STRING:
1700                 case ASN_T61STRING:
1701                 case ASN_VIDEOTEXSTRING:
1702                 case ASN_GRAPHICSTRING:
1703                 case ASN_VISIBLESTRING:
1704                 case ASN_GENERALSTRING:
1705                     value->Value.cbData = dataLen * 2;
1706                     for (i = 0; i < dataLen; i++)
1707                         str[i] = pbEncoded[1 + lenBytes + i];
1708                     str[i] = 0;
1709                     break;
1710                 case ASN_UNIVERSALSTRING:
1711                     value->Value.cbData = dataLen / 2;
1712                     for (i = 0; i < dataLen / 4; i++)
1713                         str[i] = (pbEncoded[1 + lenBytes + 2 * i + 2] << 8)
1714                          | pbEncoded[1 + lenBytes + 2 * i + 3];
1715                     str[i] = 0;
1716                     break;
1717                 case ASN_BMPSTRING:
1718                     value->Value.cbData = dataLen;
1719                     for (i = 0; i < dataLen / 2; i++)
1720                         str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
1721                          pbEncoded[1 + lenBytes + 2 * i + 1];
1722                     str[i] = 0;
1723                     break;
1724                 case ASN_UTF8STRING:
1725                     value->Value.cbData = MultiByteToWideChar(CP_UTF8, 0,
1726                      (LPCSTR)pbEncoded + 1 + lenBytes, dataLen,
1727                      str, bytesNeeded - sizeof(CERT_NAME_VALUE)) * 2;
1728                     value->Value.pbData[value->Value.cbData / sizeof(WCHAR)]
1729                      = 0;
1730                     value->Value.cbData += sizeof(WCHAR);
1731                     break;
1732                 }
1733             }
1734             else
1735             {
1736                 value->Value.cbData = 0;
1737                 value->Value.pbData = NULL;
1738             }
1739         }
1740     }
1741     return ret;
1742 }
1743
1744 static BOOL WINAPI CRYPT_AsnDecodeUnicodeNameValue(DWORD dwCertEncodingType,
1745  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1746  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1747 {
1748     BOOL ret = TRUE;
1749
1750     __TRY
1751     {
1752         ret = CRYPT_AsnDecodeUnicodeNameValueInternal(pbEncoded, cbEncoded,
1753          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
1754         if (ret && pvStructInfo)
1755         {
1756             ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
1757              pcbStructInfo, *pcbStructInfo);
1758             if (ret)
1759             {
1760                 CERT_NAME_VALUE *value;
1761
1762                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
1763                     pvStructInfo = *(BYTE **)pvStructInfo;
1764                 value = pvStructInfo;
1765                 value->Value.pbData = ((BYTE *)value + sizeof(CERT_NAME_VALUE));
1766                 ret = CRYPT_AsnDecodeUnicodeNameValueInternal(pbEncoded,
1767                  cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
1768                  pcbStructInfo, NULL);
1769             }
1770         }
1771     }
1772     __EXCEPT_PAGE_FAULT
1773     {
1774         SetLastError(STATUS_ACCESS_VIOLATION);
1775         ret = FALSE;
1776     }
1777     __ENDTRY
1778     return ret;
1779 }
1780
1781 static BOOL CRYPT_AsnDecodeRdnAttr(const BYTE *pbEncoded, DWORD cbEncoded,
1782  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1783 {
1784     BOOL ret;
1785     struct AsnDecodeSequenceItem items[] = {
1786      { ASN_OBJECTIDENTIFIER, offsetof(CERT_RDN_ATTR, pszObjId),
1787        CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
1788        offsetof(CERT_RDN_ATTR, pszObjId), 0 },
1789      { 0, offsetof(CERT_RDN_ATTR, dwValueType),
1790        CRYPT_AsnDecodeNameValueInternal, sizeof(CERT_NAME_VALUE),
1791        FALSE, TRUE, offsetof(CERT_RDN_ATTR, Value.pbData), 0 },
1792     };
1793     CERT_RDN_ATTR *attr = pvStructInfo;
1794
1795     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1796      pvStructInfo, *pcbStructInfo);
1797
1798     if (attr)
1799         TRACE("attr->pszObjId is %p\n", attr->pszObjId);
1800     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
1801      pbEncoded, cbEncoded, dwFlags, NULL, attr, pcbStructInfo, pcbDecoded,
1802      attr ? attr->pszObjId : NULL);
1803     if (attr)
1804     {
1805         TRACE("attr->pszObjId is %p (%s)\n", attr->pszObjId,
1806          debugstr_a(attr->pszObjId));
1807         TRACE("attr->dwValueType is %d\n", attr->dwValueType);
1808     }
1809     TRACE("returning %d (%08x)\n", ret, GetLastError());
1810     return ret;
1811 }
1812
1813 static BOOL CRYPT_AsnDecodeRdn(const BYTE *pbEncoded, DWORD cbEncoded,
1814  DWORD dwFlags,  void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1815 {
1816     BOOL ret = TRUE;
1817     struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
1818      CRYPT_AsnDecodeRdnAttr, sizeof(CERT_RDN_ATTR), TRUE,
1819      offsetof(CERT_RDN_ATTR, pszObjId) };
1820     PCERT_RDN rdn = pvStructInfo;
1821
1822     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1823      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
1824      rdn ? rdn->rgRDNAttr : NULL);
1825     return ret;
1826 }
1827
1828 static BOOL WINAPI CRYPT_AsnDecodeName(DWORD dwCertEncodingType,
1829  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1830  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1831 {
1832     BOOL ret = TRUE;
1833
1834     __TRY
1835     {
1836         struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1837          CRYPT_AsnDecodeRdn, sizeof(CERT_RDN), TRUE,
1838          offsetof(CERT_RDN, rgRDNAttr) };
1839
1840         ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1841          pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
1842     }
1843     __EXCEPT_PAGE_FAULT
1844     {
1845         SetLastError(STATUS_ACCESS_VIOLATION);
1846         ret = FALSE;
1847     }
1848     __ENDTRY
1849     return ret;
1850 }
1851
1852 static BOOL CRYPT_AsnDecodeUnicodeRdnAttr(const BYTE *pbEncoded,
1853  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1854  DWORD *pcbDecoded)
1855 {
1856     BOOL ret;
1857     struct AsnDecodeSequenceItem items[] = {
1858      { ASN_OBJECTIDENTIFIER, offsetof(CERT_RDN_ATTR, pszObjId),
1859        CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
1860        offsetof(CERT_RDN_ATTR, pszObjId), 0 },
1861      { 0, offsetof(CERT_RDN_ATTR, dwValueType),
1862        CRYPT_AsnDecodeUnicodeNameValueInternal, sizeof(CERT_NAME_VALUE),
1863        FALSE, TRUE, offsetof(CERT_RDN_ATTR, Value.pbData), 0 },
1864     };
1865     CERT_RDN_ATTR *attr = pvStructInfo;
1866
1867     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1868      pvStructInfo, *pcbStructInfo);
1869
1870     if (attr)
1871         TRACE("attr->pszObjId is %p\n", attr->pszObjId);
1872     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
1873      pbEncoded, cbEncoded, dwFlags, NULL, attr, pcbStructInfo, pcbDecoded,
1874      attr ? attr->pszObjId : NULL);
1875     if (attr)
1876     {
1877         TRACE("attr->pszObjId is %p (%s)\n", attr->pszObjId,
1878          debugstr_a(attr->pszObjId));
1879         TRACE("attr->dwValueType is %d\n", attr->dwValueType);
1880     }
1881     TRACE("returning %d (%08x)\n", ret, GetLastError());
1882     return ret;
1883 }
1884
1885 static BOOL CRYPT_AsnDecodeUnicodeRdn(const BYTE *pbEncoded, DWORD cbEncoded,
1886  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
1887 {
1888     BOOL ret = TRUE;
1889     struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
1890      CRYPT_AsnDecodeUnicodeRdnAttr, sizeof(CERT_RDN_ATTR), TRUE,
1891      offsetof(CERT_RDN_ATTR, pszObjId) };
1892     PCERT_RDN rdn = pvStructInfo;
1893
1894     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1895      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
1896      rdn ? rdn->rgRDNAttr : NULL);
1897     return ret;
1898 }
1899
1900 static BOOL WINAPI CRYPT_AsnDecodeUnicodeName(DWORD dwCertEncodingType,
1901  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1902  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
1903 {
1904     BOOL ret = TRUE;
1905
1906     __TRY
1907     {
1908         struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1909          CRYPT_AsnDecodeUnicodeRdn, sizeof(CERT_RDN), TRUE,
1910          offsetof(CERT_RDN, rgRDNAttr) };
1911
1912         ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1913          pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
1914     }
1915     __EXCEPT_PAGE_FAULT
1916     {
1917         SetLastError(STATUS_ACCESS_VIOLATION);
1918         ret = FALSE;
1919     }
1920     __ENDTRY
1921     return ret;
1922 }
1923
1924 static BOOL CRYPT_FindEncodedLen(const BYTE *pbEncoded, DWORD cbEncoded,
1925  DWORD *pcbDecoded)
1926 {
1927     BOOL ret = TRUE, done = FALSE;
1928     DWORD indefiniteNestingLevels = 0, decoded = 0;
1929
1930     TRACE("(%p, %d)\n", pbEncoded, cbEncoded);
1931
1932     do {
1933         DWORD dataLen;
1934
1935         if (!cbEncoded)
1936             done = TRUE;
1937         else if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded,
1938          &dataLen)))
1939         {
1940             BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1941
1942             if (dataLen == CMSG_INDEFINITE_LENGTH)
1943             {
1944                 indefiniteNestingLevels++;
1945                 pbEncoded += 1 + lenBytes;
1946                 cbEncoded -= 1 + lenBytes;
1947                 decoded += 1 + lenBytes;
1948                 TRACE("indefiniteNestingLevels = %d\n",
1949                  indefiniteNestingLevels);
1950             }
1951             else
1952             {
1953                 if (pbEncoded[0] == 0 && pbEncoded[1] == 0 &&
1954                  indefiniteNestingLevels)
1955                 {
1956                     indefiniteNestingLevels--;
1957                     TRACE("indefiniteNestingLevels = %d\n",
1958                      indefiniteNestingLevels);
1959                 }
1960                 pbEncoded += 1 + lenBytes + dataLen;
1961                 cbEncoded -= 1 + lenBytes + dataLen;
1962                 decoded += 1 + lenBytes + dataLen;
1963                 if (!indefiniteNestingLevels)
1964                     done = TRUE;
1965             }
1966         }
1967     } while (ret && !done);
1968     /* If we haven't found all 0 TLVs, we haven't found the end */
1969     if (ret && indefiniteNestingLevels)
1970     {
1971         SetLastError(CRYPT_E_ASN1_EOD);
1972         ret = FALSE;
1973     }
1974     if (ret)
1975         *pcbDecoded = decoded;
1976     TRACE("returning %d (%d)\n", ret, ret ? *pcbDecoded : 0);
1977     return ret;
1978 }
1979
1980 static BOOL CRYPT_AsnDecodeCopyBytes(const BYTE *pbEncoded,
1981  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1982  DWORD *pcbDecoded)
1983 {
1984     BOOL ret = TRUE;
1985     DWORD bytesNeeded = sizeof(CRYPT_OBJID_BLOB), encodedLen = 0;
1986
1987     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1988      pvStructInfo, *pcbStructInfo);
1989
1990     if ((ret = CRYPT_FindEncodedLen(pbEncoded, cbEncoded, &encodedLen)))
1991     {
1992         if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1993             bytesNeeded += encodedLen;
1994         if (!pvStructInfo)
1995             *pcbStructInfo = bytesNeeded;
1996         else if (*pcbStructInfo < bytesNeeded)
1997         {
1998             SetLastError(ERROR_MORE_DATA);
1999             *pcbStructInfo = bytesNeeded;
2000             ret = FALSE;
2001         }
2002         else
2003         {
2004             PCRYPT_OBJID_BLOB blob = pvStructInfo;
2005
2006             *pcbStructInfo = bytesNeeded;
2007             blob->cbData = encodedLen;
2008             if (encodedLen)
2009             {
2010                 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
2011                     blob->pbData = (LPBYTE)pbEncoded;
2012                 else
2013                 {
2014                     assert(blob->pbData);
2015                     memcpy(blob->pbData, pbEncoded, blob->cbData);
2016                 }
2017             }
2018             else
2019                 blob->pbData = NULL;
2020         }
2021         if (pcbDecoded)
2022             *pcbDecoded = encodedLen;
2023     }
2024     return ret;
2025 }
2026
2027 static BOOL CRYPT_DecodeDERArray(const BYTE *pbEncoded, DWORD cbEncoded,
2028  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2029 {
2030     BOOL ret;
2031     struct AsnArrayDescriptor arrayDesc = { 0, CRYPT_AsnDecodeCopyBytes,
2032      sizeof(CRYPT_DER_BLOB), TRUE, offsetof(CRYPT_DER_BLOB, pbData) };
2033     struct GenericArray *array = pvStructInfo;
2034
2035     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
2036      pvStructInfo, *pcbStructInfo, pcbDecoded);
2037
2038     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2039      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2040      array ? array->rgItems : NULL);
2041     return ret;
2042 }
2043
2044 static BOOL CRYPT_AsnDecodeCTLUsage(const BYTE *pbEncoded, DWORD cbEncoded,
2045  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2046 {
2047     BOOL ret;
2048     struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2049      CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), TRUE, 0 };
2050     CTL_USAGE *usage = pvStructInfo;
2051
2052     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2053      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2054      usage ? usage->rgpszUsageIdentifier : NULL);
2055     return ret;
2056 }
2057
2058 static BOOL CRYPT_AsnDecodeCTLEntry(const BYTE *pbEncoded, DWORD cbEncoded,
2059  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2060 {
2061     struct AsnDecodeSequenceItem items[] = {
2062      { ASN_OCTETSTRING, offsetof(CTL_ENTRY, SubjectIdentifier),
2063        CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_DATA_BLOB), FALSE, TRUE,
2064        offsetof(CTL_ENTRY, SubjectIdentifier.pbData), 0 },
2065      { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CTL_ENTRY, cAttribute),
2066        CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES), FALSE,
2067        TRUE, offsetof(CTL_ENTRY, rgAttribute), 0 },
2068     };
2069     BOOL ret = TRUE;
2070     CTL_ENTRY *entry = pvStructInfo;
2071
2072     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, entry,
2073      *pcbStructInfo);
2074
2075     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2076      pbEncoded, cbEncoded, dwFlags, NULL, entry, pcbStructInfo,
2077      pcbDecoded, entry ? entry->SubjectIdentifier.pbData : NULL);
2078     return ret;
2079 }
2080
2081 static BOOL CRYPT_AsnDecodeCTLEntries(const BYTE *pbEncoded, DWORD cbEncoded,
2082  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2083 {
2084     BOOL ret;
2085     struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2086      CRYPT_AsnDecodeCTLEntry, sizeof(CTL_ENTRY), TRUE,
2087      offsetof(CTL_ENTRY, SubjectIdentifier.pbData) };
2088     struct GenericArray *entries = pvStructInfo;
2089
2090     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
2091      pvStructInfo, *pcbStructInfo, pcbDecoded);
2092
2093     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2094      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2095      entries ? entries->rgItems : NULL);
2096     return ret;
2097 }
2098
2099 static BOOL WINAPI CRYPT_AsnDecodeCTL(DWORD dwCertEncodingType,
2100  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2101  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
2102 {
2103     BOOL ret = FALSE;
2104
2105     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2106      pDecodePara, pvStructInfo, *pcbStructInfo);
2107
2108     __TRY
2109     {
2110         struct AsnDecodeSequenceItem items[] = {
2111          { ASN_INTEGER, offsetof(CTL_INFO, dwVersion),
2112            CRYPT_AsnDecodeIntInternal, sizeof(DWORD), TRUE, FALSE, 0, 0 },
2113          { ASN_SEQUENCEOF, offsetof(CTL_INFO, SubjectUsage),
2114            CRYPT_AsnDecodeCTLUsage, sizeof(CTL_USAGE), FALSE, TRUE,
2115            offsetof(CTL_INFO, SubjectUsage.rgpszUsageIdentifier), 0 },
2116          { ASN_OCTETSTRING, offsetof(CTL_INFO, ListIdentifier),
2117            CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_DATA_BLOB), TRUE,
2118            TRUE, offsetof(CTL_INFO, ListIdentifier.pbData), 0 },
2119          { ASN_INTEGER, offsetof(CTL_INFO, SequenceNumber),
2120            CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
2121            TRUE, TRUE, offsetof(CTL_INFO, SequenceNumber.pbData), 0 },
2122          { 0, offsetof(CTL_INFO, ThisUpdate),
2123            CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE,
2124            0 },
2125          { 0, offsetof(CTL_INFO, NextUpdate),
2126            CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), TRUE, FALSE,
2127            0 },
2128          { ASN_SEQUENCEOF, offsetof(CTL_INFO, SubjectAlgorithm),
2129            CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
2130            FALSE, TRUE, offsetof(CTL_INFO, SubjectAlgorithm.pszObjId), 0 },
2131          { ASN_SEQUENCEOF, offsetof(CTL_INFO, cCTLEntry),
2132            CRYPT_AsnDecodeCTLEntries, sizeof(struct GenericArray),
2133            TRUE, TRUE, offsetof(CTL_INFO, rgCTLEntry), 0 },
2134          { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CTL_INFO, cExtension),
2135            CRYPT_AsnDecodeCertExtensions, sizeof(CERT_EXTENSIONS), TRUE, TRUE,
2136            offsetof(CTL_INFO, rgExtension), 0 },
2137         };
2138
2139         TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2140          pDecodePara, pvStructInfo, *pcbStructInfo);
2141
2142         ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2143          pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
2144          pcbStructInfo, NULL, NULL);
2145     }
2146     __EXCEPT_PAGE_FAULT
2147     {
2148         SetLastError(STATUS_ACCESS_VIOLATION);
2149     }
2150     __ENDTRY
2151     return ret;
2152 }
2153
2154 static BOOL CRYPT_AsnDecodeSMIMECapability(const BYTE *pbEncoded,
2155  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2156  DWORD *pcbDecoded)
2157 {
2158     BOOL ret;
2159     struct AsnDecodeSequenceItem items[] = {
2160      { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_SMIME_CAPABILITY, pszObjId),
2161        CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2162        offsetof(CRYPT_SMIME_CAPABILITY, pszObjId), 0 },
2163      { 0, offsetof(CRYPT_SMIME_CAPABILITY, Parameters),
2164        CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
2165        offsetof(CRYPT_SMIME_CAPABILITY, Parameters.pbData), 0 },
2166     };
2167     PCRYPT_SMIME_CAPABILITY capability = pvStructInfo;
2168
2169     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2170      pvStructInfo, *pcbStructInfo);
2171
2172     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2173      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2174      pcbDecoded, capability ? capability->pszObjId : NULL);
2175     TRACE("returning %d\n", ret);
2176     return ret;
2177 }
2178
2179 static BOOL CRYPT_AsnDecodeSMIMECapabilitiesInternal(const BYTE *pbEncoded,
2180  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2181  DWORD *pcbDecoded)
2182 {
2183     struct AsnArrayDescriptor arrayDesc = { 0,
2184      CRYPT_AsnDecodeSMIMECapability, sizeof(CRYPT_SMIME_CAPABILITY), TRUE,
2185      offsetof(CRYPT_SMIME_CAPABILITY, pszObjId) };
2186     PCRYPT_SMIME_CAPABILITIES capabilities = pvStructInfo;
2187     BOOL ret;
2188
2189     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2190      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2191      capabilities ? capabilities->rgCapability : NULL);
2192     return ret;
2193 }
2194
2195 static BOOL WINAPI CRYPT_AsnDecodeSMIMECapabilities(DWORD dwCertEncodingType,
2196  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2197  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
2198 {
2199     BOOL ret = FALSE;
2200
2201     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2202      pDecodePara, pvStructInfo, *pcbStructInfo);
2203
2204     __TRY
2205     {
2206         DWORD bytesNeeded;
2207
2208         if (!cbEncoded)
2209             SetLastError(CRYPT_E_ASN1_EOD);
2210         else if (pbEncoded[0] != ASN_SEQUENCEOF)
2211             SetLastError(CRYPT_E_ASN1_CORRUPT);
2212         else if ((ret = CRYPT_AsnDecodeSMIMECapabilitiesInternal(pbEncoded,
2213          cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded,
2214          NULL)))
2215         {
2216             if (!pvStructInfo)
2217                 *pcbStructInfo = bytesNeeded;
2218             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2219              pvStructInfo, pcbStructInfo, bytesNeeded)))
2220             {
2221                 PCRYPT_SMIME_CAPABILITIES capabilities;
2222
2223                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2224                     pvStructInfo = *(BYTE **)pvStructInfo;
2225                 capabilities = pvStructInfo;
2226                 capabilities->rgCapability =
2227                  (PCRYPT_SMIME_CAPABILITY)((BYTE *)pvStructInfo +
2228                  sizeof(CRYPT_SMIME_CAPABILITIES));
2229                 ret = CRYPT_AsnDecodeSMIMECapabilitiesInternal(pbEncoded,
2230                  cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
2231                  &bytesNeeded, NULL);
2232             }
2233         }
2234     }
2235     __EXCEPT_PAGE_FAULT
2236     {
2237         SetLastError(STATUS_ACCESS_VIOLATION);
2238     }
2239     __ENDTRY
2240     TRACE("returning %d\n", ret);
2241     return ret;
2242 }
2243
2244 static BOOL CRYPT_AsnDecodeIA5String(const BYTE *pbEncoded,
2245  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2246  DWORD *pcbDecoded)
2247 {
2248     BOOL ret = TRUE;
2249     DWORD dataLen;
2250     LPSTR *pStr = pvStructInfo;
2251
2252     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2253     {
2254         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2255         DWORD bytesNeeded = sizeof(LPSTR) + sizeof(char);
2256
2257         if (pbEncoded[0] != ASN_IA5STRING)
2258         {
2259             SetLastError(CRYPT_E_ASN1_CORRUPT);
2260             ret = FALSE;
2261         }
2262         else
2263         {
2264             bytesNeeded += dataLen;
2265             if (pcbDecoded)
2266                 *pcbDecoded = 1 + lenBytes + dataLen;
2267             if (!pvStructInfo)
2268                 *pcbStructInfo = bytesNeeded;
2269             else if (*pcbStructInfo < bytesNeeded)
2270             {
2271                 *pcbStructInfo = bytesNeeded;
2272                 SetLastError(ERROR_MORE_DATA);
2273                 ret = FALSE;
2274             }
2275             else
2276             {
2277                 *pcbStructInfo = bytesNeeded;
2278                 if (dataLen)
2279                 {
2280                     LPSTR str = *pStr;
2281
2282                     assert(str);
2283                     memcpy(str, pbEncoded + 1 + lenBytes, dataLen);
2284                     str[dataLen] = 0;
2285                 }
2286                 else
2287                     *pStr = NULL;
2288             }
2289         }
2290     }
2291     return ret;
2292 }
2293
2294 static BOOL CRYPT_AsnDecodeIntArray(const BYTE *pbEncoded,
2295  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2296  DWORD *pcbDecoded)
2297 {
2298     struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2299      CRYPT_AsnDecodeIntInternal, sizeof(int), FALSE, 0 };
2300     struct GenericArray *array = pvStructInfo;
2301     BOOL ret;
2302
2303     TRACE("(%p, %d, %08x, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
2304      pvStructInfo, pvStructInfo ? *pcbDecoded : 0);
2305
2306     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2307      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2308      array ? array->rgItems : NULL);
2309     TRACE("returning %d\n", ret);
2310     return ret;
2311 }
2312
2313 static BOOL CRYPT_AsnDecodeNoticeReference(const BYTE *pbEncoded,
2314  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2315  DWORD *pcbDecoded)
2316 {
2317     BOOL ret;
2318     struct AsnDecodeSequenceItem items[] = {
2319      { ASN_IA5STRING, offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
2320        pszOrganization), CRYPT_AsnDecodeIA5String, sizeof(LPSTR), FALSE, TRUE,
2321        offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, pszOrganization), 0 },
2322      { ASN_SEQUENCEOF, offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
2323        cNoticeNumbers), CRYPT_AsnDecodeIntArray, sizeof(struct GenericArray),
2324        FALSE, TRUE, offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
2325        rgNoticeNumbers), 0 },
2326     };
2327     DWORD bytesNeeded;
2328
2329     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2330      pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
2331
2332     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2333      pbEncoded, cbEncoded, dwFlags, NULL, NULL, &bytesNeeded, pcbDecoded,
2334      NULL);
2335     if (ret)
2336     {
2337         /* The caller is expecting a pointer to a
2338          * CERT_POLICY_QUALIFIER_NOTICE_REFERENCE to be decoded, whereas
2339          * CRYPT_AsnDecodeSequence is decoding a
2340          * CERT_POLICY_QUALIFIER_NOTICE_REFERENCE.  Increment the bytes
2341          * needed, and decode again if the requisite space is available.
2342          */
2343         bytesNeeded += sizeof(PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE);
2344         if (!pvStructInfo)
2345             *pcbStructInfo = bytesNeeded;
2346         else if (*pcbStructInfo < bytesNeeded)
2347         {
2348             *pcbStructInfo = bytesNeeded;
2349             SetLastError(ERROR_MORE_DATA);
2350             ret = FALSE;
2351         }
2352         else
2353         {
2354             PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE noticeRef;
2355
2356             *pcbStructInfo = bytesNeeded;
2357             /* The pointer (pvStructInfo) passed in points to the first dynamic
2358              * pointer, so use it as the pointer to the
2359              * CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, and create the
2360              * appropriate offset for the first dynamic pointer within the
2361              * notice reference by pointing to the first memory location past
2362              * the CERT_POLICY_QUALIFIER_NOTICE_REFERENCE.
2363              */
2364             noticeRef =
2365              *(PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE *)pvStructInfo;
2366             noticeRef->pszOrganization = (LPSTR)((LPBYTE)noticeRef +
2367              sizeof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE));
2368             ret = CRYPT_AsnDecodeSequence(items,
2369              sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2370              NULL, noticeRef, &bytesNeeded, pcbDecoded,
2371              noticeRef->pszOrganization);
2372         }
2373     }
2374     TRACE("returning %d\n", ret);
2375     return ret;
2376 }
2377
2378 static BOOL CRYPT_AsnDecodeUnicodeString(const BYTE *pbEncoded,
2379  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2380  DWORD *pcbDecoded)
2381 {
2382     BOOL ret = TRUE;
2383     DWORD dataLen;
2384
2385     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2386     {
2387         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2388         DWORD bytesNeeded = sizeof(LPWSTR);
2389
2390         switch (pbEncoded[0])
2391         {
2392         case ASN_NUMERICSTRING:
2393             if (dataLen)
2394                 bytesNeeded += (dataLen + 1) * 2;
2395             break;
2396         case ASN_PRINTABLESTRING:
2397             if (dataLen)
2398                 bytesNeeded += (dataLen + 1) * 2;
2399             break;
2400         case ASN_IA5STRING:
2401             if (dataLen)
2402                 bytesNeeded += (dataLen + 1) * 2;
2403             break;
2404         case ASN_T61STRING:
2405             if (dataLen)
2406                 bytesNeeded += (dataLen + 1) * 2;
2407             break;
2408         case ASN_VIDEOTEXSTRING:
2409             if (dataLen)
2410                 bytesNeeded += (dataLen + 1) * 2;
2411             break;
2412         case ASN_GRAPHICSTRING:
2413             if (dataLen)
2414                 bytesNeeded += (dataLen + 1) * 2;
2415             break;
2416         case ASN_VISIBLESTRING:
2417             if (dataLen)
2418                 bytesNeeded += (dataLen + 1) * 2;
2419             break;
2420         case ASN_GENERALSTRING:
2421             if (dataLen)
2422                 bytesNeeded += (dataLen + 1) * 2;
2423             break;
2424         case ASN_UNIVERSALSTRING:
2425             if (dataLen)
2426                 bytesNeeded += dataLen / 2 + sizeof(WCHAR);
2427             break;
2428         case ASN_BMPSTRING:
2429             if (dataLen)
2430                 bytesNeeded += dataLen + sizeof(WCHAR);
2431             break;
2432         case ASN_UTF8STRING:
2433             if (dataLen)
2434                 bytesNeeded += (MultiByteToWideChar(CP_UTF8, 0,
2435                  (LPCSTR)pbEncoded + 1 + lenBytes, dataLen, NULL, 0) + 1) * 2;
2436             break;
2437         default:
2438             SetLastError(CRYPT_E_ASN1_BADTAG);
2439             return FALSE;
2440         }
2441
2442         if (pcbDecoded)
2443             *pcbDecoded = 1 + lenBytes + dataLen;
2444         if (!pvStructInfo)
2445             *pcbStructInfo = bytesNeeded;
2446         else if (*pcbStructInfo < bytesNeeded)
2447         {
2448             *pcbStructInfo = bytesNeeded;
2449             SetLastError(ERROR_MORE_DATA);
2450             ret = FALSE;
2451         }
2452         else
2453         {
2454             LPWSTR *pStr = pvStructInfo;
2455
2456             *pcbStructInfo = bytesNeeded;
2457             if (dataLen)
2458             {
2459                 DWORD i;
2460                 LPWSTR str = *(LPWSTR *)pStr;
2461
2462                 assert(str);
2463                 switch (pbEncoded[0])
2464                 {
2465                 case ASN_NUMERICSTRING:
2466                 case ASN_PRINTABLESTRING:
2467                 case ASN_IA5STRING:
2468                 case ASN_T61STRING:
2469                 case ASN_VIDEOTEXSTRING:
2470                 case ASN_GRAPHICSTRING:
2471                 case ASN_VISIBLESTRING:
2472                 case ASN_GENERALSTRING:
2473                     for (i = 0; i < dataLen; i++)
2474                         str[i] = pbEncoded[1 + lenBytes + i];
2475                     str[i] = 0;
2476                     break;
2477                 case ASN_UNIVERSALSTRING:
2478                     for (i = 0; i < dataLen / 4; i++)
2479                         str[i] = (pbEncoded[1 + lenBytes + 2 * i + 2] << 8)
2480                          | pbEncoded[1 + lenBytes + 2 * i + 3];
2481                     str[i] = 0;
2482                     break;
2483                 case ASN_BMPSTRING:
2484                     for (i = 0; i < dataLen / 2; i++)
2485                         str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
2486                          pbEncoded[1 + lenBytes + 2 * i + 1];
2487                     str[i] = 0;
2488                     break;
2489                 case ASN_UTF8STRING:
2490                 {
2491                     int len = MultiByteToWideChar(CP_UTF8, 0,
2492                      (LPCSTR)pbEncoded + 1 + lenBytes, dataLen,
2493                      str, bytesNeeded - sizeof(CERT_NAME_VALUE)) * 2;
2494                     str[len] = 0;
2495                     break;
2496                 }
2497                 }
2498             }
2499             else
2500                 *pStr = NULL;
2501         }
2502     }
2503     return ret;
2504 }
2505
2506 static BOOL CRYPT_AsnDecodePolicyQualifierUserNoticeInternal(
2507  const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo,
2508  DWORD *pcbStructInfo, DWORD *pcbDecoded)
2509 {
2510     BOOL ret;
2511     struct AsnDecodeSequenceItem items[] = {
2512      { ASN_SEQUENCE, offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE,
2513        pNoticeReference), CRYPT_AsnDecodeNoticeReference,
2514        sizeof(PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE), TRUE, TRUE,
2515        offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE, pNoticeReference), 0 },
2516      { 0, offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE, pszDisplayText),
2517        CRYPT_AsnDecodeUnicodeString, sizeof(LPWSTR), TRUE, TRUE,
2518        offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE, pszDisplayText), 0 },
2519     };
2520     PCERT_POLICY_QUALIFIER_USER_NOTICE notice = pvStructInfo;
2521
2522     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2523      pvStructInfo, *pcbStructInfo);
2524
2525     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2526      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2527      pcbDecoded, notice ? notice->pNoticeReference : NULL);
2528     TRACE("returning %d\n", ret);
2529     return ret;
2530 }
2531
2532 static BOOL WINAPI CRYPT_AsnDecodePolicyQualifierUserNotice(
2533  DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded,
2534  DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
2535  void *pvStructInfo, DWORD *pcbStructInfo)
2536 {
2537     BOOL ret = FALSE;
2538
2539     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2540      pDecodePara, pvStructInfo, *pcbStructInfo);
2541
2542     __TRY
2543     {
2544         DWORD bytesNeeded;
2545
2546         ret = CRYPT_AsnDecodePolicyQualifierUserNoticeInternal(pbEncoded,
2547          cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded,
2548          NULL);
2549         if (ret)
2550         {
2551             if (!pvStructInfo)
2552                 *pcbStructInfo = bytesNeeded;
2553             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2554              pvStructInfo, pcbStructInfo, bytesNeeded)))
2555             {
2556                 PCERT_POLICY_QUALIFIER_USER_NOTICE notice;
2557
2558                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2559                     pvStructInfo = *(BYTE **)pvStructInfo;
2560                 notice = pvStructInfo;
2561                 notice->pNoticeReference =
2562                  (PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE)
2563                  ((BYTE *)pvStructInfo +
2564                  sizeof(CERT_POLICY_QUALIFIER_USER_NOTICE));
2565                 ret = CRYPT_AsnDecodePolicyQualifierUserNoticeInternal(
2566                  pbEncoded, cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
2567                  pvStructInfo, &bytesNeeded, NULL);
2568             }
2569         }
2570     }
2571     __EXCEPT_PAGE_FAULT
2572     {
2573         SetLastError(STATUS_ACCESS_VIOLATION);
2574     }
2575     __ENDTRY
2576     TRACE("returning %d\n", ret);
2577     return ret;
2578 }
2579
2580 static BOOL CRYPT_AsnDecodePKCSAttributeInternal(const BYTE *pbEncoded,
2581  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2582  DWORD *pcbDecoded)
2583 {
2584     BOOL ret;
2585     struct AsnDecodeSequenceItem items[] = {
2586      { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ATTRIBUTE, pszObjId),
2587        CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2588        offsetof(CRYPT_ATTRIBUTE, pszObjId), 0 },
2589      { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CRYPT_ATTRIBUTE, cValue),
2590        CRYPT_DecodeDERArray, sizeof(struct GenericArray), FALSE, TRUE,
2591        offsetof(CRYPT_ATTRIBUTE, rgValue), 0 },
2592     };
2593     PCRYPT_ATTRIBUTE attr = pvStructInfo;
2594
2595     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2596      pvStructInfo, *pcbStructInfo);
2597
2598     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2599      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2600      pcbDecoded, attr ? attr->pszObjId : NULL);
2601     TRACE("returning %d\n", ret);
2602     return ret;
2603 }
2604
2605 static BOOL WINAPI CRYPT_AsnDecodePKCSAttribute(DWORD dwCertEncodingType,
2606  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2607  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
2608 {
2609     BOOL ret = FALSE;
2610
2611     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2612      pDecodePara, pvStructInfo, *pcbStructInfo);
2613
2614     __TRY
2615     {
2616         DWORD bytesNeeded;
2617
2618         ret = CRYPT_AsnDecodePKCSAttributeInternal(pbEncoded, cbEncoded,
2619          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
2620         if (ret)
2621         {
2622             if (!pvStructInfo)
2623                 *pcbStructInfo = bytesNeeded;
2624             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2625              pvStructInfo, pcbStructInfo, bytesNeeded)))
2626             {
2627                 PCRYPT_ATTRIBUTE attr;
2628
2629                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2630                     pvStructInfo = *(BYTE **)pvStructInfo;
2631                 attr = pvStructInfo;
2632                 attr->pszObjId = (LPSTR)((BYTE *)pvStructInfo +
2633                  sizeof(CRYPT_ATTRIBUTE));
2634                 ret = CRYPT_AsnDecodePKCSAttributeInternal(pbEncoded, cbEncoded,
2635                  dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo, &bytesNeeded,
2636                  NULL);
2637             }
2638         }
2639     }
2640     __EXCEPT_PAGE_FAULT
2641     {
2642         SetLastError(STATUS_ACCESS_VIOLATION);
2643     }
2644     __ENDTRY
2645     TRACE("returning %d\n", ret);
2646     return ret;
2647 }
2648
2649 static BOOL CRYPT_AsnDecodePKCSAttributesInternal(const BYTE *pbEncoded,
2650  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2651  DWORD *pcbDecoded)
2652 {
2653     struct AsnArrayDescriptor arrayDesc = { 0,
2654      CRYPT_AsnDecodePKCSAttributeInternal, sizeof(CRYPT_ATTRIBUTE), TRUE,
2655      offsetof(CRYPT_ATTRIBUTE, pszObjId) };
2656     PCRYPT_ATTRIBUTES attrs = pvStructInfo;
2657     BOOL ret;
2658
2659     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2660      NULL, pvStructInfo, pcbStructInfo, pcbDecoded, attrs ? attrs->rgAttr :
2661      NULL);
2662     return ret;
2663 }
2664
2665 static BOOL WINAPI CRYPT_AsnDecodePKCSAttributes(DWORD dwCertEncodingType,
2666  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2667  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
2668 {
2669     BOOL ret = FALSE;
2670
2671     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2672      pDecodePara, pvStructInfo, *pcbStructInfo);
2673
2674     __TRY
2675     {
2676         DWORD bytesNeeded;
2677
2678         if (!cbEncoded)
2679             SetLastError(CRYPT_E_ASN1_EOD);
2680         else if (pbEncoded[0] != (ASN_CONSTRUCTOR | ASN_SETOF))
2681             SetLastError(CRYPT_E_ASN1_CORRUPT);
2682         else if ((ret = CRYPT_AsnDecodePKCSAttributesInternal(pbEncoded,
2683          cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded,
2684          NULL)))
2685         {
2686             if (!pvStructInfo)
2687                 *pcbStructInfo = bytesNeeded;
2688             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2689              pvStructInfo, pcbStructInfo, bytesNeeded)))
2690             {
2691                 PCRYPT_ATTRIBUTES attrs;
2692
2693                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2694                     pvStructInfo = *(BYTE **)pvStructInfo;
2695                 attrs = pvStructInfo;
2696                 attrs->rgAttr = (PCRYPT_ATTRIBUTE)((BYTE *)pvStructInfo +
2697                  sizeof(CRYPT_ATTRIBUTES));
2698                 ret = CRYPT_AsnDecodePKCSAttributesInternal(pbEncoded,
2699                  cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
2700                  &bytesNeeded, NULL);
2701             }
2702         }
2703     }
2704     __EXCEPT_PAGE_FAULT
2705     {
2706         SetLastError(STATUS_ACCESS_VIOLATION);
2707     }
2708     __ENDTRY
2709     TRACE("returning %d\n", ret);
2710     return ret;
2711 }
2712
2713 static BOOL CRYPT_AsnDecodeAlgorithmId(const BYTE *pbEncoded, DWORD cbEncoded,
2714  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2715 {
2716     CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
2717     BOOL ret = TRUE;
2718     struct AsnDecodeSequenceItem items[] = {
2719      { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId),
2720        CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2721        offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId), 0 },
2722      { 0, offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters),
2723        CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
2724        offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters.pbData), 0 },
2725     };
2726
2727     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
2728      pvStructInfo, *pcbStructInfo, pcbDecoded);
2729
2730     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2731      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2732      pcbDecoded, algo ? algo->pszObjId : NULL);
2733     if (ret && pvStructInfo)
2734     {
2735         TRACE("pszObjId is %p (%s)\n", algo->pszObjId,
2736          debugstr_a(algo->pszObjId));
2737     }
2738     return ret;
2739 }
2740
2741 static BOOL CRYPT_AsnDecodePubKeyInfoInternal(const BYTE *pbEncoded,
2742  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2743  DWORD *pcbDecoded)
2744 {
2745     BOOL ret = TRUE;
2746     struct AsnDecodeSequenceItem items[] = {
2747      { ASN_SEQUENCEOF, offsetof(CERT_PUBLIC_KEY_INFO, Algorithm),
2748        CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
2749        FALSE, TRUE, offsetof(CERT_PUBLIC_KEY_INFO,
2750        Algorithm.pszObjId) },
2751      { ASN_BITSTRING, offsetof(CERT_PUBLIC_KEY_INFO, PublicKey),
2752        CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), FALSE, TRUE,
2753        offsetof(CERT_PUBLIC_KEY_INFO, PublicKey.pbData) },
2754     };
2755     PCERT_PUBLIC_KEY_INFO info = pvStructInfo;
2756
2757     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
2758      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2759      pcbDecoded, info ? info->Algorithm.Parameters.pbData : NULL);
2760     return ret;
2761 }
2762
2763 static BOOL WINAPI CRYPT_AsnDecodePubKeyInfo(DWORD dwCertEncodingType,
2764  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2765  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
2766 {
2767     BOOL ret = TRUE;
2768
2769     __TRY
2770     {
2771         DWORD bytesNeeded;
2772
2773         if ((ret = CRYPT_AsnDecodePubKeyInfoInternal(pbEncoded, cbEncoded,
2774          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
2775         {
2776             if (!pvStructInfo)
2777                 *pcbStructInfo = bytesNeeded;
2778             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2779              pvStructInfo, pcbStructInfo, bytesNeeded)))
2780             {
2781                 PCERT_PUBLIC_KEY_INFO info;
2782
2783                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2784                     pvStructInfo = *(BYTE **)pvStructInfo;
2785                 info = pvStructInfo;
2786                 info->Algorithm.Parameters.pbData = (BYTE *)pvStructInfo +
2787                  sizeof(CERT_PUBLIC_KEY_INFO);
2788                 ret = CRYPT_AsnDecodePubKeyInfoInternal(pbEncoded, cbEncoded,
2789                  dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
2790                  &bytesNeeded, NULL);
2791             }
2792         }
2793     }
2794     __EXCEPT_PAGE_FAULT
2795     {
2796         SetLastError(STATUS_ACCESS_VIOLATION);
2797         ret = FALSE;
2798     }
2799     __ENDTRY
2800     return ret;
2801 }
2802
2803 static BOOL CRYPT_AsnDecodeBool(const BYTE *pbEncoded, DWORD cbEncoded,
2804  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2805 {
2806     BOOL ret;
2807
2808     if (cbEncoded < 3)
2809     {
2810         SetLastError(CRYPT_E_ASN1_CORRUPT);
2811         return FALSE;
2812     }
2813     if (GET_LEN_BYTES(pbEncoded[1]) > 1)
2814     {
2815         SetLastError(CRYPT_E_ASN1_CORRUPT);
2816         return FALSE;
2817     }
2818     if (pbEncoded[1] > 1)
2819     {
2820         SetLastError(CRYPT_E_ASN1_CORRUPT);
2821         return FALSE;
2822     }
2823     if (pcbDecoded)
2824         *pcbDecoded = 3;
2825     if (!pvStructInfo)
2826     {
2827         *pcbStructInfo = sizeof(BOOL);
2828         ret = TRUE;
2829     }
2830     else if (*pcbStructInfo < sizeof(BOOL))
2831     {
2832         *pcbStructInfo = sizeof(BOOL);
2833         SetLastError(ERROR_MORE_DATA);
2834         ret = FALSE;
2835     }
2836     else
2837     {
2838         *pcbStructInfo = sizeof(BOOL);
2839         *(BOOL *)pvStructInfo = pbEncoded[2] ? TRUE : FALSE;
2840         ret = TRUE;
2841     }
2842     TRACE("returning %d (%08x)\n", ret, GetLastError());
2843     return ret;
2844 }
2845
2846 static BOOL CRYPT_AsnDecodeAltNameEntry(const BYTE *pbEncoded, DWORD cbEncoded,
2847  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
2848 {
2849     PCERT_ALT_NAME_ENTRY entry = pvStructInfo;
2850     DWORD dataLen, lenBytes, bytesNeeded = sizeof(CERT_ALT_NAME_ENTRY);
2851     BOOL ret;
2852
2853     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2854      pvStructInfo, *pcbStructInfo);
2855
2856     if (cbEncoded < 2)
2857     {
2858         SetLastError(CRYPT_E_ASN1_CORRUPT);
2859         return FALSE;
2860     }
2861     lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2862     if (1 + lenBytes > cbEncoded)
2863     {
2864         SetLastError(CRYPT_E_ASN1_CORRUPT);
2865         return FALSE;
2866     }
2867     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2868     {
2869         switch (pbEncoded[0] & ASN_TYPE_MASK)
2870         {
2871         case 1: /* rfc822Name */
2872         case 2: /* dNSName */
2873         case 6: /* uniformResourceIdentifier */
2874             bytesNeeded += (dataLen + 1) * sizeof(WCHAR);
2875             break;
2876         case 4: /* directoryName */
2877         case 7: /* iPAddress */
2878             bytesNeeded += dataLen;
2879             break;
2880         case 8: /* registeredID */
2881             ret = CRYPT_AsnDecodeOidIgnoreTag(pbEncoded, cbEncoded, 0, NULL,
2882              &dataLen, NULL);
2883             if (ret)
2884             {
2885                 /* FIXME: ugly, shouldn't need to know internals of OID decode
2886                  * function to use it.
2887                  */
2888                 bytesNeeded += dataLen - sizeof(LPSTR);
2889             }
2890             break;
2891         case 0: /* otherName */
2892             FIXME("%d: stub\n", pbEncoded[0] & ASN_TYPE_MASK);
2893             SetLastError(CRYPT_E_ASN1_BADTAG);
2894             ret = FALSE;
2895             break;
2896         case 3: /* x400Address, unimplemented */
2897         case 5: /* ediPartyName, unimplemented */
2898             TRACE("type %d unimplemented\n", pbEncoded[0] & ASN_TYPE_MASK);
2899             SetLastError(CRYPT_E_ASN1_BADTAG);
2900             ret = FALSE;
2901             break;
2902         default:
2903             TRACE("type %d bad\n", pbEncoded[0] & ASN_TYPE_MASK);
2904             SetLastError(CRYPT_E_ASN1_CORRUPT);
2905             ret = FALSE;
2906         }
2907         if (ret)
2908         {
2909             if (pcbDecoded)
2910                 *pcbDecoded = 1 + lenBytes + dataLen;
2911             if (!entry)
2912                 *pcbStructInfo = bytesNeeded;
2913             else if (*pcbStructInfo < bytesNeeded)
2914             {
2915                 *pcbStructInfo = bytesNeeded;
2916                 SetLastError(ERROR_MORE_DATA);
2917                 ret = FALSE;
2918             }
2919             else
2920             {
2921                 *pcbStructInfo = bytesNeeded;
2922                 /* MS used values one greater than the asn1 ones.. sigh */
2923                 entry->dwAltNameChoice = (pbEncoded[0] & ASN_TYPE_MASK) + 1;
2924                 switch (pbEncoded[0] & ASN_TYPE_MASK)
2925                 {
2926                 case 1: /* rfc822Name */
2927                 case 2: /* dNSName */
2928                 case 6: /* uniformResourceIdentifier */
2929                 {
2930                     DWORD i;
2931
2932                     for (i = 0; i < dataLen; i++)
2933                         entry->u.pwszURL[i] =
2934                          (WCHAR)pbEncoded[1 + lenBytes + i];
2935                     entry->u.pwszURL[i] = 0;
2936                     TRACE("URL is %p (%s)\n", entry->u.pwszURL,
2937                      debugstr_w(entry->u.pwszURL));
2938                     break;
2939                 }
2940                 case 4: /* directoryName */
2941                     /* The data are memory-equivalent with the IPAddress case,
2942                      * fall-through
2943                      */
2944                 case 7: /* iPAddress */
2945                     /* The next data pointer is in the pwszURL spot, that is,
2946                      * the first 4 bytes.  Need to move it to the next spot.
2947                      */
2948                     entry->u.IPAddress.pbData = (LPBYTE)entry->u.pwszURL;
2949                     entry->u.IPAddress.cbData = dataLen;
2950                     memcpy(entry->u.IPAddress.pbData, pbEncoded + 1 + lenBytes,
2951                      dataLen);
2952                     break;
2953                 case 8: /* registeredID */
2954                     ret = CRYPT_AsnDecodeOidIgnoreTag(pbEncoded, cbEncoded, 0,
2955                      &entry->u.pszRegisteredID, &dataLen, NULL);
2956                     break;
2957                 }
2958             }
2959         }
2960     }
2961     return ret;
2962 }
2963
2964 static BOOL CRYPT_AsnDecodeAltNameInternal(const BYTE *pbEncoded,
2965  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2966  DWORD *pcbDecoded)
2967 {
2968     BOOL ret = TRUE;
2969     struct AsnArrayDescriptor arrayDesc = { 0,
2970      CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), TRUE,
2971      offsetof(CERT_ALT_NAME_ENTRY, u.pwszURL) };
2972     PCERT_ALT_NAME_INFO info = pvStructInfo;
2973
2974     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
2975      pvStructInfo, *pcbStructInfo, pcbDecoded);
2976
2977     if (info)
2978         TRACE("info->rgAltEntry is %p\n", info->rgAltEntry);
2979     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2980      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
2981      info ? info->rgAltEntry : NULL);
2982     return ret;
2983 }
2984
2985 /* Like CRYPT_AsnDecodeIntegerInternal, but swaps the bytes */
2986 static BOOL CRYPT_AsnDecodeIntegerSwapBytes(const BYTE *pbEncoded,
2987  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
2988  DWORD *pcbDecoded)
2989 {
2990     BOOL ret;
2991
2992     TRACE("(%p, %d, 0x%08x, %p, %d, %p)\n", pbEncoded, cbEncoded, dwFlags,
2993      pvStructInfo, *pcbStructInfo, pcbDecoded);
2994
2995     /* Can't use the CRYPT_DECODE_NOCOPY_FLAG, because we modify the bytes in-
2996      * place.
2997      */
2998     ret = CRYPT_AsnDecodeIntegerInternal(pbEncoded, cbEncoded,
2999      dwFlags & ~CRYPT_DECODE_NOCOPY_FLAG, pvStructInfo, pcbStructInfo,
3000      pcbDecoded);
3001     if (ret && pvStructInfo)
3002     {
3003         CRYPT_DATA_BLOB *blob = pvStructInfo;
3004
3005         if (blob->cbData)
3006         {
3007             DWORD i;
3008             BYTE temp;
3009
3010             for (i = 0; i < blob->cbData / 2; i++)
3011             {
3012                 temp = blob->pbData[i];
3013                 blob->pbData[i] = blob->pbData[blob->cbData - i - 1];
3014                 blob->pbData[blob->cbData - i - 1] = temp;
3015             }
3016         }
3017     }
3018     TRACE("returning %d (%08x)\n", ret, GetLastError());
3019     return ret;
3020 }
3021
3022 static BOOL WINAPI CRYPT_AsnDecodeAuthorityKeyId(DWORD dwCertEncodingType,
3023  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3024  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3025 {
3026     BOOL ret;
3027
3028     __TRY
3029     {
3030         struct AsnDecodeSequenceItem items[] = {
3031          { ASN_CONTEXT | 0, offsetof(CERT_AUTHORITY_KEY_ID_INFO, KeyId),
3032            CRYPT_AsnDecodeIntegerSwapBytes, sizeof(CRYPT_DATA_BLOB),
3033            TRUE, TRUE, offsetof(CERT_AUTHORITY_KEY_ID_INFO, KeyId.pbData), 0 },
3034          { ASN_CONTEXT | ASN_CONSTRUCTOR| 1,
3035            offsetof(CERT_AUTHORITY_KEY_ID_INFO, CertIssuer),
3036            CRYPT_AsnDecodeOctetsInternal, sizeof(CERT_NAME_BLOB), TRUE, TRUE,
3037            offsetof(CERT_AUTHORITY_KEY_ID_INFO, CertIssuer.pbData), 0 },
3038          { ASN_CONTEXT | 2, offsetof(CERT_AUTHORITY_KEY_ID_INFO,
3039            CertSerialNumber), CRYPT_AsnDecodeIntegerInternal,
3040            sizeof(CRYPT_INTEGER_BLOB), TRUE, TRUE,
3041            offsetof(CERT_AUTHORITY_KEY_ID_INFO, CertSerialNumber.pbData), 0 },
3042         };
3043
3044         ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3045          pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3046          pcbStructInfo, NULL, NULL);
3047     }
3048     __EXCEPT_PAGE_FAULT
3049     {
3050         SetLastError(STATUS_ACCESS_VIOLATION);
3051         ret = FALSE;
3052     }
3053     __ENDTRY
3054     return ret;
3055 }
3056
3057 static BOOL WINAPI CRYPT_AsnDecodeAuthorityKeyId2(DWORD dwCertEncodingType,
3058  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3059  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3060 {
3061     BOOL ret;
3062
3063     __TRY
3064     {
3065         struct AsnDecodeSequenceItem items[] = {
3066          { ASN_CONTEXT | 0, offsetof(CERT_AUTHORITY_KEY_ID2_INFO, KeyId),
3067            CRYPT_AsnDecodeIntegerSwapBytes, sizeof(CRYPT_DATA_BLOB),
3068            TRUE, TRUE, offsetof(CERT_AUTHORITY_KEY_ID2_INFO, KeyId.pbData), 0 },
3069          { ASN_CONTEXT | ASN_CONSTRUCTOR| 1,
3070            offsetof(CERT_AUTHORITY_KEY_ID2_INFO, AuthorityCertIssuer),
3071            CRYPT_AsnDecodeAltNameInternal, sizeof(CERT_ALT_NAME_INFO), TRUE,
3072            TRUE, offsetof(CERT_AUTHORITY_KEY_ID2_INFO,
3073            AuthorityCertIssuer.rgAltEntry), 0 },
3074          { ASN_CONTEXT | 2, offsetof(CERT_AUTHORITY_KEY_ID2_INFO,
3075            AuthorityCertSerialNumber), CRYPT_AsnDecodeIntegerInternal,
3076            sizeof(CRYPT_INTEGER_BLOB), TRUE, TRUE,
3077            offsetof(CERT_AUTHORITY_KEY_ID2_INFO,
3078            AuthorityCertSerialNumber.pbData), 0 },
3079         };
3080
3081         ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3082          pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3083          pcbStructInfo, NULL, NULL);
3084     }
3085     __EXCEPT_PAGE_FAULT
3086     {
3087         SetLastError(STATUS_ACCESS_VIOLATION);
3088         ret = FALSE;
3089     }
3090     __ENDTRY
3091     return ret;
3092 }
3093
3094 static BOOL CRYPT_AsnDecodeAccessDescription(const BYTE *pbEncoded,
3095  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3096  DWORD *pcbDecoded)
3097 {
3098     struct AsnDecodeSequenceItem items[] = {
3099      { 0, offsetof(CERT_ACCESS_DESCRIPTION, pszAccessMethod),
3100        CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), FALSE, TRUE,
3101        offsetof(CERT_ACCESS_DESCRIPTION, pszAccessMethod), 0 },
3102      { 0, offsetof(CERT_ACCESS_DESCRIPTION, AccessLocation),
3103        CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), FALSE,
3104        TRUE, offsetof(CERT_ACCESS_DESCRIPTION, AccessLocation.u.pwszURL), 0 },
3105     };
3106     CERT_ACCESS_DESCRIPTION *descr = pvStructInfo;
3107
3108     return CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3109      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3110      pcbDecoded, descr ? descr->pszAccessMethod : NULL);
3111 }
3112
3113 static BOOL WINAPI CRYPT_AsnDecodeAuthorityInfoAccess(DWORD dwCertEncodingType,
3114  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3115  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3116 {
3117     BOOL ret;
3118
3119     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3120      pDecodePara, pvStructInfo, *pcbStructInfo);
3121
3122     __TRY
3123     {
3124         struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3125          CRYPT_AsnDecodeAccessDescription, sizeof(CERT_ACCESS_DESCRIPTION),
3126          TRUE, offsetof(CERT_ACCESS_DESCRIPTION, pszAccessMethod) };
3127
3128         ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
3129          pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
3130     }
3131     __EXCEPT_PAGE_FAULT
3132     {
3133         SetLastError(STATUS_ACCESS_VIOLATION);
3134         ret = FALSE;
3135     }
3136     __ENDTRY
3137     return ret;
3138 }
3139
3140 static BOOL CRYPT_AsnDecodePKCSContent(const BYTE *pbEncoded, DWORD cbEncoded,
3141  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
3142 {
3143     BOOL ret;
3144     DWORD dataLen;
3145
3146     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
3147      pvStructInfo, *pcbStructInfo, pcbDecoded);
3148
3149     /* The caller has already checked the tag, no need to check it again.
3150      * Check the outer length is valid:
3151      */
3152     if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
3153     {
3154         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
3155         DWORD innerLen;
3156
3157         pbEncoded += 1 + lenBytes;
3158         cbEncoded -= 1 + lenBytes;
3159         if (dataLen == CMSG_INDEFINITE_LENGTH)
3160             cbEncoded -= 2; /* space for 0 TLV */
3161         /* Check the inner length is valid: */
3162         if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &innerLen)))
3163         {
3164             DWORD decodedLen;
3165
3166             ret = CRYPT_AsnDecodeCopyBytes(pbEncoded, cbEncoded, dwFlags,
3167              pvStructInfo, pcbStructInfo, &decodedLen);
3168             if (dataLen == CMSG_INDEFINITE_LENGTH)
3169             {
3170                 if (*(pbEncoded + decodedLen) != 0 ||
3171                  *(pbEncoded + decodedLen + 1) != 0)
3172                 {
3173                     TRACE("expected 0 TLV, got {%02x,%02x}\n",
3174                      *(pbEncoded + decodedLen),
3175                      *(pbEncoded + decodedLen + 1));
3176                     SetLastError(CRYPT_E_ASN1_CORRUPT);
3177                     ret = FALSE;
3178                 }
3179                 else
3180                     decodedLen += 2;
3181             }
3182             if (ret && pcbDecoded)
3183             {
3184                 *pcbDecoded = 1 + lenBytes + decodedLen;
3185                 TRACE("decoded %d bytes\n", *pcbDecoded);
3186             }
3187         }
3188     }
3189     return ret;
3190 }
3191
3192 static BOOL CRYPT_AsnDecodePKCSContentInfoInternal(const BYTE *pbEncoded,
3193  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3194  DWORD *pcbDecoded)
3195 {
3196     CRYPT_CONTENT_INFO *info = pvStructInfo;
3197     struct AsnDecodeSequenceItem items[] = {
3198      { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_CONTENT_INFO, pszObjId),
3199        CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
3200        offsetof(CRYPT_CONTENT_INFO, pszObjId), 0 },
3201      { ASN_CONTEXT | ASN_CONSTRUCTOR | 0,
3202        offsetof(CRYPT_CONTENT_INFO, Content), CRYPT_AsnDecodePKCSContent,
3203        sizeof(CRYPT_DER_BLOB), TRUE, TRUE,
3204        offsetof(CRYPT_CONTENT_INFO, Content.pbData), 0 },
3205     };
3206     BOOL ret;
3207
3208     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
3209      pvStructInfo, *pcbStructInfo, pcbDecoded);
3210
3211     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3212      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3213      pcbDecoded, info ? info->pszObjId : NULL);
3214     return ret;
3215 }
3216
3217 static BOOL WINAPI CRYPT_AsnDecodePKCSContentInfo(DWORD dwCertEncodingType,
3218  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3219  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3220 {
3221     BOOL ret = FALSE;
3222
3223     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3224      pDecodePara, pvStructInfo, *pcbStructInfo);
3225
3226     __TRY
3227     {
3228         ret = CRYPT_AsnDecodePKCSContentInfoInternal(pbEncoded, cbEncoded,
3229          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
3230         if (ret && pvStructInfo)
3231         {
3232             ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
3233              pcbStructInfo, *pcbStructInfo);
3234             if (ret)
3235             {
3236                 CRYPT_CONTENT_INFO *info;
3237
3238                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3239                     pvStructInfo = *(BYTE **)pvStructInfo;
3240                 info = pvStructInfo;
3241                 info->pszObjId = (LPSTR)((BYTE *)info +
3242                  sizeof(CRYPT_CONTENT_INFO));
3243                 ret = CRYPT_AsnDecodePKCSContentInfoInternal(pbEncoded,
3244                  cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3245                  pcbStructInfo, NULL);
3246             }
3247         }
3248     }
3249     __EXCEPT_PAGE_FAULT
3250     {
3251         SetLastError(STATUS_ACCESS_VIOLATION);
3252     }
3253     __ENDTRY
3254     return ret;
3255 }
3256
3257 BOOL CRYPT_AsnDecodePKCSDigestedData(const BYTE *pbEncoded, DWORD cbEncoded,
3258  DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
3259  CRYPT_DIGESTED_DATA *digestedData, DWORD *pcbDigestedData)
3260 {
3261     BOOL ret;
3262     struct AsnDecodeSequenceItem items[] = {
3263      { ASN_INTEGER, offsetof(CRYPT_DIGESTED_DATA, version),
3264        CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
3265      { ASN_SEQUENCEOF, offsetof(CRYPT_DIGESTED_DATA, DigestAlgorithm),
3266        CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
3267        FALSE, TRUE, offsetof(CRYPT_DIGESTED_DATA, DigestAlgorithm.pszObjId),
3268        0 },
3269      { ASN_SEQUENCEOF, offsetof(CRYPT_DIGESTED_DATA, ContentInfo),
3270        CRYPT_AsnDecodePKCSContentInfoInternal,
3271        sizeof(CRYPT_CONTENT_INFO), FALSE, TRUE, offsetof(CRYPT_DIGESTED_DATA,
3272        ContentInfo.pszObjId), 0 },
3273      { ASN_OCTETSTRING, offsetof(CRYPT_DIGESTED_DATA, hash),
3274        CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_HASH_BLOB), FALSE, TRUE,
3275        offsetof(CRYPT_DIGESTED_DATA, hash.pbData), 0 },
3276     };
3277
3278     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3279      pbEncoded, cbEncoded, dwFlags, pDecodePara, digestedData, pcbDigestedData,
3280      NULL, NULL);
3281     return ret;
3282 }
3283
3284 static BOOL WINAPI CRYPT_AsnDecodeAltName(DWORD dwCertEncodingType,
3285  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3286  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3287 {
3288     BOOL ret = TRUE;
3289
3290     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3291      pDecodePara, pvStructInfo, *pcbStructInfo);
3292
3293     __TRY
3294     {
3295         DWORD bytesNeeded;
3296
3297         if ((ret = CRYPT_AsnDecodeAltNameInternal(pbEncoded, cbEncoded,
3298          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
3299         {
3300             if (!pvStructInfo)
3301                 *pcbStructInfo = bytesNeeded;
3302             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3303              pvStructInfo, pcbStructInfo, bytesNeeded)))
3304             {
3305                 CERT_ALT_NAME_INFO *name;
3306
3307                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3308                     pvStructInfo = *(BYTE **)pvStructInfo;
3309                 name = pvStructInfo;
3310                 name->rgAltEntry = (PCERT_ALT_NAME_ENTRY)
3311                  ((BYTE *)pvStructInfo + sizeof(CERT_ALT_NAME_INFO));
3312                 ret = CRYPT_AsnDecodeAltNameInternal(pbEncoded, cbEncoded,
3313                  dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3314                  &bytesNeeded, NULL);
3315             }
3316         }
3317     }
3318     __EXCEPT_PAGE_FAULT
3319     {
3320         SetLastError(STATUS_ACCESS_VIOLATION);
3321         ret = FALSE;
3322     }
3323     __ENDTRY
3324     return ret;
3325 }
3326
3327 struct PATH_LEN_CONSTRAINT
3328 {
3329     BOOL  fPathLenConstraint;
3330     DWORD dwPathLenConstraint;
3331 };
3332
3333 static BOOL CRYPT_AsnDecodePathLenConstraint(const BYTE *pbEncoded,
3334  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3335  DWORD *pcbDecoded)
3336 {
3337     BOOL ret = TRUE;
3338     DWORD bytesNeeded = sizeof(struct PATH_LEN_CONSTRAINT), size;
3339
3340     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
3341      pvStructInfo, *pcbStructInfo, pcbDecoded);
3342
3343     if (!pvStructInfo)
3344     {
3345         ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags, NULL,
3346          &size, pcbDecoded);
3347         *pcbStructInfo = bytesNeeded;
3348     }
3349     else if (*pcbStructInfo < bytesNeeded)
3350     {
3351         SetLastError(ERROR_MORE_DATA);
3352         *pcbStructInfo = bytesNeeded;
3353         ret = FALSE;
3354     }
3355     else
3356     {
3357         struct PATH_LEN_CONSTRAINT *constraint = pvStructInfo;
3358
3359         *pcbStructInfo = bytesNeeded;
3360         size = sizeof(constraint->dwPathLenConstraint);
3361         ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags,
3362          &constraint->dwPathLenConstraint, &size, pcbDecoded);
3363         if (ret)
3364             constraint->fPathLenConstraint = TRUE;
3365         TRACE("got an int, dwPathLenConstraint is %d\n",
3366          constraint->dwPathLenConstraint);
3367     }
3368     TRACE("returning %d (%08x)\n", ret, GetLastError());
3369     return ret;
3370 }
3371
3372 static BOOL CRYPT_AsnDecodeSubtreeConstraints(const BYTE *pbEncoded,
3373  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3374  DWORD *pcbDecoded)
3375 {
3376     BOOL ret;
3377     struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3378      CRYPT_AsnDecodeCopyBytes, sizeof(CERT_NAME_BLOB), TRUE,
3379      offsetof(CERT_NAME_BLOB, pbData) };
3380     struct GenericArray *entries = pvStructInfo;
3381
3382     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
3383      pvStructInfo, *pcbStructInfo, pcbDecoded);
3384
3385     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
3386      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
3387      entries ? entries->rgItems : NULL);
3388     TRACE("Returning %d (%08x)\n", ret, GetLastError());
3389     return ret;
3390 }
3391
3392 static BOOL WINAPI CRYPT_AsnDecodeBasicConstraints(DWORD dwCertEncodingType,
3393  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3394  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3395 {
3396     BOOL ret;
3397
3398     __TRY
3399     {
3400         struct AsnDecodeSequenceItem items[] = {
3401          { ASN_BITSTRING, offsetof(CERT_BASIC_CONSTRAINTS_INFO, SubjectType),
3402            CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), FALSE, TRUE,
3403            offsetof(CERT_BASIC_CONSTRAINTS_INFO, SubjectType.pbData), 0 },
3404          { ASN_INTEGER, offsetof(CERT_BASIC_CONSTRAINTS_INFO,
3405            fPathLenConstraint), CRYPT_AsnDecodePathLenConstraint,
3406            sizeof(struct PATH_LEN_CONSTRAINT), TRUE, FALSE, 0, 0 },
3407          { ASN_SEQUENCEOF, offsetof(CERT_BASIC_CONSTRAINTS_INFO,
3408            cSubtreesConstraint), CRYPT_AsnDecodeSubtreeConstraints,
3409            sizeof(struct GenericArray), TRUE, TRUE,
3410            offsetof(CERT_BASIC_CONSTRAINTS_INFO, rgSubtreesConstraint), 0 },
3411         };
3412
3413         ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3414          pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3415          pcbStructInfo, NULL, NULL);
3416     }
3417     __EXCEPT_PAGE_FAULT
3418     {
3419         SetLastError(STATUS_ACCESS_VIOLATION);
3420         ret = FALSE;
3421     }
3422     __ENDTRY
3423     return ret;
3424 }
3425
3426 static BOOL WINAPI CRYPT_AsnDecodeBasicConstraints2(DWORD dwCertEncodingType,
3427  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3428  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3429 {
3430     BOOL ret;
3431
3432     __TRY
3433     {
3434         struct AsnDecodeSequenceItem items[] = {
3435          { ASN_BOOL, offsetof(CERT_BASIC_CONSTRAINTS2_INFO, fCA),
3436            CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE, FALSE, 0, 0 },
3437          { ASN_INTEGER, offsetof(CERT_BASIC_CONSTRAINTS2_INFO,
3438            fPathLenConstraint), CRYPT_AsnDecodePathLenConstraint,
3439            sizeof(struct PATH_LEN_CONSTRAINT), TRUE, FALSE, 0, 0 },
3440         };
3441
3442         ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3443          pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3444          pcbStructInfo, NULL, NULL);
3445     }
3446     __EXCEPT_PAGE_FAULT
3447     {
3448         SetLastError(STATUS_ACCESS_VIOLATION);
3449         ret = FALSE;
3450     }
3451     __ENDTRY
3452     return ret;
3453 }
3454
3455 static BOOL CRYPT_AsnDecodePolicyQualifier(const BYTE *pbEncoded,
3456  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3457  DWORD *pcbDecoded)
3458 {
3459     struct AsnDecodeSequenceItem items[] = {
3460      { ASN_OBJECTIDENTIFIER, offsetof(CERT_POLICY_QUALIFIER_INFO,
3461        pszPolicyQualifierId), CRYPT_AsnDecodeOidInternal, sizeof(LPSTR),
3462        FALSE, TRUE, offsetof(CERT_POLICY_QUALIFIER_INFO, pszPolicyQualifierId),
3463        0 },
3464      { 0, offsetof(CERT_POLICY_QUALIFIER_INFO, Qualifier),
3465        CRYPT_AsnDecodeDerBlob, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
3466        offsetof(CERT_POLICY_QUALIFIER_INFO, Qualifier.pbData), 0 },
3467     };
3468     BOOL ret;
3469     CERT_POLICY_QUALIFIER_INFO *qualifier = pvStructInfo;
3470
3471     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3472      pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3473
3474     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3475      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3476      pcbDecoded, qualifier ? qualifier->pszPolicyQualifierId : NULL);
3477     return ret;
3478 }
3479
3480 static BOOL CRYPT_AsnDecodePolicyQualifiers(const BYTE *pbEncoded,
3481  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3482  DWORD *pcbDecoded)
3483 {
3484     BOOL ret;
3485     struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3486      CRYPT_AsnDecodePolicyQualifier, sizeof(CERT_POLICY_QUALIFIER_INFO), TRUE,
3487      offsetof(CERT_POLICY_QUALIFIER_INFO, pszPolicyQualifierId) };
3488     struct GenericArray *entries = pvStructInfo;
3489
3490     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3491      pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3492
3493     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
3494      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
3495      entries ? entries->rgItems : NULL);
3496     TRACE("Returning %d (%08x)\n", ret, GetLastError());
3497     return ret;
3498 }
3499
3500 static BOOL CRYPT_AsnDecodeCertPolicy(const BYTE *pbEncoded, DWORD cbEncoded,
3501  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
3502 {
3503     struct AsnDecodeSequenceItem items[] = {
3504      { ASN_OBJECTIDENTIFIER, offsetof(CERT_POLICY_INFO, pszPolicyIdentifier),
3505        CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), FALSE, TRUE,
3506        offsetof(CERT_POLICY_INFO, pszPolicyIdentifier), 0 },
3507      { ASN_SEQUENCEOF, offsetof(CERT_POLICY_INFO, cPolicyQualifier),
3508        CRYPT_AsnDecodePolicyQualifiers, sizeof(struct GenericArray), TRUE,
3509        TRUE, offsetof(CERT_POLICY_INFO, rgPolicyQualifier), 0 },
3510     };
3511     CERT_POLICY_INFO *info = pvStructInfo;
3512     BOOL ret;
3513
3514     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3515      pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3516
3517     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3518      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3519      pcbDecoded, info ? info->pszPolicyIdentifier : NULL);
3520     return ret;
3521 }
3522
3523 static BOOL WINAPI CRYPT_AsnDecodeCertPolicies(DWORD dwCertEncodingType,
3524  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3525  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3526 {
3527     BOOL ret = FALSE;
3528
3529     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3530      pDecodePara, pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3531
3532     __TRY
3533     {
3534         struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3535          CRYPT_AsnDecodeCertPolicy, sizeof(CERT_POLICY_INFO), TRUE,
3536          offsetof(CERT_POLICY_INFO, pszPolicyIdentifier) };
3537
3538         ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
3539          pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
3540     }
3541     __EXCEPT_PAGE_FAULT
3542     {
3543         SetLastError(STATUS_ACCESS_VIOLATION);
3544     }
3545     __ENDTRY
3546     return ret;
3547 }
3548
3549 #define RSA1_MAGIC 0x31415352
3550
3551 struct DECODED_RSA_PUB_KEY
3552 {
3553     DWORD              pubexp;
3554     CRYPT_INTEGER_BLOB modulus;
3555 };
3556
3557 static BOOL WINAPI CRYPT_AsnDecodeRsaPubKey(DWORD dwCertEncodingType,
3558  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3559  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3560 {
3561     BOOL ret;
3562
3563     __TRY
3564     {
3565         struct AsnDecodeSequenceItem items[] = {
3566          { ASN_INTEGER, offsetof(struct DECODED_RSA_PUB_KEY, modulus),
3567            CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
3568            FALSE, TRUE, offsetof(struct DECODED_RSA_PUB_KEY, modulus.pbData),
3569            0 },
3570          { ASN_INTEGER, offsetof(struct DECODED_RSA_PUB_KEY, pubexp),
3571            CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
3572         };
3573         struct DECODED_RSA_PUB_KEY *decodedKey = NULL;
3574         DWORD size = 0;
3575
3576         ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
3577          pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &decodedKey,
3578          &size, NULL, NULL);
3579         if (ret)
3580         {
3581             DWORD bytesNeeded = sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) +
3582              decodedKey->modulus.cbData;
3583
3584             if (!pvStructInfo)
3585             {
3586                 *pcbStructInfo = bytesNeeded;
3587                 ret = TRUE;
3588             }
3589             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3590              pvStructInfo, pcbStructInfo, bytesNeeded)))
3591             {
3592                 BLOBHEADER *hdr;
3593                 RSAPUBKEY *rsaPubKey;
3594
3595                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3596                     pvStructInfo = *(BYTE **)pvStructInfo;
3597                 hdr = pvStructInfo;
3598                 hdr->bType = PUBLICKEYBLOB;
3599                 hdr->bVersion = CUR_BLOB_VERSION;
3600                 hdr->reserved = 0;
3601                 hdr->aiKeyAlg = CALG_RSA_KEYX;
3602                 rsaPubKey = (RSAPUBKEY *)((BYTE *)pvStructInfo +
3603                  sizeof(BLOBHEADER));
3604                 rsaPubKey->magic = RSA1_MAGIC;
3605                 rsaPubKey->pubexp = decodedKey->pubexp;
3606                 rsaPubKey->bitlen = decodedKey->modulus.cbData * 8;
3607                 memcpy((BYTE *)pvStructInfo + sizeof(BLOBHEADER) +
3608                  sizeof(RSAPUBKEY), decodedKey->modulus.pbData,
3609                  decodedKey->modulus.cbData);
3610             }
3611             LocalFree(decodedKey);
3612         }
3613     }
3614     __EXCEPT_PAGE_FAULT
3615     {
3616         SetLastError(STATUS_ACCESS_VIOLATION);
3617         ret = FALSE;
3618     }
3619     __ENDTRY
3620     return ret;
3621 }
3622
3623 static BOOL CRYPT_AsnDecodeOctetsInternal(const BYTE *pbEncoded,
3624  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3625  DWORD *pcbDecoded)
3626 {
3627     BOOL ret;
3628     DWORD bytesNeeded, dataLen;
3629
3630     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
3631      pvStructInfo, *pcbStructInfo, pcbDecoded);
3632
3633     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
3634     {
3635         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
3636
3637         if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
3638             bytesNeeded = sizeof(CRYPT_DATA_BLOB);
3639         else
3640             bytesNeeded = dataLen + sizeof(CRYPT_DATA_BLOB);
3641         if (pcbDecoded)
3642             *pcbDecoded = 1 + lenBytes + dataLen;
3643         if (!pvStructInfo)
3644             *pcbStructInfo = bytesNeeded;
3645         else if (*pcbStructInfo < bytesNeeded)
3646         {
3647             SetLastError(ERROR_MORE_DATA);
3648             *pcbStructInfo = bytesNeeded;
3649             ret = FALSE;
3650         }
3651         else
3652         {
3653             CRYPT_DATA_BLOB *blob;
3654
3655             *pcbStructInfo = bytesNeeded;
3656             blob = pvStructInfo;
3657             blob->cbData = dataLen;
3658             if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
3659                 blob->pbData = (BYTE *)pbEncoded + 1 + lenBytes;
3660             else
3661             {
3662                 assert(blob->pbData);
3663                 if (blob->cbData)
3664                     memcpy(blob->pbData, pbEncoded + 1 + lenBytes,
3665                      blob->cbData);
3666             }
3667         }
3668     }
3669     return ret;
3670 }
3671
3672 static BOOL WINAPI CRYPT_AsnDecodeOctets(DWORD dwCertEncodingType,
3673  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3674  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3675 {
3676     BOOL ret;
3677
3678     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
3679      pDecodePara, pvStructInfo, *pcbStructInfo);
3680
3681     __TRY
3682     {
3683         DWORD bytesNeeded;
3684
3685         if (!cbEncoded)
3686         {
3687             SetLastError(CRYPT_E_ASN1_CORRUPT);
3688             ret = FALSE;
3689         }
3690         else if (pbEncoded[0] != ASN_OCTETSTRING)
3691         {
3692             SetLastError(CRYPT_E_ASN1_BADTAG);
3693             ret = FALSE;
3694         }
3695         else if ((ret = CRYPT_AsnDecodeOctetsInternal(pbEncoded, cbEncoded,
3696          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
3697         {
3698             if (!pvStructInfo)
3699                 *pcbStructInfo = bytesNeeded;
3700             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3701              pvStructInfo, pcbStructInfo, bytesNeeded)))
3702             {
3703                 CRYPT_DATA_BLOB *blob;
3704
3705                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3706                     pvStructInfo = *(BYTE **)pvStructInfo;
3707                 blob = pvStructInfo;
3708                 blob->pbData = (BYTE *)pvStructInfo + sizeof(CRYPT_DATA_BLOB);
3709                 ret = CRYPT_AsnDecodeOctetsInternal(pbEncoded, cbEncoded,
3710                  dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3711                  &bytesNeeded, NULL);
3712             }
3713         }
3714     }
3715     __EXCEPT_PAGE_FAULT
3716     {
3717         SetLastError(STATUS_ACCESS_VIOLATION);
3718         ret = FALSE;
3719     }
3720     __ENDTRY
3721     return ret;
3722 }
3723
3724 static BOOL CRYPT_AsnDecodeBitsInternal(const BYTE *pbEncoded, DWORD cbEncoded,
3725  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
3726 {
3727     BOOL ret;
3728     DWORD bytesNeeded, dataLen;
3729     BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
3730
3731     TRACE("(%p, %d, 0x%08x, %p, %d, %p)\n", pbEncoded, cbEncoded, dwFlags,
3732      pvStructInfo, *pcbStructInfo, pcbDecoded);
3733
3734     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
3735     {
3736         if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
3737             bytesNeeded = sizeof(CRYPT_BIT_BLOB);
3738         else
3739             bytesNeeded = dataLen - 1 + sizeof(CRYPT_BIT_BLOB);
3740         if (pcbDecoded)
3741             *pcbDecoded = 1 + lenBytes + dataLen;
3742         if (!pvStructInfo)
3743             *pcbStructInfo = bytesNeeded;
3744         else if (*pcbStructInfo < bytesNeeded)
3745         {
3746             *pcbStructInfo = bytesNeeded;
3747             SetLastError(ERROR_MORE_DATA);
3748             ret = FALSE;
3749         }
3750         else
3751         {
3752             CRYPT_BIT_BLOB *blob;
3753
3754             *pcbStructInfo = bytesNeeded;
3755             blob = pvStructInfo;
3756             blob->cbData = dataLen - 1;
3757             blob->cUnusedBits = *(pbEncoded + 1 + lenBytes);
3758             if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
3759             {
3760                 blob->pbData = (BYTE *)pbEncoded + 2 + lenBytes;
3761             }
3762             else
3763             {
3764                 assert(blob->pbData);
3765                 if (blob->cbData)
3766                 {
3767                     BYTE mask = 0xff << blob->cUnusedBits;
3768
3769                     memcpy(blob->pbData, pbEncoded + 2 + lenBytes,
3770                      blob->cbData);
3771                     blob->pbData[blob->cbData - 1] &= mask;
3772                 }
3773             }
3774         }
3775     }
3776     return ret;
3777 }
3778
3779 static BOOL WINAPI CRYPT_AsnDecodeBits(DWORD dwCertEncodingType,
3780  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3781  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3782 {
3783     BOOL ret;
3784
3785     TRACE("(%p, %d, 0x%08x, %p, %p, %p)\n", pbEncoded, cbEncoded, dwFlags,
3786      pDecodePara, pvStructInfo, pcbStructInfo);
3787
3788     __TRY
3789     {
3790         DWORD bytesNeeded;
3791
3792         if (!cbEncoded)
3793         {
3794             SetLastError(CRYPT_E_ASN1_CORRUPT);
3795             ret = FALSE;
3796         }
3797         else if (pbEncoded[0] != ASN_BITSTRING)
3798         {
3799             SetLastError(CRYPT_E_ASN1_BADTAG);
3800             ret = FALSE;
3801         }
3802         else if ((ret = CRYPT_AsnDecodeBitsInternal(pbEncoded, cbEncoded,
3803          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
3804         {
3805             if (!pvStructInfo)
3806                 *pcbStructInfo = bytesNeeded;
3807             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3808              pvStructInfo, pcbStructInfo, bytesNeeded)))
3809             {
3810                 CRYPT_BIT_BLOB *blob;
3811
3812                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3813                     pvStructInfo = *(BYTE **)pvStructInfo;
3814                 blob = pvStructInfo;
3815                 blob->pbData = (BYTE *)pvStructInfo + sizeof(CRYPT_BIT_BLOB);
3816                 ret = CRYPT_AsnDecodeBitsInternal(pbEncoded, cbEncoded,
3817                  dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3818                  &bytesNeeded, NULL);
3819             }
3820         }
3821     }
3822     __EXCEPT_PAGE_FAULT
3823     {
3824         SetLastError(STATUS_ACCESS_VIOLATION);
3825         ret = FALSE;
3826     }
3827     __ENDTRY
3828     TRACE("returning %d (%08x)\n", ret, GetLastError());
3829     return ret;
3830 }
3831
3832 /* Ignores tag.  Only allows integers 4 bytes or smaller in size. */
3833 static BOOL CRYPT_AsnDecodeIntInternal(const BYTE *pbEncoded, DWORD cbEncoded,
3834  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
3835 {
3836     BOOL ret;
3837     BYTE buf[sizeof(CRYPT_INTEGER_BLOB) + sizeof(int)];
3838     CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)buf;
3839     DWORD size = sizeof(buf);
3840
3841     blob->pbData = buf + sizeof(CRYPT_INTEGER_BLOB);
3842     ret = CRYPT_AsnDecodeIntegerInternal(pbEncoded, cbEncoded, 0, buf,
3843      &size, pcbDecoded);
3844     if (ret)
3845     {
3846         if (!pvStructInfo)
3847             *pcbStructInfo = sizeof(int);
3848         else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo, sizeof(int))))
3849         {
3850             int val, i;
3851
3852             if (blob->pbData[blob->cbData - 1] & 0x80)
3853             {
3854                 /* initialize to a negative value to sign-extend */
3855                 val = -1;
3856             }
3857             else
3858                 val = 0;
3859             for (i = 0; i < blob->cbData; i++)
3860             {
3861                 val <<= 8;
3862                 val |= blob->pbData[blob->cbData - i - 1];
3863             }
3864             memcpy(pvStructInfo, &val, sizeof(int));
3865         }
3866     }
3867     else if (GetLastError() == ERROR_MORE_DATA)
3868         SetLastError(CRYPT_E_ASN1_LARGE);
3869     return ret;
3870 }
3871
3872 static BOOL WINAPI CRYPT_AsnDecodeInt(DWORD dwCertEncodingType,
3873  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3874  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3875 {
3876     BOOL ret;
3877
3878     __TRY
3879     {
3880         DWORD bytesNeeded;
3881
3882         if (!cbEncoded)
3883         {
3884             SetLastError(CRYPT_E_ASN1_EOD);
3885             ret = FALSE;
3886         }
3887         else if (pbEncoded[0] != ASN_INTEGER)
3888         {
3889             SetLastError(CRYPT_E_ASN1_BADTAG);
3890             ret = FALSE;
3891         }
3892         else
3893             ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded,
3894              dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
3895         if (ret)
3896         {
3897             if (!pvStructInfo)
3898                 *pcbStructInfo = bytesNeeded;
3899             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3900              pvStructInfo, pcbStructInfo, bytesNeeded)))
3901             {
3902                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3903                     pvStructInfo = *(BYTE **)pvStructInfo;
3904                 ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded,
3905                  dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3906                  &bytesNeeded, NULL);
3907             }
3908         }
3909     }
3910     __EXCEPT_PAGE_FAULT
3911     {
3912         SetLastError(STATUS_ACCESS_VIOLATION);
3913         ret = FALSE;
3914     }
3915     __ENDTRY
3916     return ret;
3917 }
3918
3919 static BOOL CRYPT_AsnDecodeIntegerInternal(const BYTE *pbEncoded,
3920  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
3921  DWORD *pcbDecoded)
3922 {
3923     BOOL ret;
3924     DWORD bytesNeeded, dataLen;
3925
3926     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
3927     {
3928         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
3929
3930         bytesNeeded = dataLen + sizeof(CRYPT_INTEGER_BLOB);
3931         if (pcbDecoded)
3932             *pcbDecoded = 1 + lenBytes + dataLen;
3933         if (!pvStructInfo)
3934             *pcbStructInfo = bytesNeeded;
3935         else if (*pcbStructInfo < bytesNeeded)
3936         {
3937             *pcbStructInfo = bytesNeeded;
3938             SetLastError(ERROR_MORE_DATA);
3939             ret = FALSE;
3940         }
3941         else
3942         {
3943             CRYPT_INTEGER_BLOB *blob = pvStructInfo;
3944
3945             *pcbStructInfo = bytesNeeded;
3946             blob->cbData = dataLen;
3947             assert(blob->pbData);
3948             if (blob->cbData)
3949             {
3950                 DWORD i;
3951
3952                 for (i = 0; i < blob->cbData; i++)
3953                 {
3954                     blob->pbData[i] = *(pbEncoded + 1 + lenBytes +
3955                      dataLen - i - 1);
3956                 }
3957             }
3958         }
3959     }
3960     return ret;
3961 }
3962
3963 static BOOL WINAPI CRYPT_AsnDecodeInteger(DWORD dwCertEncodingType,
3964  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
3965  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
3966 {
3967     BOOL ret;
3968
3969     __TRY
3970     {
3971         DWORD bytesNeeded;
3972
3973         if (pbEncoded[0] != ASN_INTEGER)
3974         {
3975             SetLastError(CRYPT_E_ASN1_BADTAG);
3976             ret = FALSE;
3977         }
3978         else
3979             ret = CRYPT_AsnDecodeIntegerInternal(pbEncoded, cbEncoded,
3980              dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
3981         if (ret)
3982         {
3983             if (!pvStructInfo)
3984                 *pcbStructInfo = bytesNeeded;
3985             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3986              pvStructInfo, pcbStructInfo, bytesNeeded)))
3987             {
3988                 CRYPT_INTEGER_BLOB *blob;
3989
3990                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3991                     pvStructInfo = *(BYTE **)pvStructInfo;
3992                 blob = pvStructInfo;
3993                 blob->pbData = (BYTE *)pvStructInfo +
3994                  sizeof(CRYPT_INTEGER_BLOB);
3995                 ret = CRYPT_AsnDecodeIntegerInternal(pbEncoded, cbEncoded,
3996                  dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, pvStructInfo,
3997                  &bytesNeeded, NULL);
3998             }
3999         }
4000     }
4001     __EXCEPT_PAGE_FAULT
4002     {
4003         SetLastError(STATUS_ACCESS_VIOLATION);
4004         ret = FALSE;
4005     }
4006     __ENDTRY
4007     return ret;
4008 }
4009
4010 static BOOL CRYPT_AsnDecodeUnsignedIntegerInternal(const BYTE *pbEncoded,
4011  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4012  DWORD *pcbDecoded)
4013 {
4014     BOOL ret;
4015
4016     if (pbEncoded[0] == ASN_INTEGER)
4017     {
4018         DWORD bytesNeeded, dataLen;
4019
4020         if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
4021         {
4022             BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
4023
4024             if (pcbDecoded)
4025                 *pcbDecoded = 1 + lenBytes + dataLen;
4026             bytesNeeded = dataLen + sizeof(CRYPT_INTEGER_BLOB);
4027             if (!pvStructInfo)
4028                 *pcbStructInfo = bytesNeeded;
4029             else if (*pcbStructInfo < bytesNeeded)
4030             {
4031                 *pcbStructInfo = bytesNeeded;
4032                 SetLastError(ERROR_MORE_DATA);
4033                 ret = FALSE;
4034             }
4035             else
4036             {
4037                 CRYPT_INTEGER_BLOB *blob = pvStructInfo;
4038
4039                 *pcbStructInfo = bytesNeeded;
4040                 blob->cbData = dataLen;
4041                 assert(blob->pbData);
4042                 /* remove leading zero byte if it exists */
4043                 if (blob->cbData && *(pbEncoded + 1 + lenBytes) == 0)
4044                 {
4045                     blob->cbData--;
4046                     blob->pbData++;
4047                 }
4048                 if (blob->cbData)
4049                 {
4050                     DWORD i;
4051
4052                     for (i = 0; i < blob->cbData; i++)
4053                     {
4054                         blob->pbData[i] = *(pbEncoded + 1 + lenBytes +
4055                          dataLen - i - 1);
4056                     }
4057                 }
4058             }
4059         }
4060     }
4061     else
4062     {
4063         SetLastError(CRYPT_E_ASN1_BADTAG);
4064         ret = FALSE;
4065     }
4066     return ret;
4067 }
4068
4069 static BOOL WINAPI CRYPT_AsnDecodeUnsignedInteger(DWORD dwCertEncodingType,
4070  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4071  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4072 {
4073     BOOL ret;
4074
4075     __TRY
4076     {
4077         DWORD bytesNeeded;
4078
4079         if ((ret = CRYPT_AsnDecodeUnsignedIntegerInternal(pbEncoded, cbEncoded,
4080          dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
4081         {
4082             if (!pvStructInfo)
4083                 *pcbStructInfo = bytesNeeded;
4084             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4085              pvStructInfo, pcbStructInfo, bytesNeeded)))
4086             {
4087                 CRYPT_INTEGER_BLOB *blob;
4088
4089                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4090                     pvStructInfo = *(BYTE **)pvStructInfo;
4091                 blob = pvStructInfo;
4092                 blob->pbData = (BYTE *)pvStructInfo +
4093                  sizeof(CRYPT_INTEGER_BLOB);
4094                 ret = CRYPT_AsnDecodeUnsignedIntegerInternal(pbEncoded,
4095                  cbEncoded, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, pvStructInfo,
4096                  &bytesNeeded, NULL);
4097             }
4098         }
4099     }
4100     __EXCEPT_PAGE_FAULT
4101     {
4102         SetLastError(STATUS_ACCESS_VIOLATION);
4103         ret = FALSE;
4104     }
4105     __ENDTRY
4106     return ret;
4107 }
4108
4109 static BOOL WINAPI CRYPT_AsnDecodeEnumerated(DWORD dwCertEncodingType,
4110  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4111  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4112 {
4113     BOOL ret;
4114
4115     if (!pvStructInfo)
4116     {
4117         *pcbStructInfo = sizeof(int);
4118         return TRUE;
4119     }
4120     __TRY
4121     {
4122         if (pbEncoded[0] == ASN_ENUMERATED)
4123         {
4124             unsigned int val = 0, i;
4125
4126             if (cbEncoded <= 1)
4127             {
4128                 SetLastError(CRYPT_E_ASN1_EOD);
4129                 ret = FALSE;
4130             }
4131             else if (pbEncoded[1] == 0)
4132             {
4133                 SetLastError(CRYPT_E_ASN1_CORRUPT);
4134                 ret = FALSE;
4135             }
4136             else
4137             {
4138                 /* A little strange looking, but we have to accept a sign byte:
4139                  * 0xffffffff gets encoded as 0a 05 00 ff ff ff ff.  Also,
4140                  * assuming a small length is okay here, it has to be in short
4141                  * form.
4142                  */
4143                 if (pbEncoded[1] > sizeof(unsigned int) + 1)
4144                 {
4145                     SetLastError(CRYPT_E_ASN1_LARGE);
4146                     return FALSE;
4147                 }
4148                 for (i = 0; i < pbEncoded[1]; i++)
4149                 {
4150                     val <<= 8;
4151                     val |= pbEncoded[2 + i];
4152                 }
4153                 if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4154                  pvStructInfo, pcbStructInfo, sizeof(unsigned int))))
4155                 {
4156                     if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4157                         pvStructInfo = *(BYTE **)pvStructInfo;
4158                     memcpy(pvStructInfo, &val, sizeof(unsigned int));
4159                 }
4160             }
4161         }
4162         else
4163         {
4164             SetLastError(CRYPT_E_ASN1_BADTAG);
4165             ret = FALSE;
4166         }
4167     }
4168     __EXCEPT_PAGE_FAULT
4169     {
4170         SetLastError(STATUS_ACCESS_VIOLATION);
4171         ret = FALSE;
4172     }
4173     __ENDTRY
4174     return ret;
4175 }
4176
4177 /* Modifies word, pbEncoded, and len, and magically sets a value ret to FALSE
4178  * if it fails.
4179  */
4180 #define CRYPT_TIME_GET_DIGITS(pbEncoded, len, numDigits, word) \
4181  do { \
4182     BYTE i; \
4183  \
4184     (word) = 0; \
4185     for (i = 0; (len) > 0 && i < (numDigits); i++, (len)--) \
4186     { \
4187         if (!isdigit(*(pbEncoded))) \
4188         { \
4189             SetLastError(CRYPT_E_ASN1_CORRUPT); \
4190             ret = FALSE; \
4191         } \
4192         else \
4193         { \
4194             (word) *= 10; \
4195             (word) += *(pbEncoded)++ - '0'; \
4196         } \
4197     } \
4198  } while (0)
4199
4200 static BOOL CRYPT_AsnDecodeTimeZone(const BYTE *pbEncoded, DWORD len,
4201  SYSTEMTIME *sysTime)
4202 {
4203     BOOL ret = TRUE;
4204
4205     if (len >= 3 && (*pbEncoded == '+' || *pbEncoded == '-'))
4206     {
4207         WORD hours, minutes = 0;
4208         BYTE sign = *pbEncoded++;
4209
4210         len--;
4211         CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, hours);
4212         if (ret && hours >= 24)
4213         {
4214             SetLastError(CRYPT_E_ASN1_CORRUPT);
4215             ret = FALSE;
4216         }
4217         else if (len >= 2)
4218         {
4219             CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, minutes);
4220             if (ret && minutes >= 60)
4221             {
4222                 SetLastError(CRYPT_E_ASN1_CORRUPT);
4223                 ret = FALSE;
4224             }
4225         }
4226         if (ret)
4227         {
4228             if (sign == '+')
4229             {
4230                 sysTime->wHour += hours;
4231                 sysTime->wMinute += minutes;
4232             }
4233             else
4234             {
4235                 if (hours > sysTime->wHour)
4236                 {
4237                     sysTime->wDay--;
4238                     sysTime->wHour = 24 - (hours - sysTime->wHour);
4239                 }
4240                 else
4241                     sysTime->wHour -= hours;
4242                 if (minutes > sysTime->wMinute)
4243                 {
4244                     sysTime->wHour--;
4245                     sysTime->wMinute = 60 - (minutes - sysTime->wMinute);
4246                 }
4247                 else
4248                     sysTime->wMinute -= minutes;
4249             }
4250         }
4251     }
4252     return ret;
4253 }
4254
4255 #define MIN_ENCODED_TIME_LENGTH 10
4256
4257 static BOOL CRYPT_AsnDecodeUtcTimeInternal(const BYTE *pbEncoded,
4258  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4259  DWORD *pcbDecoded)
4260 {
4261     BOOL ret = FALSE;
4262
4263     if (pbEncoded[0] == ASN_UTCTIME)
4264     {
4265         if (cbEncoded <= 1)
4266             SetLastError(CRYPT_E_ASN1_EOD);
4267         else if (pbEncoded[1] > 0x7f)
4268         {
4269             /* long-form date strings really can't be valid */
4270             SetLastError(CRYPT_E_ASN1_CORRUPT);
4271         }
4272         else
4273         {
4274             SYSTEMTIME sysTime = { 0 };
4275             BYTE len = pbEncoded[1];
4276
4277             if (len < MIN_ENCODED_TIME_LENGTH)
4278                 SetLastError(CRYPT_E_ASN1_CORRUPT);
4279             else
4280             {
4281                 ret = TRUE;
4282                 if (pcbDecoded)
4283                     *pcbDecoded = 2 + len;
4284                 pbEncoded += 2;
4285                 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wYear);
4286                 if (sysTime.wYear >= 50)
4287                     sysTime.wYear += 1900;
4288                 else
4289                     sysTime.wYear += 2000;
4290                 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wMonth);
4291                 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wDay);
4292                 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wHour);
4293                 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wMinute);
4294                 if (ret && len > 0)
4295                 {
4296                     if (len >= 2 && isdigit(*pbEncoded) &&
4297                      isdigit(*(pbEncoded + 1)))
4298                         CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2,
4299                          sysTime.wSecond);
4300                     else if (isdigit(*pbEncoded))
4301                         CRYPT_TIME_GET_DIGITS(pbEncoded, len, 1,
4302                          sysTime.wSecond);
4303                     if (ret)
4304                         ret = CRYPT_AsnDecodeTimeZone(pbEncoded, len,
4305                          &sysTime);
4306                 }
4307                 if (ret)
4308                 {
4309                     if (!pvStructInfo)
4310                         *pcbStructInfo = sizeof(FILETIME);
4311                     else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo,
4312                      sizeof(FILETIME))))
4313                         ret = SystemTimeToFileTime(&sysTime, pvStructInfo);
4314                 }
4315             }
4316         }
4317     }
4318     else
4319         SetLastError(CRYPT_E_ASN1_BADTAG);
4320     return ret;
4321 }
4322
4323 static BOOL WINAPI CRYPT_AsnDecodeUtcTime(DWORD dwCertEncodingType,
4324  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4325  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4326 {
4327     BOOL ret = FALSE;
4328
4329     __TRY
4330     {
4331         DWORD bytesNeeded;
4332
4333         ret = CRYPT_AsnDecodeUtcTimeInternal(pbEncoded, cbEncoded,
4334          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
4335         if (ret)
4336         {
4337             if (!pvStructInfo)
4338                 *pcbStructInfo = bytesNeeded;
4339             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags,
4340              pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
4341             {
4342                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4343                     pvStructInfo = *(BYTE **)pvStructInfo;
4344                 ret = CRYPT_AsnDecodeUtcTimeInternal(pbEncoded, cbEncoded,
4345                  dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
4346                  &bytesNeeded, NULL);
4347             }
4348         }
4349     }
4350     __EXCEPT_PAGE_FAULT
4351     {
4352         SetLastError(STATUS_ACCESS_VIOLATION);
4353     }
4354     __ENDTRY
4355     return ret;
4356 }
4357
4358 static BOOL CRYPT_AsnDecodeGeneralizedTime(const BYTE *pbEncoded,
4359  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4360  DWORD *pcbDecoded)
4361 {
4362     BOOL ret = FALSE;
4363
4364     if (pbEncoded[0] == ASN_GENERALTIME)
4365     {
4366         if (cbEncoded <= 1)
4367             SetLastError(CRYPT_E_ASN1_EOD);
4368         else if (pbEncoded[1] > 0x7f)
4369         {
4370             /* long-form date strings really can't be valid */
4371             SetLastError(CRYPT_E_ASN1_CORRUPT);
4372         }
4373         else
4374         {
4375             BYTE len = pbEncoded[1];
4376
4377             if (len < MIN_ENCODED_TIME_LENGTH)
4378                 SetLastError(CRYPT_E_ASN1_CORRUPT);
4379             else
4380             {
4381                 SYSTEMTIME sysTime = { 0 };
4382
4383                 ret = TRUE;
4384                 if (pcbDecoded)
4385                     *pcbDecoded = 2 + len;
4386                 pbEncoded += 2;
4387                 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 4, sysTime.wYear);
4388                 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wMonth);
4389                 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wDay);
4390                 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wHour);
4391                 if (ret && len > 0)
4392                 {
4393                     CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2,
4394                      sysTime.wMinute);
4395                     if (ret && len > 0)
4396                         CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2,
4397                          sysTime.wSecond);
4398                     if (ret && len > 0 && (*pbEncoded == '.' ||
4399                      *pbEncoded == ','))
4400                     {
4401                         BYTE digits;
4402
4403                         pbEncoded++;
4404                         len--;
4405                         /* workaround macro weirdness */
4406                         digits = min(len, 3);
4407                         CRYPT_TIME_GET_DIGITS(pbEncoded, len, digits,
4408                          sysTime.wMilliseconds);
4409                     }
4410                     if (ret)
4411                         ret = CRYPT_AsnDecodeTimeZone(pbEncoded, len,
4412                          &sysTime);
4413                 }
4414                 if (ret)
4415                 {
4416                     if (!pvStructInfo)
4417                         *pcbStructInfo = sizeof(FILETIME);
4418                     else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo,
4419                      sizeof(FILETIME))))
4420                         ret = SystemTimeToFileTime(&sysTime, pvStructInfo);
4421                 }
4422             }
4423         }
4424     }
4425     else
4426         SetLastError(CRYPT_E_ASN1_BADTAG);
4427     return ret;
4428 }
4429
4430 static BOOL CRYPT_AsnDecodeChoiceOfTimeInternal(const BYTE *pbEncoded,
4431  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4432  DWORD *pcbDecoded)
4433 {
4434     BOOL ret;
4435     InternalDecodeFunc decode = NULL;
4436
4437     if (pbEncoded[0] == ASN_UTCTIME)
4438         decode = CRYPT_AsnDecodeUtcTimeInternal;
4439     else if (pbEncoded[0] == ASN_GENERALTIME)
4440         decode = CRYPT_AsnDecodeGeneralizedTime;
4441     if (decode)
4442         ret = decode(pbEncoded, cbEncoded, dwFlags, pvStructInfo,
4443          pcbStructInfo, pcbDecoded);
4444     else
4445     {
4446         SetLastError(CRYPT_E_ASN1_BADTAG);
4447         ret = FALSE;
4448     }
4449     return ret;
4450 }
4451
4452 static BOOL WINAPI CRYPT_AsnDecodeChoiceOfTime(DWORD dwCertEncodingType,
4453  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4454  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4455 {
4456     BOOL ret;
4457
4458     __TRY
4459     {
4460         DWORD bytesNeeded;
4461
4462         ret = CRYPT_AsnDecodeChoiceOfTimeInternal(pbEncoded, cbEncoded,
4463          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
4464         if (ret)
4465         {
4466             if (!pvStructInfo)
4467                 *pcbStructInfo = bytesNeeded;
4468             else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4469              pvStructInfo, pcbStructInfo, bytesNeeded)))
4470             {
4471                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4472                     pvStructInfo = *(BYTE **)pvStructInfo;
4473                 ret = CRYPT_AsnDecodeChoiceOfTimeInternal(pbEncoded, cbEncoded,
4474                  dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
4475                  &bytesNeeded, NULL);
4476             }
4477         }
4478     }
4479     __EXCEPT_PAGE_FAULT
4480     {
4481         SetLastError(STATUS_ACCESS_VIOLATION);
4482         ret = FALSE;
4483     }
4484     __ENDTRY
4485     return ret;
4486 }
4487
4488 static BOOL WINAPI CRYPT_AsnDecodeSequenceOfAny(DWORD dwCertEncodingType,
4489  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4490  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4491 {
4492     BOOL ret = TRUE;
4493
4494     __TRY
4495     {
4496         if (pbEncoded[0] == ASN_SEQUENCEOF)
4497         {
4498             DWORD bytesNeeded, dataLen, remainingLen, cValue;
4499
4500             if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
4501             {
4502                 BYTE lenBytes;
4503                 const BYTE *ptr;
4504
4505                 lenBytes = GET_LEN_BYTES(pbEncoded[1]);
4506                 bytesNeeded = sizeof(CRYPT_SEQUENCE_OF_ANY);
4507                 cValue = 0;
4508                 ptr = pbEncoded + 1 + lenBytes;
4509                 remainingLen = dataLen;
4510                 while (ret && remainingLen)
4511                 {
4512                     DWORD nextLen;
4513
4514                     ret = CRYPT_GetLen(ptr, remainingLen, &nextLen);
4515                     if (ret)
4516                     {
4517                         DWORD nextLenBytes = GET_LEN_BYTES(ptr[1]);
4518
4519                         remainingLen -= 1 + nextLenBytes + nextLen;
4520                         ptr += 1 + nextLenBytes + nextLen;
4521                         bytesNeeded += sizeof(CRYPT_DER_BLOB);
4522                         if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
4523                             bytesNeeded += 1 + nextLenBytes + nextLen;
4524                         cValue++;
4525                     }
4526                 }
4527                 if (ret)
4528                 {
4529                     CRYPT_SEQUENCE_OF_ANY *seq;
4530                     BYTE *nextPtr;
4531                     DWORD i;
4532
4533                     if (!pvStructInfo)
4534                         *pcbStructInfo = bytesNeeded;
4535                     else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4536                      pvStructInfo, pcbStructInfo, bytesNeeded)))
4537                     {
4538                         if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4539                             pvStructInfo = *(BYTE **)pvStructInfo;
4540                         seq = pvStructInfo;
4541                         seq->cValue = cValue;
4542                         seq->rgValue = (CRYPT_DER_BLOB *)((BYTE *)seq +
4543                          sizeof(*seq));
4544                         nextPtr = (BYTE *)seq->rgValue +
4545                          cValue * sizeof(CRYPT_DER_BLOB);
4546                         ptr = pbEncoded + 1 + lenBytes;
4547                         remainingLen = dataLen;
4548                         i = 0;
4549                         while (ret && remainingLen)
4550                         {
4551                             DWORD nextLen;
4552
4553                             ret = CRYPT_GetLen(ptr, remainingLen, &nextLen);
4554                             if (ret)
4555                             {
4556                                 DWORD nextLenBytes = GET_LEN_BYTES(ptr[1]);
4557
4558                                 seq->rgValue[i].cbData = 1 + nextLenBytes +
4559                                  nextLen;
4560                                 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
4561                                     seq->rgValue[i].pbData = (BYTE *)ptr;
4562                                 else
4563                                 {
4564                                     seq->rgValue[i].pbData = nextPtr;
4565                                     memcpy(nextPtr, ptr, 1 + nextLenBytes +
4566                                      nextLen);
4567                                     nextPtr += 1 + nextLenBytes + nextLen;
4568                                 }
4569                                 remainingLen -= 1 + nextLenBytes + nextLen;
4570                                 ptr += 1 + nextLenBytes + nextLen;
4571                                 i++;
4572                             }
4573                         }
4574                     }
4575                 }
4576             }
4577         }
4578         else
4579         {
4580             SetLastError(CRYPT_E_ASN1_BADTAG);
4581             ret = FALSE;
4582         }
4583     }
4584     __EXCEPT_PAGE_FAULT
4585     {
4586         SetLastError(STATUS_ACCESS_VIOLATION);
4587         ret = FALSE;
4588     }
4589     __ENDTRY
4590     return ret;
4591 }
4592
4593 static BOOL CRYPT_AsnDecodeDistPointName(const BYTE *pbEncoded,
4594  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4595  DWORD *pcbDecoded)
4596 {
4597     BOOL ret;
4598
4599     if (pbEncoded[0] == (ASN_CONTEXT | ASN_CONSTRUCTOR | 0))
4600     {
4601         DWORD bytesNeeded, dataLen;
4602
4603         if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
4604         {
4605             struct AsnArrayDescriptor arrayDesc = {
4606              ASN_CONTEXT | ASN_CONSTRUCTOR | 0, CRYPT_AsnDecodeAltNameEntry,
4607              sizeof(CERT_ALT_NAME_ENTRY), TRUE,
4608              offsetof(CERT_ALT_NAME_ENTRY, u.pwszURL) };
4609             BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
4610             DWORD nameLen;
4611
4612             if (dataLen)
4613             {
4614                 ret = CRYPT_AsnDecodeArray(&arrayDesc,
4615                  pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
4616                  0, NULL, NULL, &nameLen, NULL, NULL);
4617                 /* The CERT_ALT_NAME_INFO's size is included by CRYPT_AsnDecodeArray
4618                  * as the sizeof(struct GenericArray), so don't include it in the
4619                  * total bytes needed.
4620                  */
4621                 bytesNeeded = sizeof(CRL_DIST_POINT_NAME) + nameLen -
4622                  sizeof(CERT_ALT_NAME_INFO);
4623             }
4624             else
4625                 bytesNeeded = sizeof(CRL_DIST_POINT_NAME);
4626             if (pcbDecoded)
4627                 *pcbDecoded = 1 + lenBytes + dataLen;
4628             if (!pvStructInfo)
4629                 *pcbStructInfo = bytesNeeded;
4630             else if (*pcbStructInfo < bytesNeeded)
4631             {
4632                 *pcbStructInfo = bytesNeeded;
4633                 SetLastError(ERROR_MORE_DATA);
4634                 ret = FALSE;
4635             }
4636             else
4637             {
4638                 CRL_DIST_POINT_NAME *name = pvStructInfo;
4639
4640                 *pcbStructInfo = bytesNeeded;
4641                 if (dataLen)
4642                 {
4643                     name->dwDistPointNameChoice = CRL_DIST_POINT_FULL_NAME;
4644                     ret = CRYPT_AsnDecodeArray(&arrayDesc,
4645                      pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
4646                      0, NULL, &name->u.FullName, &nameLen, NULL,
4647                      name->u.FullName.rgAltEntry);
4648                 }
4649                 else
4650                     name->dwDistPointNameChoice = CRL_DIST_POINT_NO_NAME;
4651             }
4652         }
4653     }
4654     else
4655     {
4656         SetLastError(CRYPT_E_ASN1_BADTAG);
4657         ret = FALSE;
4658     }
4659     return ret;
4660 }
4661
4662 static BOOL CRYPT_AsnDecodeDistPoint(const BYTE *pbEncoded, DWORD cbEncoded,
4663  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
4664 {
4665     struct AsnDecodeSequenceItem items[] = {
4666      { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CRL_DIST_POINT,
4667        DistPointName), CRYPT_AsnDecodeDistPointName,
4668        sizeof(CRL_DIST_POINT_NAME), TRUE, TRUE, offsetof(CRL_DIST_POINT,
4669        DistPointName.u.FullName.rgAltEntry), 0 },
4670      { ASN_CONTEXT | 1, offsetof(CRL_DIST_POINT, ReasonFlags),
4671        CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
4672        offsetof(CRL_DIST_POINT, ReasonFlags.pbData), 0 },
4673      { ASN_CONTEXT | ASN_CONSTRUCTOR | 2, offsetof(CRL_DIST_POINT, CRLIssuer),
4674        CRYPT_AsnDecodeAltNameInternal, sizeof(CERT_ALT_NAME_INFO), TRUE, TRUE,
4675        offsetof(CRL_DIST_POINT, CRLIssuer.rgAltEntry), 0 },
4676     };
4677     CRL_DIST_POINT *point = pvStructInfo;
4678     BOOL ret;
4679
4680     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4681      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
4682      pcbDecoded, point ? point->DistPointName.u.FullName.rgAltEntry : NULL);
4683     return ret;
4684 }
4685
4686 static BOOL WINAPI CRYPT_AsnDecodeCRLDistPoints(DWORD dwCertEncodingType,
4687  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4688  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4689 {
4690     BOOL ret;
4691
4692     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4693      pDecodePara, pvStructInfo, *pcbStructInfo);
4694
4695     __TRY
4696     {
4697         struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
4698          CRYPT_AsnDecodeDistPoint, sizeof(CRL_DIST_POINT), TRUE,
4699          offsetof(CRL_DIST_POINT, DistPointName.u.FullName.rgAltEntry) };
4700
4701         ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
4702          pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
4703     }
4704     __EXCEPT_PAGE_FAULT
4705     {
4706         SetLastError(STATUS_ACCESS_VIOLATION);
4707         ret = FALSE;
4708     }
4709     __ENDTRY
4710     return ret;
4711 }
4712
4713 static BOOL WINAPI CRYPT_AsnDecodeEnhancedKeyUsage(DWORD dwCertEncodingType,
4714  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4715  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4716 {
4717     BOOL ret;
4718
4719     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4720      pDecodePara, pvStructInfo, *pcbStructInfo);
4721
4722     __TRY
4723     {
4724         struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
4725          CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), TRUE, 0 };
4726
4727         ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
4728          pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
4729     }
4730     __EXCEPT_PAGE_FAULT
4731     {
4732         SetLastError(STATUS_ACCESS_VIOLATION);
4733         ret = FALSE;
4734     }
4735     __ENDTRY
4736     return ret;
4737 }
4738
4739 static BOOL WINAPI CRYPT_AsnDecodeIssuingDistPoint(DWORD dwCertEncodingType,
4740  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4741  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4742 {
4743     BOOL ret;
4744
4745     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4746      pDecodePara, pvStructInfo, *pcbStructInfo);
4747
4748     __TRY
4749     {
4750         struct AsnDecodeSequenceItem items[] = {
4751          { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CRL_ISSUING_DIST_POINT,
4752            DistPointName), CRYPT_AsnDecodeDistPointName,
4753            sizeof(CRL_DIST_POINT_NAME), TRUE, TRUE,
4754            offsetof(CRL_ISSUING_DIST_POINT,
4755            DistPointName.u.FullName.rgAltEntry), 0 },
4756          { ASN_CONTEXT | 1, offsetof(CRL_ISSUING_DIST_POINT,
4757            fOnlyContainsUserCerts), CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE,
4758            FALSE, 0 },
4759          { ASN_CONTEXT | 2, offsetof(CRL_ISSUING_DIST_POINT,
4760            fOnlyContainsCACerts), CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE,
4761            FALSE, 0 },
4762          { ASN_CONTEXT | 3, offsetof(CRL_ISSUING_DIST_POINT,
4763            OnlySomeReasonFlags), CRYPT_AsnDecodeBitsInternal,
4764            sizeof(CRYPT_BIT_BLOB), TRUE, TRUE, offsetof(CRL_ISSUING_DIST_POINT,
4765            OnlySomeReasonFlags.pbData), 0 },
4766          { ASN_CONTEXT | 4, offsetof(CRL_ISSUING_DIST_POINT,
4767            fIndirectCRL), CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE, FALSE, 0 },
4768         };
4769
4770         ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4771          pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
4772          pcbStructInfo, NULL, NULL);
4773     }
4774     __EXCEPT_PAGE_FAULT
4775     {
4776         SetLastError(STATUS_ACCESS_VIOLATION);
4777         ret = FALSE;
4778     }
4779     __ENDTRY
4780     return ret;
4781 }
4782
4783 static BOOL CRYPT_AsnDecodeMaximum(const BYTE *pbEncoded,
4784  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4785  DWORD *pcbDecoded)
4786 {
4787     BOOL ret = FALSE;
4788
4789     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
4790      pvStructInfo, *pcbStructInfo, pcbDecoded);
4791
4792     if (!cbEncoded)
4793     {
4794         SetLastError(CRYPT_E_ASN1_EOD);
4795         return FALSE;
4796     }
4797     if (pbEncoded[0] != (ASN_CONTEXT | 1))
4798     {
4799         SetLastError(CRYPT_E_ASN1_BADTAG);
4800         return FALSE;
4801     }
4802     /* The BOOL is implicit:  if the integer is present, then it's TRUE */
4803     ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags,
4804      pvStructInfo ? (BYTE *)pvStructInfo + sizeof(BOOL) : NULL, pcbStructInfo,
4805      pcbDecoded);
4806     if (ret && pvStructInfo)
4807         *(BOOL *)pvStructInfo = TRUE;
4808     TRACE("returning %d\n", ret);
4809     return ret;
4810 }
4811
4812 static BOOL CRYPT_AsnDecodeSubtree(const BYTE *pbEncoded,
4813  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4814  DWORD *pcbDecoded)
4815 {
4816     BOOL ret;
4817     struct AsnDecodeSequenceItem items[] = {
4818      { 0, offsetof(CERT_GENERAL_SUBTREE, Base),
4819        CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), TRUE, TRUE,
4820        offsetof(CERT_ALT_NAME_ENTRY, u.pwszURL), 0 },
4821      { ASN_CONTEXT | 0, offsetof(CERT_GENERAL_SUBTREE, dwMinimum),
4822        CRYPT_AsnDecodeIntInternal, sizeof(DWORD), TRUE, FALSE, 0, 0 },
4823      { ASN_CONTEXT | 1, offsetof(CERT_GENERAL_SUBTREE, fMaximum),
4824        CRYPT_AsnDecodeMaximum, sizeof(BOOL) + sizeof(DWORD), TRUE, FALSE, 0,
4825        0 },
4826     };
4827     CERT_GENERAL_SUBTREE *subtree = pvStructInfo;
4828
4829     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
4830      pvStructInfo, *pcbStructInfo, pcbDecoded);
4831
4832     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4833      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
4834      pcbDecoded, subtree ? subtree->Base.u.pwszURL : NULL);
4835     if (pcbDecoded)
4836     {
4837         TRACE("%d\n", *pcbDecoded);
4838         if (*pcbDecoded < cbEncoded)
4839             TRACE("%02x %02x\n", *(pbEncoded + *pcbDecoded),
4840              *(pbEncoded + *pcbDecoded + 1));
4841     }
4842     TRACE("returning %d\n", ret);
4843     return ret;
4844 }
4845
4846 static BOOL CRYPT_AsnDecodeSubtreeArray(const BYTE *pbEncoded,
4847  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4848  DWORD *pcbDecoded)
4849 {
4850     BOOL ret = TRUE;
4851     struct AsnArrayDescriptor arrayDesc = { 0,
4852      CRYPT_AsnDecodeSubtree, sizeof(CERT_GENERAL_SUBTREE), TRUE,
4853      offsetof(CERT_GENERAL_SUBTREE, Base.u.pwszURL) };
4854     struct GenericArray *array = pvStructInfo;
4855
4856     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
4857      pvStructInfo, *pcbStructInfo, pcbDecoded);
4858
4859     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
4860      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
4861      array ? array->rgItems : NULL);
4862     return ret;
4863 }
4864
4865
4866 static BOOL WINAPI CRYPT_AsnDecodeNameConstraints(DWORD dwCertEncodingType,
4867  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4868  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4869 {
4870     BOOL ret = FALSE;
4871
4872     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4873      pDecodePara, pvStructInfo, *pcbStructInfo);
4874
4875     __TRY
4876     {
4877         struct AsnDecodeSequenceItem items[] = {
4878          { ASN_CONTEXT | ASN_CONSTRUCTOR | 0,
4879            offsetof(CERT_NAME_CONSTRAINTS_INFO, cPermittedSubtree),
4880            CRYPT_AsnDecodeSubtreeArray, sizeof(struct GenericArray), TRUE, TRUE,
4881            offsetof(CERT_NAME_CONSTRAINTS_INFO, rgPermittedSubtree), 0 },
4882          { ASN_CONTEXT | ASN_CONSTRUCTOR | 1,
4883            offsetof(CERT_NAME_CONSTRAINTS_INFO, cExcludedSubtree),
4884            CRYPT_AsnDecodeSubtreeArray, sizeof(struct GenericArray), TRUE, TRUE,
4885            offsetof(CERT_NAME_CONSTRAINTS_INFO, rgExcludedSubtree), 0 },
4886         };
4887
4888         ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4889          pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
4890          pcbStructInfo, NULL, NULL);
4891     }
4892     __EXCEPT_PAGE_FAULT
4893     {
4894         SetLastError(STATUS_ACCESS_VIOLATION);
4895     }
4896     __ENDTRY
4897     return ret;
4898 }
4899
4900 static BOOL CRYPT_AsnDecodeIssuerSerialNumber(const BYTE *pbEncoded,
4901  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4902  DWORD *pcbDecoded)
4903 {
4904     BOOL ret;
4905     struct AsnDecodeSequenceItem items[] = {
4906      { 0, offsetof(CERT_ISSUER_SERIAL_NUMBER, Issuer), CRYPT_AsnDecodeDerBlob,
4907        sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CERT_ISSUER_SERIAL_NUMBER,
4908        Issuer.pbData) },
4909      { ASN_INTEGER, offsetof(CERT_ISSUER_SERIAL_NUMBER, SerialNumber),
4910        CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), FALSE,
4911        TRUE, offsetof(CERT_ISSUER_SERIAL_NUMBER, SerialNumber.pbData), 0 },
4912     };
4913     CERT_ISSUER_SERIAL_NUMBER *issuerSerial = pvStructInfo;
4914
4915     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
4916      pvStructInfo, *pcbStructInfo, pcbDecoded);
4917
4918     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4919      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
4920      pcbDecoded, issuerSerial ? issuerSerial->Issuer.pbData : NULL);
4921     if (ret && issuerSerial && !issuerSerial->SerialNumber.cbData)
4922     {
4923         SetLastError(CRYPT_E_ASN1_CORRUPT);
4924         ret = FALSE;
4925     }
4926     TRACE("returning %d\n", ret);
4927     return ret;
4928 }
4929
4930 static BOOL CRYPT_AsnDecodePKCSSignerInfoInternal(const BYTE *pbEncoded,
4931  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
4932  DWORD *pcbDecoded)
4933 {
4934     CMSG_SIGNER_INFO *info = pvStructInfo;
4935     struct AsnDecodeSequenceItem items[] = {
4936      { ASN_INTEGER, offsetof(CMSG_SIGNER_INFO, dwVersion),
4937        CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
4938      { ASN_SEQUENCEOF, offsetof(CMSG_SIGNER_INFO, Issuer),
4939        CRYPT_AsnDecodeIssuerSerialNumber, sizeof(CERT_ISSUER_SERIAL_NUMBER),
4940        FALSE, TRUE, offsetof(CMSG_SIGNER_INFO, Issuer.pbData), 0 },
4941      { ASN_SEQUENCEOF, offsetof(CMSG_SIGNER_INFO, HashAlgorithm),
4942        CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
4943        FALSE, TRUE, offsetof(CMSG_SIGNER_INFO, HashAlgorithm.pszObjId), 0 },
4944      { ASN_CONSTRUCTOR | ASN_CONTEXT | 0,
4945        offsetof(CMSG_SIGNER_INFO, AuthAttrs),
4946        CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
4947        TRUE, TRUE, offsetof(CMSG_SIGNER_INFO, AuthAttrs.rgAttr), 0 },
4948      { ASN_SEQUENCEOF, offsetof(CMSG_SIGNER_INFO, HashEncryptionAlgorithm),
4949        CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
4950        FALSE, TRUE, offsetof(CMSG_SIGNER_INFO,
4951        HashEncryptionAlgorithm.pszObjId), 0 },
4952      { ASN_OCTETSTRING, offsetof(CMSG_SIGNER_INFO, EncryptedHash),
4953        CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_DER_BLOB),
4954        FALSE, TRUE, offsetof(CMSG_SIGNER_INFO, EncryptedHash.pbData), 0 },
4955      { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
4956        offsetof(CMSG_SIGNER_INFO, UnauthAttrs),
4957        CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
4958        TRUE, TRUE, offsetof(CMSG_SIGNER_INFO, UnauthAttrs.rgAttr), 0 },
4959     };
4960     BOOL ret;
4961
4962     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4963      pvStructInfo, *pcbStructInfo);
4964
4965     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
4966      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
4967      pcbDecoded, info ? info->Issuer.pbData : NULL);
4968     return ret;
4969 }
4970
4971 static BOOL WINAPI CRYPT_AsnDecodePKCSSignerInfo(DWORD dwCertEncodingType,
4972  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
4973  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
4974 {
4975     BOOL ret = FALSE;
4976
4977     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
4978      pDecodePara, pvStructInfo, *pcbStructInfo);
4979
4980     __TRY
4981     {
4982         ret = CRYPT_AsnDecodePKCSSignerInfoInternal(pbEncoded, cbEncoded,
4983          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
4984         if (ret && pvStructInfo)
4985         {
4986             ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
4987              pcbStructInfo, *pcbStructInfo);
4988             if (ret)
4989             {
4990                 CMSG_SIGNER_INFO *info;
4991
4992                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4993                     pvStructInfo = *(BYTE **)pvStructInfo;
4994                 info = pvStructInfo;
4995                 info->Issuer.pbData = ((BYTE *)info +
4996                  sizeof(CMSG_SIGNER_INFO));
4997                 ret = CRYPT_AsnDecodePKCSSignerInfoInternal(pbEncoded,
4998                  cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
4999                  pcbStructInfo, NULL);
5000             }
5001         }
5002     }
5003     __EXCEPT_PAGE_FAULT
5004     {
5005         SetLastError(STATUS_ACCESS_VIOLATION);
5006     }
5007     __ENDTRY
5008     TRACE("returning %d\n", ret);
5009     return ret;
5010 }
5011
5012 static BOOL CRYPT_AsnDecodeCMSSignerId(const BYTE *pbEncoded,
5013  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
5014  DWORD *pcbDecoded)
5015 {
5016     CERT_ID *id = pvStructInfo;
5017     BOOL ret = FALSE;
5018
5019     if (*pbEncoded == ASN_SEQUENCEOF)
5020     {
5021         ret = CRYPT_AsnDecodeIssuerSerialNumber(pbEncoded, cbEncoded, dwFlags,
5022          id ? &id->u.IssuerSerialNumber : NULL, pcbStructInfo, pcbDecoded);
5023         if (ret)
5024         {
5025             if (id)
5026                 id->dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
5027             if (*pcbStructInfo > sizeof(CERT_ISSUER_SERIAL_NUMBER))
5028                 *pcbStructInfo = sizeof(CERT_ID) + *pcbStructInfo -
5029                  sizeof(CERT_ISSUER_SERIAL_NUMBER);
5030             else
5031                 *pcbStructInfo = sizeof(CERT_ID);
5032         }
5033     }
5034     else if (*pbEncoded == (ASN_CONTEXT | 0))
5035     {
5036         ret = CRYPT_AsnDecodeOctetsInternal(pbEncoded, cbEncoded, dwFlags,
5037          id ? &id->u.KeyId : NULL, pcbStructInfo, pcbDecoded);
5038         if (ret)
5039         {
5040             if (id)
5041                 id->dwIdChoice = CERT_ID_KEY_IDENTIFIER;
5042             if (*pcbStructInfo > sizeof(CRYPT_DATA_BLOB))
5043                 *pcbStructInfo = sizeof(CERT_ID) + *pcbStructInfo -
5044                  sizeof(CRYPT_DATA_BLOB);
5045             else
5046                 *pcbStructInfo = sizeof(CERT_ID);
5047         }
5048     }
5049     else
5050         SetLastError(CRYPT_E_ASN1_BADTAG);
5051     return ret;
5052 }
5053
5054 static BOOL CRYPT_AsnDecodeCMSSignerInfoInternal(const BYTE *pbEncoded,
5055  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
5056  DWORD *pcbDecoded)
5057 {
5058     CMSG_CMS_SIGNER_INFO *info = pvStructInfo;
5059     struct AsnDecodeSequenceItem items[] = {
5060      { ASN_INTEGER, offsetof(CMSG_CMS_SIGNER_INFO, dwVersion),
5061        CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
5062      { 0, offsetof(CMSG_CMS_SIGNER_INFO, SignerId),
5063        CRYPT_AsnDecodeCMSSignerId, sizeof(CERT_ID), FALSE, TRUE,
5064        offsetof(CMSG_CMS_SIGNER_INFO, SignerId.u.KeyId.pbData), 0 },
5065      { ASN_SEQUENCEOF, offsetof(CMSG_CMS_SIGNER_INFO, HashAlgorithm),
5066        CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
5067        FALSE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, HashAlgorithm.pszObjId), 0 },
5068      { ASN_CONSTRUCTOR | ASN_CONTEXT | 0,
5069        offsetof(CMSG_CMS_SIGNER_INFO, AuthAttrs),
5070        CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
5071        TRUE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, AuthAttrs.rgAttr), 0 },
5072      { ASN_SEQUENCEOF, offsetof(CMSG_CMS_SIGNER_INFO, HashEncryptionAlgorithm),
5073        CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
5074        FALSE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO,
5075        HashEncryptionAlgorithm.pszObjId), 0 },
5076      { ASN_OCTETSTRING, offsetof(CMSG_CMS_SIGNER_INFO, EncryptedHash),
5077        CRYPT_AsnDecodeOctetsInternal, sizeof(CRYPT_DER_BLOB),
5078        FALSE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, EncryptedHash.pbData), 0 },
5079      { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
5080        offsetof(CMSG_CMS_SIGNER_INFO, UnauthAttrs),
5081        CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
5082        TRUE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, UnauthAttrs.rgAttr), 0 },
5083     };
5084     BOOL ret;
5085
5086     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
5087      pvStructInfo, *pcbStructInfo);
5088
5089     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
5090      pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
5091      pcbDecoded, info ? info->SignerId.u.KeyId.pbData : NULL);
5092     return ret;
5093 }
5094
5095 static BOOL WINAPI CRYPT_AsnDecodeCMSSignerInfo(DWORD dwCertEncodingType,
5096  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
5097  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
5098 {
5099     BOOL ret = FALSE;
5100
5101     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
5102      pDecodePara, pvStructInfo, *pcbStructInfo);
5103
5104     __TRY
5105     {
5106         ret = CRYPT_AsnDecodeCMSSignerInfoInternal(pbEncoded, cbEncoded,
5107          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
5108         if (ret && pvStructInfo)
5109         {
5110             ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
5111              pcbStructInfo, *pcbStructInfo);
5112             if (ret)
5113             {
5114                 CMSG_CMS_SIGNER_INFO *info;
5115
5116                 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
5117                     pvStructInfo = *(BYTE **)pvStructInfo;
5118                 info = pvStructInfo;
5119                 info->SignerId.u.KeyId.pbData = ((BYTE *)info +
5120                  sizeof(CMSG_CMS_SIGNER_INFO));
5121                 ret = CRYPT_AsnDecodeCMSSignerInfoInternal(pbEncoded,
5122                  cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
5123                  pcbStructInfo, NULL);
5124             }
5125         }
5126     }
5127     __EXCEPT_PAGE_FAULT
5128     {
5129         SetLastError(STATUS_ACCESS_VIOLATION);
5130     }
5131     __ENDTRY
5132     TRACE("returning %d\n", ret);
5133     return ret;
5134 }
5135
5136 static BOOL CRYPT_DecodeSignerArray(const BYTE *pbEncoded, DWORD cbEncoded,
5137  DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
5138 {
5139     BOOL ret;
5140     struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
5141      CRYPT_AsnDecodeCMSSignerInfoInternal, sizeof(CMSG_CMS_SIGNER_INFO), TRUE,
5142      offsetof(CMSG_CMS_SIGNER_INFO, SignerId.u.KeyId.pbData) };
5143     struct GenericArray *array = pvStructInfo;
5144
5145     TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
5146      pvStructInfo, *pcbStructInfo, pcbDecoded);
5147
5148     ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
5149      NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
5150      array ? array->rgItems : NULL);
5151     return ret;
5152 }
5153
5154 BOOL CRYPT_AsnDecodeCMSSignedInfo(const BYTE *pbEncoded, DWORD cbEncoded,
5155  DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
5156  CRYPT_SIGNED_INFO *signedInfo, DWORD *pcbSignedInfo)
5157 {
5158     BOOL ret = FALSE;
5159     struct AsnDecodeSequenceItem items[] = {
5160      { ASN_INTEGER, offsetof(CRYPT_SIGNED_INFO, version),
5161        CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
5162      /* Placeholder for the hash algorithms - redundant with those in the
5163       * signers, so just ignore them.
5164       */
5165      { ASN_CONSTRUCTOR | ASN_SETOF, 0, NULL, 0, TRUE, FALSE, 0, 0 },
5166      { ASN_SEQUENCE, offsetof(CRYPT_SIGNED_INFO, content),
5167        CRYPT_AsnDecodePKCSContentInfoInternal, sizeof(CRYPT_CONTENT_INFO),
5168        FALSE, TRUE, offsetof(CRYPT_SIGNED_INFO, content.pszObjId), 0 },
5169      { ASN_CONSTRUCTOR | ASN_CONTEXT | 0,
5170        offsetof(CRYPT_SIGNED_INFO, cCertEncoded),
5171        CRYPT_DecodeDERArray, sizeof(struct GenericArray), TRUE, TRUE,
5172        offsetof(CRYPT_SIGNED_INFO, rgCertEncoded), 0 },
5173      { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
5174        offsetof(CRYPT_SIGNED_INFO, cCrlEncoded), CRYPT_DecodeDERArray,
5175        sizeof(struct GenericArray), TRUE, TRUE,
5176        offsetof(CRYPT_SIGNED_INFO, rgCrlEncoded), 0 },
5177      { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CRYPT_SIGNED_INFO, cSignerInfo),
5178        CRYPT_DecodeSignerArray, sizeof(struct GenericArray), TRUE, TRUE,
5179        offsetof(CRYPT_SIGNED_INFO, rgSignerInfo), 0 },
5180     };
5181
5182     TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
5183      pDecodePara, signedInfo, *pcbSignedInfo);
5184
5185     ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
5186      pbEncoded, cbEncoded, dwFlags, pDecodePara, signedInfo, pcbSignedInfo,
5187      NULL, NULL);
5188     TRACE("returning %d\n", ret);
5189     return ret;
5190 }
5191
5192 static CryptDecodeObjectExFunc CRYPT_GetBuiltinDecoder(DWORD dwCertEncodingType,
5193  LPCSTR lpszStructType)
5194 {
5195     CryptDecodeObjectExFunc decodeFunc = NULL;
5196
5197     if ((dwCertEncodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING
5198      && (dwCertEncodingType & CMSG_ENCODING_TYPE_MASK) != PKCS_7_ASN_ENCODING)
5199     {
5200         SetLastError(ERROR_FILE_NOT_FOUND);
5201         return NULL;
5202     }
5203     if (!HIWORD(lpszStructType))
5204     {
5205         switch (LOWORD(lpszStructType))
5206         {
5207         case LOWORD(X509_CERT):
5208             decodeFunc = CRYPT_AsnDecodeCertSignedContent;
5209             break;
5210         case LOWORD(X509_CERT_TO_BE_SIGNED):
5211             decodeFunc = CRYPT_AsnDecodeCert;
5212             break;
5213         case LOWORD(X509_CERT_CRL_TO_BE_SIGNED):
5214             decodeFunc = CRYPT_AsnDecodeCRL;
5215             break;
5216         case LOWORD(X509_EXTENSIONS):
5217             decodeFunc = CRYPT_AsnDecodeExtensions;
5218             break;
5219         case LOWORD(X509_NAME_VALUE):
5220             decodeFunc = CRYPT_AsnDecodeNameValue;
5221             break;
5222         case LOWORD(X509_NAME):
5223             decodeFunc = CRYPT_AsnDecodeName;
5224             break;
5225         case LOWORD(X509_PUBLIC_KEY_INFO):
5226             decodeFunc = CRYPT_AsnDecodePubKeyInfo;
5227             break;
5228         case LOWORD(X509_AUTHORITY_KEY_ID):
5229             decodeFunc = CRYPT_AsnDecodeAuthorityKeyId;
5230             break;
5231         case LOWORD(X509_ALTERNATE_NAME):
5232             decodeFunc = CRYPT_AsnDecodeAltName;
5233             break;
5234         case LOWORD(X509_BASIC_CONSTRAINTS):
5235             decodeFunc = CRYPT_AsnDecodeBasicConstraints;
5236             break;
5237         case LOWORD(X509_BASIC_CONSTRAINTS2):
5238             decodeFunc = CRYPT_AsnDecodeBasicConstraints2;
5239             break;
5240         case LOWORD(X509_CERT_POLICIES):
5241             decodeFunc = CRYPT_AsnDecodeCertPolicies;
5242             break;
5243         case LOWORD(RSA_CSP_PUBLICKEYBLOB):
5244             decodeFunc = CRYPT_AsnDecodeRsaPubKey;
5245             break;
5246         case LOWORD(X509_UNICODE_NAME):
5247             decodeFunc = CRYPT_AsnDecodeUnicodeName;
5248             break;
5249         case LOWORD(PKCS_ATTRIBUTE):
5250             decodeFunc = CRYPT_AsnDecodePKCSAttribute;
5251             break;
5252         case LOWORD(X509_UNICODE_NAME_VALUE):
5253             decodeFunc = CRYPT_AsnDecodeUnicodeNameValue;
5254             break;
5255         case LOWORD(X509_OCTET_STRING):
5256             decodeFunc = CRYPT_AsnDecodeOctets;
5257             break;
5258         case LOWORD(X509_BITS):
5259         case LOWORD(X509_KEY_USAGE):
5260             decodeFunc = CRYPT_AsnDecodeBits;
5261             break;
5262         case LOWORD(X509_INTEGER):
5263             decodeFunc = CRYPT_AsnDecodeInt;
5264             break;
5265         case LOWORD(X509_MULTI_BYTE_INTEGER):
5266             decodeFunc = CRYPT_AsnDecodeInteger;
5267             break;
5268         case LOWORD(X509_MULTI_BYTE_UINT):
5269             decodeFunc = CRYPT_AsnDecodeUnsignedInteger;
5270             break;
5271         case LOWORD(X509_ENUMERATED):
5272             decodeFunc = CRYPT_AsnDecodeEnumerated;
5273             break;
5274         case LOWORD(X509_CHOICE_OF_TIME):
5275             decodeFunc = CRYPT_AsnDecodeChoiceOfTime;
5276             break;
5277         case LOWORD(X509_AUTHORITY_KEY_ID2):
5278             decodeFunc = CRYPT_AsnDecodeAuthorityKeyId2;
5279             break;
5280         case LOWORD(X509_AUTHORITY_INFO_ACCESS):
5281             decodeFunc = CRYPT_AsnDecodeAuthorityInfoAccess;
5282             break;
5283         case LOWORD(PKCS_CONTENT_INFO):
5284             decodeFunc = CRYPT_AsnDecodePKCSContentInfo;
5285             break;
5286         case LOWORD(X509_SEQUENCE_OF_ANY):
5287             decodeFunc = CRYPT_AsnDecodeSequenceOfAny;
5288             break;
5289         case LOWORD(PKCS_UTC_TIME):
5290             decodeFunc = CRYPT_AsnDecodeUtcTime;
5291             break;
5292         case LOWORD(X509_CRL_DIST_POINTS):
5293             decodeFunc = CRYPT_AsnDecodeCRLDistPoints;
5294             break;
5295         case LOWORD(X509_ENHANCED_KEY_USAGE):
5296             decodeFunc = CRYPT_AsnDecodeEnhancedKeyUsage;
5297             break;
5298         case LOWORD(PKCS_CTL):
5299             decodeFunc = CRYPT_AsnDecodeCTL;
5300             break;
5301         case LOWORD(PKCS_SMIME_CAPABILITIES):
5302             decodeFunc = CRYPT_AsnDecodeSMIMECapabilities;
5303             break;
5304         case LOWORD(X509_PKIX_POLICY_QUALIFIER_USERNOTICE):
5305             decodeFunc = CRYPT_AsnDecodePolicyQualifierUserNotice;
5306             break;
5307         case LOWORD(PKCS_ATTRIBUTES):
5308             decodeFunc = CRYPT_AsnDecodePKCSAttributes;
5309             break;
5310         case LOWORD(X509_ISSUING_DIST_POINT):
5311             decodeFunc = CRYPT_AsnDecodeIssuingDistPoint;
5312             break;
5313         case LOWORD(X509_NAME_CONSTRAINTS):
5314             decodeFunc = CRYPT_AsnDecodeNameConstraints;
5315             break;
5316         case LOWORD(PKCS7_SIGNER_INFO):
5317             decodeFunc = CRYPT_AsnDecodePKCSSignerInfo;
5318             break;
5319         case LOWORD(CMS_SIGNER_INFO):
5320             decodeFunc = CRYPT_AsnDecodeCMSSignerInfo;
5321             break;
5322         }
5323     }
5324     else if (!strcmp(lpszStructType, szOID_CERT_EXTENSIONS))
5325         decodeFunc = CRYPT_AsnDecodeExtensions;
5326     else if (!strcmp(lpszStructType, szOID_RSA_signingTime))
5327         decodeFunc = CRYPT_AsnDecodeUtcTime;
5328     else if (!strcmp(lpszStructType, szOID_RSA_SMIMECapabilities))
5329         decodeFunc = CRYPT_AsnDecodeSMIMECapabilities;
5330     else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER))
5331         decodeFunc = CRYPT_AsnDecodeAuthorityKeyId;
5332     else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER2))
5333         decodeFunc = CRYPT_AsnDecodeAuthorityKeyId2;
5334     else if (!strcmp(lpszStructType, szOID_CRL_REASON_CODE))
5335         decodeFunc = CRYPT_AsnDecodeEnumerated;
5336     else if (!strcmp(lpszStructType, szOID_KEY_USAGE))
5337         decodeFunc = CRYPT_AsnDecodeBits;
5338     else if (!strcmp(lpszStructType, szOID_SUBJECT_KEY_IDENTIFIER))
5339         decodeFunc = CRYPT_AsnDecodeOctets;
5340     else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS))
5341         decodeFunc = CRYPT_AsnDecodeBasicConstraints;
5342     else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS2))
5343         decodeFunc = CRYPT_AsnDecodeBasicConstraints2;
5344     else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME))
5345         decodeFunc = CRYPT_AsnDecodeAltName;
5346     else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME2))
5347         decodeFunc = CRYPT_AsnDecodeAltName;
5348     else if (!strcmp(lpszStructType, szOID_NEXT_UPDATE_LOCATION))
5349         decodeFunc = CRYPT_AsnDecodeAltName;
5350     else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME))
5351         decodeFunc = CRYPT_AsnDecodeAltName;
5352     else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME2))
5353         decodeFunc = CRYPT_AsnDecodeAltName;
5354     else if (!strcmp(lpszStructType, szOID_CRL_DIST_POINTS))
5355         decodeFunc = CRYPT_AsnDecodeCRLDistPoints;
5356     else if (!strcmp(lpszStructType, szOID_CERT_POLICIES))
5357         decodeFunc = CRYPT_AsnDecodeCertPolicies;
5358     else if (!strcmp(lpszStructType, szOID_ENHANCED_KEY_USAGE))
5359         decodeFunc = CRYPT_AsnDecodeEnhancedKeyUsage;
5360     else if (!strcmp(lpszStructType, szOID_ISSUING_DIST_POINT))
5361         decodeFunc = CRYPT_AsnDecodeIssuingDistPoint;
5362     else if (!strcmp(lpszStructType, szOID_NAME_CONSTRAINTS))
5363         decodeFunc = CRYPT_AsnDecodeNameConstraints;
5364     else if (!strcmp(lpszStructType, szOID_AUTHORITY_INFO_ACCESS))
5365         decodeFunc = CRYPT_AsnDecodeAuthorityInfoAccess;
5366     else if (!strcmp(lpszStructType, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE))
5367         decodeFunc = CRYPT_AsnDecodePolicyQualifierUserNotice;
5368     else if (!strcmp(lpszStructType, szOID_CTL))
5369         decodeFunc = CRYPT_AsnDecodeCTL;
5370     return decodeFunc;
5371 }
5372
5373 static CryptDecodeObjectFunc CRYPT_LoadDecoderFunc(DWORD dwCertEncodingType,
5374  LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
5375 {
5376     static HCRYPTOIDFUNCSET set = NULL;
5377     CryptDecodeObjectFunc decodeFunc = NULL;
5378
5379     if (!set)
5380         set = CryptInitOIDFunctionSet(CRYPT_OID_DECODE_OBJECT_FUNC, 0);
5381     CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
5382      (void **)&decodeFunc, hFunc);
5383     return decodeFunc;
5384 }
5385
5386 static CryptDecodeObjectExFunc CRYPT_LoadDecoderExFunc(DWORD dwCertEncodingType,
5387  LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
5388 {
5389     static HCRYPTOIDFUNCSET set = NULL;
5390     CryptDecodeObjectExFunc decodeFunc = NULL;
5391
5392     if (!set)
5393         set = CryptInitOIDFunctionSet(CRYPT_OID_DECODE_OBJECT_EX_FUNC, 0);
5394     CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
5395      (void **)&decodeFunc, hFunc);
5396     return decodeFunc;
5397 }
5398
5399 BOOL WINAPI CryptDecodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType,
5400  const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo,
5401  DWORD *pcbStructInfo)
5402 {
5403     BOOL ret = FALSE;
5404     CryptDecodeObjectFunc pCryptDecodeObject = NULL;
5405     CryptDecodeObjectExFunc pCryptDecodeObjectEx = NULL;
5406     HCRYPTOIDFUNCADDR hFunc = NULL;
5407
5408     TRACE_(crypt)("(0x%08x, %s, %p, %d, 0x%08x, %p, %p)\n", dwCertEncodingType,
5409      debugstr_a(lpszStructType), pbEncoded, cbEncoded, dwFlags,
5410      pvStructInfo, pcbStructInfo);
5411
5412     if (!pvStructInfo && !pcbStructInfo)
5413     {
5414         SetLastError(ERROR_INVALID_PARAMETER);
5415         return FALSE;
5416     }
5417     if (cbEncoded > MAX_ENCODED_LEN)
5418     {
5419         SetLastError(CRYPT_E_ASN1_LARGE);
5420         return FALSE;
5421     }
5422
5423     if (!(pCryptDecodeObjectEx = CRYPT_GetBuiltinDecoder(dwCertEncodingType,
5424      lpszStructType)))
5425     {
5426         TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n",
5427          debugstr_a(lpszStructType));
5428         pCryptDecodeObject = CRYPT_LoadDecoderFunc(dwCertEncodingType,
5429          lpszStructType, &hFunc);
5430         if (!pCryptDecodeObject)
5431             pCryptDecodeObjectEx = CRYPT_LoadDecoderExFunc(dwCertEncodingType,
5432              lpszStructType, &hFunc);
5433     }
5434     if (pCryptDecodeObject)
5435         ret = pCryptDecodeObject(dwCertEncodingType, lpszStructType,
5436          pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo);
5437     else if (pCryptDecodeObjectEx)
5438         ret = pCryptDecodeObjectEx(dwCertEncodingType, lpszStructType,
5439          pbEncoded, cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL,
5440          pvStructInfo, pcbStructInfo);
5441     if (hFunc)
5442         CryptFreeOIDFunctionAddress(hFunc, 0);
5443     TRACE_(crypt)("returning %d\n", ret);
5444     return ret;
5445 }
5446
5447 BOOL WINAPI CryptDecodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType,
5448  const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
5449  PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
5450 {
5451     BOOL ret = FALSE;
5452     CryptDecodeObjectExFunc decodeFunc;
5453     HCRYPTOIDFUNCADDR hFunc = NULL;
5454
5455     TRACE_(crypt)("(0x%08x, %s, %p, %d, 0x%08x, %p, %p, %p)\n",
5456      dwCertEncodingType, debugstr_a(lpszStructType), pbEncoded,
5457      cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo);
5458
5459     if (!pvStructInfo && !pcbStructInfo)
5460     {
5461         SetLastError(ERROR_INVALID_PARAMETER);
5462         return FALSE;
5463     }
5464     if (cbEncoded > MAX_ENCODED_LEN)
5465     {
5466         SetLastError(CRYPT_E_ASN1_LARGE);
5467         return FALSE;
5468     }
5469
5470     SetLastError(NOERROR);
5471     if (dwFlags & CRYPT_DECODE_ALLOC_FLAG && pvStructInfo)
5472         *(BYTE **)pvStructInfo = NULL;
5473     decodeFunc = CRYPT_GetBuiltinDecoder(dwCertEncodingType, lpszStructType);
5474     if (!decodeFunc)
5475     {
5476         TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n",
5477          debugstr_a(lpszStructType));
5478         decodeFunc = CRYPT_LoadDecoderExFunc(dwCertEncodingType, lpszStructType,
5479          &hFunc);
5480     }
5481     if (decodeFunc)
5482         ret = decodeFunc(dwCertEncodingType, lpszStructType, pbEncoded,
5483          cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo);
5484     else
5485     {
5486         CryptDecodeObjectFunc pCryptDecodeObject =
5487          CRYPT_LoadDecoderFunc(dwCertEncodingType, lpszStructType, &hFunc);
5488
5489         /* Try CryptDecodeObject function.  Don't call CryptDecodeObject
5490          * directly, as that could cause an infinite loop.
5491          */
5492         if (pCryptDecodeObject)
5493         {
5494             if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
5495             {
5496                 ret = pCryptDecodeObject(dwCertEncodingType, lpszStructType,
5497                  pbEncoded, cbEncoded, dwFlags, NULL, pcbStructInfo);
5498                 if (ret && (ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
5499                  pvStructInfo, pcbStructInfo, *pcbStructInfo)))
5500                     ret = pCryptDecodeObject(dwCertEncodingType,
5501                      lpszStructType, pbEncoded, cbEncoded, dwFlags,
5502                      *(BYTE **)pvStructInfo, pcbStructInfo);
5503             }
5504             else
5505                 ret = pCryptDecodeObject(dwCertEncodingType, lpszStructType,
5506                  pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo);
5507         }
5508     }
5509     if (hFunc)
5510         CryptFreeOIDFunctionAddress(hFunc, 0);
5511     TRACE_(crypt)("returning %d\n", ret);
5512     return ret;
5513 }
5514
5515 BOOL WINAPI PFXIsPFXBlob(CRYPT_DATA_BLOB *pPFX)
5516 {
5517     BOOL ret;
5518
5519     TRACE("(%p)\n", pPFX);
5520
5521     /* A PFX blob is an asn.1-encoded sequence, consisting of at least a
5522      * version integer of length 1 (3 encoded byes) and at least one other
5523      * datum (two encoded bytes), plus at least two bytes for the outer
5524      * sequence.  Thus, even an empty PFX blob is at least 7 bytes in length.
5525      */
5526     if (pPFX->cbData < 7)
5527         ret = FALSE;
5528     else if (pPFX->pbData[0] == ASN_SEQUENCE)
5529     {
5530         DWORD len;
5531
5532         if ((ret = CRYPT_GetLengthIndefinite(pPFX->pbData, pPFX->cbData, &len)))
5533         {
5534             BYTE lenLen = GET_LEN_BYTES(pPFX->pbData[1]);
5535
5536             /* Need at least three bytes for the integer version */
5537             if (pPFX->cbData < 1 + lenLen + 3)
5538                 ret = FALSE;
5539             else if (pPFX->pbData[1 + lenLen] != ASN_INTEGER || /* Tag */
5540              pPFX->pbData[1 + lenLen + 1] != 1 ||          /* Definite length */
5541              pPFX->pbData[1 + lenLen + 2] != 3)            /* PFX version */
5542                 ret = FALSE;
5543         }
5544     }
5545     else
5546         ret = FALSE;
5547     return ret;
5548 }