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

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