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