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

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