git.oblomov.eu Git - wine/blob - dlls/wintrust/asn.c

   1 /* wintrust asn functions
   2  *
   3  * Copyright 2007 Juan Lang
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  *
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <assert.h>
  27 #define NONAMELESSUNION
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winerror.h"
  31 #include "wincrypt.h"
  32 #include "wintrust.h"
  33 #include "snmp.h"
  34 #include "winternl.h"
  35 #include "wine/debug.h"
  36 #include "wine/exception.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(cryptasn);
  39
  40 #ifdef WORDS_BIGENDIAN
  41
  42 #define hton16(x) (x)
  43 #define n16toh(x) (x)
  44
  45 #else
  46
  47 #define hton16(x) RtlUshortByteSwap(x)
  48 #define n16toh(x) RtlUshortByteSwap(x)
  49
  50 #endif
  51
  52 #define ASN_BOOL            (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x01)
  53 #define ASN_BITSTRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x03)
  54 #define ASN_BMPSTRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1e)
  55
  56 static BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded)
  57 {
  58     DWORD bytesNeeded, significantBytes = 0;
  59
  60     if (len <= 0x7f)
  61         bytesNeeded = 1;
  62     else
  63     {
  64         DWORD temp;
  65
  66         for (temp = len, significantBytes = sizeof(temp); !(temp & 0xff000000);
  67          temp <<= 8, significantBytes--)
  68             ;
  69         bytesNeeded = significantBytes + 1;
  70     }
  71     if (!pbEncoded)
  72     {
  73         *pcbEncoded = bytesNeeded;
  74         return TRUE;
  75     }
  76     if (*pcbEncoded < bytesNeeded)
  77     {
  78         SetLastError(ERROR_MORE_DATA);
  79         return FALSE;
  80     }
  81     if (len <= 0x7f)
  82         *pbEncoded = (BYTE)len;
  83     else
  84     {
  85         DWORD i;
  86
  87         *pbEncoded++ = significantBytes | 0x80;
  88         for (i = 0; i < significantBytes; i++)
  89         {
  90             *(pbEncoded + significantBytes - i - 1) = (BYTE)(len & 0xff);
  91             len >>= 8;
  92         }
  93     }
  94     *pcbEncoded = bytesNeeded;
  95     return TRUE;
  96 }
  97
  98 static BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
  99  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 100  DWORD *pcbEncoded)
 101 {
 102     BOOL ret = TRUE;
 103     const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo;
 104     DWORD bytesNeeded, lenBytes;
 105
 106     TRACE("(%d, %p), %p, %d\n", blob->cbData, blob->pbData, pbEncoded,
 107      *pcbEncoded);
 108
 109     CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes);
 110     bytesNeeded = 1 + lenBytes + blob->cbData;
 111     if (!pbEncoded)
 112         *pcbEncoded = bytesNeeded;
 113     else if (*pcbEncoded < bytesNeeded)
 114     {
 115         *pcbEncoded = bytesNeeded;
 116         SetLastError(ERROR_MORE_DATA);
 117         ret = FALSE;
 118     }
 119     else
 120     {
 121         *pbEncoded++ = ASN_OCTETSTRING;
 122         CRYPT_EncodeLen(blob->cbData, pbEncoded, &lenBytes);
 123         pbEncoded += lenBytes;
 124         if (blob->cbData)
 125             memcpy(pbEncoded, blob->pbData, blob->cbData);
 126     }
 127     TRACE("returning %d\n", ret);
 128     return ret;
 129 }
 130
 131 BOOL WINAPI WVTAsn1SpcLinkEncode(DWORD dwCertEncodingType,
 132  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 133  DWORD *pcbEncoded)
 134 {
 135     BOOL ret = FALSE;
 136
 137     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
 138      debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
 139      pcbEncoded);
 140
 141     __TRY
 142     {
 143         const SPC_LINK *link = (const SPC_LINK *)pvStructInfo;
 144         DWORD bytesNeeded, lenBytes;
 145
 146         switch (link->dwLinkChoice)
 147         {
 148         case SPC_FILE_LINK_CHOICE:
 149         {
 150             DWORD fileNameLen, fileNameLenBytes;
 151             LPWSTR ptr;
 152
 153             fileNameLen = link->u.pwszFile ?
 154              lstrlenW(link->u.pwszFile) * sizeof(WCHAR) : 0;
 155             CRYPT_EncodeLen(fileNameLen, NULL, &fileNameLenBytes);
 156             CRYPT_EncodeLen(1 + fileNameLenBytes + fileNameLen, NULL,
 157              &lenBytes);
 158             bytesNeeded = 2 + lenBytes + fileNameLenBytes + fileNameLen;
 159             if (!pbEncoded)
 160             {
 161                 *pcbEncoded = bytesNeeded;
 162                 ret = TRUE;
 163             }
 164             else if (*pcbEncoded < bytesNeeded)
 165             {
 166                 SetLastError(ERROR_MORE_DATA);
 167                 *pcbEncoded = bytesNeeded;
 168             }
 169             else
 170             {
 171                 *pcbEncoded = bytesNeeded;
 172                 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_CONTEXT | 2;
 173                 CRYPT_EncodeLen(1 + fileNameLenBytes + fileNameLen, pbEncoded,
 174                  &lenBytes);
 175                 pbEncoded += lenBytes;
 176                 *pbEncoded++ = ASN_CONTEXT;
 177                 CRYPT_EncodeLen(fileNameLen, pbEncoded, &fileNameLenBytes);
 178                 pbEncoded += fileNameLenBytes;
 179                 for (ptr = link->u.pwszFile; ptr && *ptr; ptr++)
 180                 {
 181                     *(WCHAR *)pbEncoded = hton16(*ptr);
 182                     pbEncoded += sizeof(WCHAR);
 183                 }
 184                 ret = TRUE;
 185             }
 186             break;
 187         }
 188         case SPC_MONIKER_LINK_CHOICE:
 189         {
 190             DWORD classIdLenBytes, dataLenBytes, dataLen;
 191             CRYPT_DATA_BLOB classId = { sizeof(link->u.Moniker.ClassId),
 192              (BYTE *)link->u.Moniker.ClassId };
 193
 194             CRYPT_EncodeLen(classId.cbData, NULL, &classIdLenBytes);
 195             CRYPT_EncodeLen(link->u.Moniker.SerializedData.cbData, NULL,
 196              &dataLenBytes);
 197             dataLen = 2 + classIdLenBytes + classId.cbData +
 198              dataLenBytes + link->u.Moniker.SerializedData.cbData;
 199             CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
 200             bytesNeeded = 1 + dataLen + lenBytes;
 201             if (!pbEncoded)
 202             {
 203                 *pcbEncoded = bytesNeeded;
 204                 ret = TRUE;
 205             }
 206             else if (*pcbEncoded < bytesNeeded)
 207             {
 208                 SetLastError(ERROR_MORE_DATA);
 209                 *pcbEncoded = bytesNeeded;
 210             }
 211             else
 212             {
 213                 DWORD size;
 214
 215                 *pcbEncoded = bytesNeeded;
 216                 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_CONTEXT | 1;
 217                 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
 218                 pbEncoded += lenBytes;
 219                 size = 1 + classIdLenBytes + classId.cbData;
 220                 CRYPT_AsnEncodeOctets(X509_ASN_ENCODING, NULL, &classId,
 221                  pbEncoded, &size);
 222                 pbEncoded += size;
 223                 size = 1 + dataLenBytes + link->u.Moniker.SerializedData.cbData;
 224                 CRYPT_AsnEncodeOctets(X509_ASN_ENCODING, NULL,
 225                  &link->u.Moniker.SerializedData, pbEncoded, &size);
 226                 pbEncoded += size;
 227                 ret = TRUE;
 228             }
 229             break;
 230         }
 231         case SPC_URL_LINK_CHOICE:
 232         {
 233             LPWSTR ptr;
 234             DWORD urlLen;
 235
 236             /* Check for invalid characters in URL */
 237             ret = TRUE;
 238             urlLen = 0;
 239             for (ptr = link->u.pwszUrl; ptr && *ptr && ret; ptr++)
 240                 if (*ptr > 0x7f)
 241                 {
 242                     *pcbEncoded = 0;
 243                     SetLastError(CRYPT_E_INVALID_IA5_STRING);
 244                     ret = FALSE;
 245                 }
 246                 else
 247                     urlLen++;
 248             if (ret)
 249             {
 250                 CRYPT_EncodeLen(urlLen, NULL, &lenBytes);
 251                 bytesNeeded = 1 + lenBytes + urlLen;
 252                 if (!pbEncoded)
 253                     *pcbEncoded = bytesNeeded;
 254                 else if (*pcbEncoded < bytesNeeded)
 255                 {
 256                     SetLastError(ERROR_MORE_DATA);
 257                     *pcbEncoded = bytesNeeded;
 258                     ret = FALSE;
 259                 }
 260                 else
 261                 {
 262                     *pcbEncoded = bytesNeeded;
 263                     *pbEncoded++ = ASN_CONTEXT;
 264                     CRYPT_EncodeLen(urlLen, pbEncoded, &lenBytes);
 265                     pbEncoded += lenBytes;
 266                     for (ptr = link->u.pwszUrl; ptr && *ptr; ptr++)
 267                         *pbEncoded++ = (BYTE)*ptr;
 268                 }
 269             }
 270             break;
 271         }
 272         default:
 273             SetLastError(E_INVALIDARG);
 274         }
 275     }
 276     __EXCEPT_PAGE_FAULT
 277     {
 278         SetLastError(STATUS_ACCESS_VIOLATION);
 279     }
 280     __ENDTRY
 281     TRACE("returning %d\n", ret);
 282     return ret;
 283 }
 284
 285 typedef BOOL (WINAPI *CryptEncodeObjectFunc)(DWORD, LPCSTR, const void *,
 286  BYTE *, DWORD *);
 287
 288 struct AsnEncodeSequenceItem
 289 {
 290     const void           *pvStructInfo;
 291     CryptEncodeObjectFunc encodeFunc;
 292     DWORD                 size; /* used during encoding, not for your use */
 293 };
 294
 295 static BOOL CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
 296  struct AsnEncodeSequenceItem items[], DWORD cItem, BYTE *pbEncoded,
 297  DWORD *pcbEncoded)
 298 {
 299     BOOL ret;
 300     DWORD i, dataLen = 0;
 301
 302     TRACE("%p, %d, %p, %d\n", items, cItem, pbEncoded, *pcbEncoded);
 303     for (i = 0, ret = TRUE; ret && i < cItem; i++)
 304     {
 305         ret = items[i].encodeFunc(dwCertEncodingType, NULL,
 306          items[i].pvStructInfo, NULL, &items[i].size);
 307         /* Some functions propagate their errors through the size */
 308         if (!ret)
 309             *pcbEncoded = items[i].size;
 310         dataLen += items[i].size;
 311     }
 312     if (ret)
 313     {
 314         DWORD lenBytes, bytesNeeded;
 315
 316         CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
 317         bytesNeeded = 1 + lenBytes + dataLen;
 318         if (!pbEncoded)
 319             *pcbEncoded = bytesNeeded;
 320         else if (*pcbEncoded < bytesNeeded)
 321         {
 322             *pcbEncoded = bytesNeeded;
 323             SetLastError(ERROR_MORE_DATA);
 324             ret = FALSE;
 325         }
 326         else
 327         {
 328             *pcbEncoded = bytesNeeded;
 329             *pbEncoded++ = ASN_SEQUENCE;
 330             CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
 331             pbEncoded += lenBytes;
 332             for (i = 0; ret && i < cItem; i++)
 333             {
 334                 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
 335                  items[i].pvStructInfo, pbEncoded, &items[i].size);
 336                 /* Some functions propagate their errors through the size */
 337                 if (!ret)
 338                     *pcbEncoded = items[i].size;
 339                 pbEncoded += items[i].size;
 340             }
 341         }
 342     }
 343     TRACE("returning %d\n", ret);
 344     return ret;
 345 }
 346
 347 static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType,
 348  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 349  DWORD *pcbEncoded)
 350 {
 351     BOOL ret = FALSE;
 352
 353     __TRY
 354     {
 355         const CRYPT_BIT_BLOB *blob = (const CRYPT_BIT_BLOB *)pvStructInfo;
 356         DWORD bytesNeeded, lenBytes, dataBytes;
 357         BYTE unusedBits;
 358
 359         /* yep, MS allows cUnusedBits to be >= 8 */
 360         if (!blob->cUnusedBits)
 361         {
 362             dataBytes = blob->cbData;
 363             unusedBits = 0;
 364         }
 365         else if (blob->cbData * 8 > blob->cUnusedBits)
 366         {
 367             dataBytes = (blob->cbData * 8 - blob->cUnusedBits) / 8 + 1;
 368             unusedBits = blob->cUnusedBits >= 8 ? blob->cUnusedBits / 8 :
 369              blob->cUnusedBits;
 370         }
 371         else
 372         {
 373             dataBytes = 0;
 374             unusedBits = 0;
 375         }
 376         CRYPT_EncodeLen(dataBytes + 1, NULL, &lenBytes);
 377         bytesNeeded = 1 + lenBytes + dataBytes + 1;
 378         if (!pbEncoded)
 379         {
 380             *pcbEncoded = bytesNeeded;
 381             ret = TRUE;
 382         }
 383         else if (*pcbEncoded < bytesNeeded)
 384         {
 385             *pcbEncoded = bytesNeeded;
 386             SetLastError(ERROR_MORE_DATA);
 387         }
 388         else
 389         {
 390             ret = TRUE;
 391             *pcbEncoded = bytesNeeded;
 392             *pbEncoded++ = ASN_BITSTRING;
 393             CRYPT_EncodeLen(dataBytes + 1, pbEncoded, &lenBytes);
 394             pbEncoded += lenBytes;
 395             *pbEncoded++ = unusedBits;
 396             if (dataBytes)
 397             {
 398                 BYTE mask = 0xff << unusedBits;
 399
 400                 if (dataBytes > 1)
 401                 {
 402                     memcpy(pbEncoded, blob->pbData, dataBytes - 1);
 403                     pbEncoded += dataBytes - 1;
 404                 }
 405                 *pbEncoded = *(blob->pbData + dataBytes - 1) & mask;
 406             }
 407         }
 408     }
 409     __EXCEPT_PAGE_FAULT
 410     {
 411         SetLastError(STATUS_ACCESS_VIOLATION);
 412     }
 413     __ENDTRY
 414     return ret;
 415 }
 416
 417 struct AsnConstructedItem
 418 {
 419     BYTE                  tag;
 420     const void           *pvStructInfo;
 421     CryptEncodeObjectFunc encodeFunc;
 422 };
 423
 424 static BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType,
 425  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 426  DWORD *pcbEncoded)
 427 {
 428     BOOL ret;
 429     const struct AsnConstructedItem *item =
 430      (const struct AsnConstructedItem *)pvStructInfo;
 431     DWORD len;
 432
 433     if ((ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
 434      item->pvStructInfo, NULL, &len)))
 435     {
 436         DWORD dataLen, bytesNeeded;
 437
 438         CRYPT_EncodeLen(len, NULL, &dataLen);
 439         bytesNeeded = 1 + dataLen + len;
 440         if (!pbEncoded)
 441             *pcbEncoded = bytesNeeded;
 442         else if (*pcbEncoded < bytesNeeded)
 443         {
 444             *pcbEncoded = bytesNeeded;
 445             SetLastError(ERROR_MORE_DATA);
 446             ret = FALSE;
 447         }
 448         else
 449         {
 450             *pcbEncoded = bytesNeeded;
 451             *pbEncoded++ = ASN_CONTEXT | ASN_CONSTRUCTOR | item->tag;
 452             CRYPT_EncodeLen(len, pbEncoded, &dataLen);
 453             pbEncoded += dataLen;
 454             ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
 455              item->pvStructInfo, pbEncoded, &len);
 456             if (!ret)
 457             {
 458                 /* Some functions propagate their errors through the size */
 459                 *pcbEncoded = len;
 460             }
 461         }
 462     }
 463     else
 464     {
 465         /* Some functions propagate their errors through the size */
 466         *pcbEncoded = len;
 467     }
 468     return ret;
 469 }
 470
 471
 472 BOOL WINAPI WVTAsn1SpcPeImageDataEncode(DWORD dwCertEncodingType,
 473  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 474  DWORD *pcbEncoded)
 475 {
 476     const SPC_PE_IMAGE_DATA *imageData =
 477      (const SPC_PE_IMAGE_DATA *)pvStructInfo;
 478     BOOL ret = FALSE;
 479
 480     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
 481      debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
 482      pcbEncoded);
 483
 484     __TRY
 485     {
 486         struct AsnEncodeSequenceItem items[2] = {
 487          { 0 }
 488         };
 489         struct AsnConstructedItem constructed = { 0, imageData->pFile,
 490          WVTAsn1SpcLinkEncode };
 491         DWORD cItem = 0;
 492
 493         if (imageData->Flags.cbData)
 494         {
 495             items[cItem].pvStructInfo = &imageData->Flags;
 496             items[cItem].encodeFunc = CRYPT_AsnEncodeBits;
 497             cItem++;
 498         }
 499         if (imageData->pFile)
 500         {
 501             items[cItem].pvStructInfo = &constructed;
 502             items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
 503             cItem++;
 504         }
 505
 506         ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
 507          pbEncoded, pcbEncoded);
 508     }
 509     __EXCEPT_PAGE_FAULT
 510     {
 511         SetLastError(STATUS_ACCESS_VIOLATION);
 512     }
 513     __ENDTRY
 514     TRACE("returning %d\n", ret);
 515     return ret;
 516 }
 517
 518 static BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
 519  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 520  DWORD *pcbEncoded)
 521 {
 522     LPCSTR pszObjId = (LPCSTR)pvStructInfo;
 523     DWORD bytesNeeded = 0, lenBytes;
 524     BOOL ret = TRUE;
 525     int firstPos = 0;
 526     BYTE firstByte = 0;
 527
 528     TRACE("%s\n", debugstr_a(pszObjId));
 529
 530     if (pszObjId)
 531     {
 532         const char *ptr;
 533         int val1, val2;
 534
 535         if (sscanf(pszObjId, "%d.%d%n", &val1, &val2, &firstPos) != 2)
 536         {
 537             SetLastError(CRYPT_E_ASN1_ERROR);
 538             return FALSE;
 539         }
 540         bytesNeeded++;
 541         firstByte = val1 * 40 + val2;
 542         ptr = pszObjId + firstPos;
 543         if (*ptr == '.')
 544         {
 545             ptr++;
 546             firstPos++;
 547         }
 548         while (ret && *ptr)
 549         {
 550             int pos;
 551
 552             /* note I assume each component is at most 32-bits long in base 2 */
 553             if (sscanf(ptr, "%d%n", &val1, &pos) == 1)
 554             {
 555                 if (val1 >= 0x10000000)
 556                     bytesNeeded += 5;
 557                 else if (val1 >= 0x200000)
 558                     bytesNeeded += 4;
 559                 else if (val1 >= 0x4000)
 560                     bytesNeeded += 3;
 561                 else if (val1 >= 0x80)
 562                     bytesNeeded += 2;
 563                 else
 564                     bytesNeeded += 1;
 565                 ptr += pos;
 566                 if (*ptr == '.')
 567                     ptr++;
 568             }
 569             else
 570             {
 571                 SetLastError(CRYPT_E_ASN1_ERROR);
 572                 return FALSE;
 573             }
 574         }
 575         CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
 576     }
 577     else
 578         lenBytes = 1;
 579     bytesNeeded += 1 + lenBytes;
 580     if (pbEncoded)
 581     {
 582         if (*pcbEncoded < bytesNeeded)
 583         {
 584             SetLastError(ERROR_MORE_DATA);
 585             ret = FALSE;
 586         }
 587         else
 588         {
 589             *pbEncoded++ = ASN_OBJECTIDENTIFIER;
 590             CRYPT_EncodeLen(bytesNeeded - 1 - lenBytes, pbEncoded, &lenBytes);
 591             pbEncoded += lenBytes;
 592             if (pszObjId)
 593             {
 594                 const char *ptr;
 595                 int val, pos;
 596
 597                 *pbEncoded++ = firstByte;
 598                 ptr = pszObjId + firstPos;
 599                 while (ret && *ptr)
 600                 {
 601                     sscanf(ptr, "%d%n", &val, &pos);
 602                     {
 603                         unsigned char outBytes[5];
 604                         int numBytes, i;
 605
 606                         if (val >= 0x10000000)
 607                             numBytes = 5;
 608                         else if (val >= 0x200000)
 609                             numBytes = 4;
 610                         else if (val >= 0x4000)
 611                             numBytes = 3;
 612                         else if (val >= 0x80)
 613                             numBytes = 2;
 614                         else
 615                             numBytes = 1;
 616                         for (i = numBytes; i > 0; i--)
 617                         {
 618                             outBytes[i - 1] = val & 0x7f;
 619                             val >>= 7;
 620                         }
 621                         for (i = 0; i < numBytes - 1; i++)
 622                             *pbEncoded++ = outBytes[i] | 0x80;
 623                         *pbEncoded++ = outBytes[i];
 624                         ptr += pos;
 625                         if (*ptr == '.')
 626                             ptr++;
 627                     }
 628                 }
 629             }
 630         }
 631     }
 632     *pcbEncoded = bytesNeeded;
 633     return ret;
 634 }
 635
 636 static BOOL WINAPI CRYPT_CopyEncodedBlob(DWORD dwCertEncodingType,
 637  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 638  DWORD *pcbEncoded)
 639 {
 640     const CRYPT_DER_BLOB *blob = (const CRYPT_DER_BLOB *)pvStructInfo;
 641     BOOL ret = TRUE;
 642
 643     if (!pbEncoded)
 644         *pcbEncoded = blob->cbData;
 645     else if (*pcbEncoded < blob->cbData)
 646     {
 647         *pcbEncoded = blob->cbData;
 648         SetLastError(ERROR_MORE_DATA);
 649         ret = FALSE;
 650     }
 651     else
 652     {
 653         if (blob->cbData)
 654             memcpy(pbEncoded, blob->pbData, blob->cbData);
 655         *pcbEncoded = blob->cbData;
 656     }
 657     return ret;
 658 }
 659
 660 static BOOL WINAPI CRYPT_AsnEncodeAlgorithmIdWithNullParams(
 661  DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
 662  BYTE *pbEncoded, DWORD *pcbEncoded)
 663 {
 664     const CRYPT_ALGORITHM_IDENTIFIER *algo =
 665      (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
 666     static const BYTE asn1Null[] = { ASN_NULL, 0 };
 667     static const CRYPT_DATA_BLOB nullBlob = { sizeof(asn1Null),
 668      (LPBYTE)asn1Null };
 669     BOOL ret;
 670     struct AsnEncodeSequenceItem items[2] = {
 671      { algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
 672      { NULL,           CRYPT_CopyEncodedBlob, 0 },
 673     };
 674
 675     if (algo->Parameters.cbData)
 676         items[1].pvStructInfo = &algo->Parameters;
 677     else
 678         items[1].pvStructInfo = &nullBlob;
 679     ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
 680      sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
 681     return ret;
 682 }
 683
 684 static BOOL WINAPI CRYPT_AsnEncodeAttributeTypeValue(DWORD dwCertEncodingType,
 685  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 686  DWORD *pcbEncoded)
 687 {
 688     const CRYPT_ATTRIBUTE_TYPE_VALUE *typeValue =
 689      (const CRYPT_ATTRIBUTE_TYPE_VALUE *)pvStructInfo;
 690     struct AsnEncodeSequenceItem items[] = {
 691      { &typeValue->pszObjId, CRYPT_AsnEncodeOid, 0 },
 692      { &typeValue->Value,    CRYPT_CopyEncodedBlob, 0 },
 693     };
 694
 695     return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
 696      items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
 697 }
 698
 699 struct SPCDigest
 700 {
 701     CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm;
 702     CRYPT_HASH_BLOB            Digest;
 703 };
 704
 705 static BOOL WINAPI CRYPT_AsnEncodeSPCDigest(DWORD dwCertEncodingType,
 706  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 707  DWORD *pcbEncoded)
 708 {
 709     const struct SPCDigest *digest = (const struct SPCDigest *)pvStructInfo;
 710     struct AsnEncodeSequenceItem items[] = {
 711      { &digest->DigestAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams, 0 },
 712      { &digest->Digest,          CRYPT_CopyEncodedBlob, 0 },
 713     };
 714
 715     return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
 716      items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
 717 }
 718
 719 BOOL WINAPI WVTAsn1SpcIndirectDataContentEncode(DWORD dwCertEncodingType,
 720  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 721  DWORD *pcbEncoded)
 722 {
 723     BOOL ret = FALSE;
 724
 725     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
 726      debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
 727
 728     __TRY
 729     {
 730         const SPC_INDIRECT_DATA_CONTENT *data =
 731          (const SPC_INDIRECT_DATA_CONTENT *)pvStructInfo;
 732         struct AsnEncodeSequenceItem items[] = {
 733          { &data->Data,            CRYPT_AsnEncodeAttributeTypeValue, 0 },
 734          { &data->DigestAlgorithm, CRYPT_AsnEncodeSPCDigest, 0 },
 735         };
 736
 737         ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
 738          items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
 739     }
 740     __EXCEPT_PAGE_FAULT
 741     {
 742         SetLastError(STATUS_ACCESS_VIOLATION);
 743     }
 744     __ENDTRY
 745     return ret;
 746 }
 747
 748 static BOOL WINAPI CRYPT_AsnEncodeBMPString(DWORD dwCertEncodingType,
 749  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 750  DWORD *pcbEncoded)
 751 {
 752     BOOL ret = TRUE;
 753     LPCWSTR str = (LPCWSTR)pvStructInfo;
 754     DWORD bytesNeeded, lenBytes, strLen;
 755
 756     if (str)
 757         strLen = lstrlenW(str);
 758     else
 759         strLen = 0;
 760     CRYPT_EncodeLen(strLen * 2, NULL, &lenBytes);
 761     bytesNeeded = 1 + lenBytes + strLen * 2;
 762     if (!pbEncoded)
 763         *pcbEncoded = bytesNeeded;
 764     else if (*pcbEncoded < bytesNeeded)
 765     {
 766         *pcbEncoded = bytesNeeded;
 767         SetLastError(ERROR_MORE_DATA);
 768         ret = FALSE;
 769     }
 770     else
 771     {
 772         DWORD i;
 773
 774         *pcbEncoded = bytesNeeded;
 775         *pbEncoded++ = ASN_BMPSTRING;
 776         CRYPT_EncodeLen(strLen * 2, pbEncoded, &lenBytes);
 777         pbEncoded += lenBytes;
 778         for (i = 0; i < strLen; i++)
 779         {
 780             *pbEncoded++ = (str[i] & 0xff00) >> 8;
 781             *pbEncoded++ = str[i] & 0x00ff;
 782         }
 783     }
 784     return ret;
 785 }
 786
 787 struct AsnEncodeTagSwappedItem
 788 {
 789     BYTE                  tag;
 790     const void           *pvStructInfo;
 791     CryptEncodeObjectFunc encodeFunc;
 792 };
 793
 794 /* Sort of a wacky hack, it encodes something using the struct
 795  * AsnEncodeTagSwappedItem's encodeFunc, then replaces the tag byte with the tag
 796  * given in the struct AsnEncodeTagSwappedItem.
 797  */
 798 static BOOL WINAPI CRYPT_AsnEncodeSwapTag(DWORD dwCertEncodingType,
 799  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 800  DWORD *pcbEncoded)
 801 {
 802     BOOL ret;
 803     const struct AsnEncodeTagSwappedItem *item = pvStructInfo;
 804
 805     ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
 806      item->pvStructInfo, pbEncoded, pcbEncoded);
 807     if (ret && pbEncoded)
 808         *pbEncoded = item->tag;
 809     return ret;
 810 }
 811
 812 BOOL WINAPI WVTAsn1SpcSpOpusInfoEncode(DWORD dwCertEncodingType,
 813  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 814  DWORD *pcbEncoded)
 815 {
 816     BOOL ret = FALSE;
 817
 818     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
 819      debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
 820
 821     __TRY
 822     {
 823         const SPC_SP_OPUS_INFO *info = pvStructInfo;
 824
 825         if (info->pMoreInfo &&
 826          info->pMoreInfo->dwLinkChoice != SPC_URL_LINK_CHOICE &&
 827          info->pMoreInfo->dwLinkChoice != SPC_MONIKER_LINK_CHOICE &&
 828          info->pMoreInfo->dwLinkChoice != SPC_FILE_LINK_CHOICE)
 829             SetLastError(E_INVALIDARG);
 830         else if (info->pPublisherInfo &&
 831          info->pPublisherInfo->dwLinkChoice != SPC_URL_LINK_CHOICE &&
 832          info->pPublisherInfo->dwLinkChoice != SPC_MONIKER_LINK_CHOICE &&
 833          info->pPublisherInfo->dwLinkChoice != SPC_FILE_LINK_CHOICE)
 834             SetLastError(E_INVALIDARG);
 835         else
 836         {
 837             struct AsnEncodeSequenceItem items[3] = { { 0 } };
 838             struct AsnConstructedItem constructed[3] = { { 0 } };
 839             struct AsnEncodeTagSwappedItem swapped;
 840             DWORD cItem = 0, cConstructed = 0;
 841
 842             if (info->pwszProgramName)
 843             {
 844                 swapped.tag = ASN_CONTEXT;
 845                 swapped.pvStructInfo = info->pwszProgramName;
 846                 swapped.encodeFunc = CRYPT_AsnEncodeBMPString;
 847                 constructed[cConstructed].tag = 0;
 848                 constructed[cConstructed].pvStructInfo = &swapped;
 849                 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeSwapTag;
 850                 items[cItem].pvStructInfo = &constructed[cConstructed];
 851                 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
 852                 cConstructed++;
 853                 cItem++;
 854             }
 855             if (info->pMoreInfo)
 856             {
 857                 constructed[cConstructed].tag = 1;
 858                 constructed[cConstructed].pvStructInfo = info->pMoreInfo;
 859                 constructed[cConstructed].encodeFunc = WVTAsn1SpcLinkEncode;
 860                 items[cItem].pvStructInfo = &constructed[cConstructed];
 861                 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
 862                 cConstructed++;
 863                 cItem++;
 864             }
 865             if (info->pPublisherInfo)
 866             {
 867                 constructed[cConstructed].tag = 2;
 868                 constructed[cConstructed].pvStructInfo = info->pPublisherInfo;
 869                 constructed[cConstructed].encodeFunc = WVTAsn1SpcLinkEncode;
 870                 items[cItem].pvStructInfo = &constructed[cConstructed];
 871                 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
 872                 cConstructed++;
 873                 cItem++;
 874             }
 875             ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
 876              items, cItem, pbEncoded, pcbEncoded);
 877         }
 878     }
 879     __EXCEPT_PAGE_FAULT
 880     {
 881         SetLastError(STATUS_ACCESS_VIOLATION);
 882     }
 883     __ENDTRY
 884     return ret;
 885 }
 886
 887 static BOOL CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType,
 888  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 889  DWORD *pcbEncoded)
 890 {
 891     BOOL ret;
 892
 893     __TRY
 894     {
 895         DWORD significantBytes, lenBytes, bytesNeeded;
 896         BYTE padByte = 0;
 897         BOOL pad = FALSE;
 898         const CRYPT_INTEGER_BLOB *blob =
 899          (const CRYPT_INTEGER_BLOB *)pvStructInfo;
 900
 901         significantBytes = blob->cbData;
 902         if (significantBytes)
 903         {
 904             if (blob->pbData[significantBytes - 1] & 0x80)
 905             {
 906                 /* negative, lop off leading (little-endian) 0xffs */
 907                 for (; significantBytes > 0 &&
 908                  blob->pbData[significantBytes - 1] == 0xff; significantBytes--)
 909                     ;
 910                 if (blob->pbData[significantBytes - 1] < 0x80)
 911                 {
 912                     padByte = 0xff;
 913                     pad = TRUE;
 914                 }
 915             }
 916             else
 917             {
 918                 /* positive, lop off leading (little-endian) zeroes */
 919                 for (; significantBytes > 0 &&
 920                  !blob->pbData[significantBytes - 1]; significantBytes--)
 921                     ;
 922                 if (significantBytes == 0)
 923                     significantBytes = 1;
 924                 if (blob->pbData[significantBytes - 1] > 0x7f)
 925                 {
 926                     padByte = 0;
 927                     pad = TRUE;
 928                 }
 929             }
 930         }
 931         if (pad)
 932             CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes);
 933         else
 934             CRYPT_EncodeLen(significantBytes, NULL, &lenBytes);
 935         bytesNeeded = 1 + lenBytes + significantBytes;
 936         if (pad)
 937             bytesNeeded++;
 938         if (!pbEncoded)
 939         {
 940             *pcbEncoded = bytesNeeded;
 941             ret = TRUE;
 942         }
 943         else if (*pcbEncoded < bytesNeeded)
 944         {
 945             *pcbEncoded = bytesNeeded;
 946             SetLastError(ERROR_MORE_DATA);
 947             ret = FALSE;
 948         }
 949         else
 950         {
 951             *pcbEncoded = bytesNeeded;
 952             *pbEncoded++ = ASN_INTEGER;
 953             if (pad)
 954             {
 955                 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
 956                 pbEncoded += lenBytes;
 957                 *pbEncoded++ = padByte;
 958             }
 959             else
 960             {
 961                 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
 962                 pbEncoded += lenBytes;
 963             }
 964             for (; significantBytes > 0; significantBytes--)
 965                 *(pbEncoded++) = blob->pbData[significantBytes - 1];
 966             ret = TRUE;
 967         }
 968     }
 969     __EXCEPT_PAGE_FAULT
 970     {
 971         SetLastError(STATUS_ACCESS_VIOLATION);
 972         ret = FALSE;
 973     }
 974     __ENDTRY
 975     return ret;
 976 }
 977
 978 BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType,
 979  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 980  DWORD *pcbEncoded)
 981 {
 982     CRYPT_INTEGER_BLOB blob = { sizeof(INT), (BYTE *)pvStructInfo };
 983
 984     return CRYPT_AsnEncodeInteger(dwCertEncodingType, X509_MULTI_BYTE_INTEGER,
 985      &blob, pbEncoded, pcbEncoded);
 986 }
 987
 988 BOOL WINAPI WVTAsn1CatMemberInfoEncode(DWORD dwCertEncodingType,
 989  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
 990  DWORD *pcbEncoded)
 991 {
 992     BOOL ret = FALSE;
 993
 994     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
 995      debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
 996
 997     __TRY
 998     {
 999         const CAT_MEMBERINFO *info = (const CAT_MEMBERINFO *)pvStructInfo;
1000         struct AsnEncodeSequenceItem items[] = {
1001          { info->pwszSubjGuid, CRYPT_AsnEncodeBMPString, 0 },
1002          { &info->dwCertVersion, CRYPT_AsnEncodeInt, 0 },
1003         };
1004
1005         ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
1006          items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
1007     }
1008     __EXCEPT_PAGE_FAULT
1009     {
1010         SetLastError(STATUS_ACCESS_VIOLATION);
1011     }
1012     __ENDTRY
1013     return ret;
1014 }
1015
1016 BOOL WINAPI WVTAsn1CatNameValueEncode(DWORD dwCertEncodingType,
1017  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
1018  DWORD *pcbEncoded)
1019 {
1020     BOOL ret = FALSE;
1021
1022     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
1023      debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
1024
1025     __TRY
1026     {
1027         const CAT_NAMEVALUE *value = (const CAT_NAMEVALUE *)pvStructInfo;
1028         struct AsnEncodeSequenceItem items[] = {
1029          { value->pwszTag,   CRYPT_AsnEncodeBMPString, 0 },
1030          { &value->fdwFlags, CRYPT_AsnEncodeInt, 0 },
1031          { &value->Value,    CRYPT_AsnEncodeOctets, 0 },
1032         };
1033
1034         ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
1035          items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
1036     }
1037     __EXCEPT_PAGE_FAULT
1038     {
1039         SetLastError(STATUS_ACCESS_VIOLATION);
1040     }
1041     __ENDTRY
1042     return ret;
1043 }
1044
1045 static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
1046  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
1047  DWORD *pcbEncoded)
1048 {
1049     BOOL val = *(const BOOL *)pvStructInfo, ret;
1050
1051     TRACE("%d\n", val);
1052
1053     if (!pbEncoded)
1054     {
1055         *pcbEncoded = 3;
1056         ret = TRUE;
1057     }
1058     else if (*pcbEncoded < 3)
1059     {
1060         *pcbEncoded = 3;
1061         SetLastError(ERROR_MORE_DATA);
1062         ret = FALSE;
1063     }
1064     else
1065     {
1066         *pcbEncoded = 3;
1067         *pbEncoded++ = ASN_BOOL;
1068         *pbEncoded++ = 1;
1069         *pbEncoded++ = val ? 0xff : 0;
1070         ret = TRUE;
1071     }
1072     TRACE("returning %d (%08x)\n", ret, GetLastError());
1073     return ret;
1074 }
1075
1076 BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoEncode(DWORD dwCertEncodingType,
1077  LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
1078  DWORD *pcbEncoded)
1079 {
1080     BOOL ret = FALSE;
1081
1082     TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
1083      debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
1084
1085     __TRY
1086     {
1087         const SPC_FINANCIAL_CRITERIA *criteria = pvStructInfo;
1088         struct AsnEncodeSequenceItem items[] = {
1089          { &criteria->fFinancialInfoAvailable, CRYPT_AsnEncodeBool, 0 },
1090          { &criteria->fMeetsCriteria,          CRYPT_AsnEncodeBool, 0 },
1091         };
1092
1093         ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
1094          items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
1095     }
1096     __EXCEPT_PAGE_FAULT
1097     {
1098         SetLastError(STATUS_ACCESS_VIOLATION);
1099     }
1100     __ENDTRY
1101     return ret;
1102 }
1103
1104 /* Gets the number of length bytes from the given (leading) length byte */
1105 #define GET_LEN_BYTES(b) ((b) <= 0x7f ? 1 : 1 + ((b) & 0x7f))
1106
1107 /* Helper function to get the encoded length of the data starting at pbEncoded,
1108  * where pbEncoded[0] is the tag.  If the data are too short to contain a
1109  * length or if the length is too large for cbEncoded, sets an appropriate
1110  * error code and returns FALSE.
1111  */
1112 static BOOL CRYPT_GetLen(const BYTE *pbEncoded, DWORD cbEncoded, DWORD *len)
1113 {
1114     BOOL ret;
1115
1116     if (cbEncoded <= 1)
1117     {
1118         SetLastError(CRYPT_E_ASN1_CORRUPT);
1119         ret = FALSE;
1120     }
1121     else if (pbEncoded[1] <= 0x7f)
1122     {
1123         if (pbEncoded[1] + 1 > cbEncoded)
1124         {
1125             SetLastError(CRYPT_E_ASN1_EOD);
1126             ret = FALSE;
1127         }
1128         else
1129         {
1130             *len = pbEncoded[1];
1131             ret = TRUE;
1132         }
1133     }
1134     else if (pbEncoded[1] == 0x80)
1135     {
1136         FIXME("unimplemented for indefinite-length encoding\n");
1137         SetLastError(CRYPT_E_ASN1_CORRUPT);
1138         ret = FALSE;
1139     }
1140     else
1141     {
1142         BYTE lenLen = GET_LEN_BYTES(pbEncoded[1]);
1143
1144         if (lenLen > sizeof(DWORD) + 1)
1145         {
1146             SetLastError(CRYPT_E_ASN1_LARGE);
1147             ret = FALSE;
1148         }
1149         else if (lenLen + 2 > cbEncoded)
1150         {
1151             SetLastError(CRYPT_E_ASN1_CORRUPT);
1152             ret = FALSE;
1153         }
1154         else
1155         {
1156             DWORD out = 0;
1157
1158             pbEncoded += 2;
1159             while (--lenLen)
1160             {
1161                 out <<= 8;
1162                 out |= *pbEncoded++;
1163             }
1164             if (out + lenLen + 1 > cbEncoded)
1165             {
1166                 SetLastError(CRYPT_E_ASN1_EOD);
1167                 ret = FALSE;
1168             }
1169             else
1170             {
1171                 *len = out;
1172                 ret = TRUE;
1173             }
1174         }
1175     }
1176     return ret;
1177 }
1178
1179 static BOOL WINAPI CRYPT_AsnDecodeOctets(DWORD dwCertEncodingType,
1180  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1181  void *pvStructInfo, DWORD *pcbStructInfo)
1182 {
1183     BOOL ret;
1184     DWORD bytesNeeded, dataLen;
1185
1186     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1187      pvStructInfo, *pcbStructInfo);
1188
1189     if (!cbEncoded)
1190     {
1191         SetLastError(CRYPT_E_ASN1_CORRUPT);
1192         ret = FALSE;
1193     }
1194     else if (pbEncoded[0] != ASN_OCTETSTRING)
1195     {
1196         SetLastError(CRYPT_E_ASN1_BADTAG);
1197         ret = FALSE;
1198     }
1199     else if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1200     {
1201         if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1202             bytesNeeded = sizeof(CRYPT_DATA_BLOB);
1203         else
1204             bytesNeeded = dataLen + sizeof(CRYPT_DATA_BLOB);
1205         if (!pvStructInfo)
1206             *pcbStructInfo = bytesNeeded;
1207         else if (*pcbStructInfo < bytesNeeded)
1208         {
1209             SetLastError(ERROR_MORE_DATA);
1210             *pcbStructInfo = bytesNeeded;
1211             ret = FALSE;
1212         }
1213         else
1214         {
1215             CRYPT_DATA_BLOB *blob;
1216             BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1217
1218             blob = (CRYPT_DATA_BLOB *)pvStructInfo;
1219             blob->cbData = dataLen;
1220             if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1221                 blob->pbData = (BYTE *)pbEncoded + 1 + lenBytes;
1222             else
1223             {
1224                 assert(blob->pbData);
1225                 if (blob->cbData)
1226                     memcpy(blob->pbData, pbEncoded + 1 + lenBytes,
1227                      blob->cbData);
1228             }
1229         }
1230     }
1231     return ret;
1232 }
1233
1234 static BOOL CRYPT_AsnDecodeSPCLinkInternal(DWORD dwCertEncodingType,
1235  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1236  void *pvStructInfo, DWORD *pcbStructInfo)
1237 {
1238     BOOL ret = FALSE;
1239     DWORD bytesNeeded = sizeof(SPC_LINK), dataLen;
1240
1241     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1242      pvStructInfo, *pcbStructInfo);
1243
1244     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1245     {
1246         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1247         DWORD realDataLen;
1248
1249         switch (pbEncoded[0])
1250         {
1251         case ASN_CONTEXT:
1252             bytesNeeded += (dataLen + 1) * sizeof(WCHAR);
1253             if (!pvStructInfo)
1254                 *pcbStructInfo = bytesNeeded;
1255             else if (*pcbStructInfo < bytesNeeded)
1256             {
1257                 *pcbStructInfo = bytesNeeded;
1258                 SetLastError(ERROR_MORE_DATA);
1259                 ret = FALSE;
1260             }
1261             else
1262             {
1263                 PSPC_LINK link = (PSPC_LINK)pvStructInfo;
1264                 DWORD i;
1265
1266                 link->dwLinkChoice = SPC_URL_LINK_CHOICE;
1267                 for (i = 0; i < dataLen; i++)
1268                     link->u.pwszUrl[i] =
1269                      *(pbEncoded + 1 + lenBytes + i);
1270                 link->u.pwszUrl[i] = '\0';
1271                 TRACE("returning url %s\n", debugstr_w(link->u.pwszUrl));
1272             }
1273             break;
1274         case ASN_CONSTRUCTOR | ASN_CONTEXT | 1:
1275         {
1276             CRYPT_DATA_BLOB classId;
1277             DWORD size = sizeof(classId);
1278
1279             if ((ret = CRYPT_AsnDecodeOctets(dwCertEncodingType, NULL,
1280              pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
1281              CRYPT_DECODE_NOCOPY_FLAG, &classId, &size)))
1282             {
1283                 if (classId.cbData != sizeof(SPC_UUID))
1284                 {
1285                     SetLastError(CRYPT_E_BAD_ENCODE);
1286                     ret = FALSE;
1287                 }
1288                 else
1289                 {
1290                     CRYPT_DATA_BLOB data;
1291
1292                     /* The tag length for the classId must be 1 since the
1293                      * length is correct.
1294                      */
1295                     size = sizeof(data);
1296                     if ((ret = CRYPT_AsnDecodeOctets(dwCertEncodingType, NULL,
1297                      pbEncoded + 3 + lenBytes + classId.cbData,
1298                      cbEncoded - 3 - lenBytes - classId.cbData,
1299                      CRYPT_DECODE_NOCOPY_FLAG, &data, &size)))
1300                     {
1301                         bytesNeeded += data.cbData;
1302                         if (!pvStructInfo)
1303                             *pcbStructInfo = bytesNeeded;
1304                         else if (*pcbStructInfo < bytesNeeded)
1305                         {
1306                             *pcbStructInfo = bytesNeeded;
1307                             SetLastError(ERROR_MORE_DATA);
1308                             ret = FALSE;
1309                         }
1310                         else
1311                         {
1312                             PSPC_LINK link = (PSPC_LINK)pvStructInfo;
1313
1314                             link->dwLinkChoice = SPC_MONIKER_LINK_CHOICE;
1315                             /* pwszFile pointer was set by caller, copy it
1316                              * before overwriting it
1317                              */
1318                             link->u.Moniker.SerializedData.pbData =
1319                              (BYTE *)link->u.pwszFile;
1320                             memcpy(link->u.Moniker.ClassId, classId.pbData,
1321                              classId.cbData);
1322                             memcpy(link->u.Moniker.SerializedData.pbData,
1323                              data.pbData, data.cbData);
1324                             link->u.Moniker.SerializedData.cbData = data.cbData;
1325                         }
1326                     }
1327                 }
1328             }
1329             break;
1330         }
1331         case ASN_CONSTRUCTOR | ASN_CONTEXT | 2:
1332             if (dataLen && pbEncoded[1 + lenBytes] != ASN_CONTEXT)
1333                 SetLastError(CRYPT_E_ASN1_BADTAG);
1334             else if ((ret = CRYPT_GetLen(pbEncoded + 1 + lenBytes, dataLen,
1335              &realDataLen)))
1336             {
1337                 BYTE realLenBytes = GET_LEN_BYTES(pbEncoded[2 + lenBytes]);
1338
1339                 bytesNeeded += realDataLen + sizeof(WCHAR);
1340                 if (!pvStructInfo)
1341                     *pcbStructInfo = bytesNeeded;
1342                 else if (*pcbStructInfo < bytesNeeded)
1343                 {
1344                     *pcbStructInfo = bytesNeeded;
1345                     SetLastError(ERROR_MORE_DATA);
1346                     ret = FALSE;
1347                 }
1348                 else
1349                 {
1350                     PSPC_LINK link = (PSPC_LINK)pvStructInfo;
1351                     DWORD i;
1352                     const BYTE *ptr = pbEncoded + 2 + lenBytes + realLenBytes;
1353
1354                     link->dwLinkChoice = SPC_FILE_LINK_CHOICE;
1355                     for (i = 0; i < dataLen / sizeof(WCHAR); i++)
1356                         link->u.pwszFile[i] =
1357                          hton16(*(WORD *)(ptr + i * sizeof(WCHAR)));
1358                     link->u.pwszFile[realDataLen / sizeof(WCHAR)] = '\0';
1359                     TRACE("returning file %s\n", debugstr_w(link->u.pwszFile));
1360                 }
1361             }
1362             else
1363             {
1364                 bytesNeeded += sizeof(WCHAR);
1365                 if (!pvStructInfo)
1366                     *pcbStructInfo = bytesNeeded;
1367                 else if (*pcbStructInfo < bytesNeeded)
1368                 {
1369                     *pcbStructInfo = bytesNeeded;
1370                     SetLastError(ERROR_MORE_DATA);
1371                     ret = FALSE;
1372                 }
1373                 else
1374                 {
1375                     PSPC_LINK link = (PSPC_LINK)pvStructInfo;
1376
1377                     link->dwLinkChoice = SPC_FILE_LINK_CHOICE;
1378                     link->u.pwszFile[0] = '\0';
1379                     ret = TRUE;
1380                 }
1381             }
1382             break;
1383         default:
1384             SetLastError(CRYPT_E_ASN1_BADTAG);
1385         }
1386     }
1387     TRACE("returning %d\n", ret);
1388     return ret;
1389 }
1390
1391 BOOL WINAPI WVTAsn1SpcLinkDecode(DWORD dwCertEncodingType,
1392  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1393  void *pvStructInfo, DWORD *pcbStructInfo)
1394 {
1395     BOOL ret = FALSE;
1396
1397     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1398      pvStructInfo, *pcbStructInfo);
1399
1400     __TRY
1401     {
1402         DWORD bytesNeeded;
1403
1404         ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
1405          lpszStructType, pbEncoded, cbEncoded, dwFlags, NULL, &bytesNeeded);
1406         if (ret)
1407         {
1408             if (!pvStructInfo)
1409                 *pcbStructInfo = bytesNeeded;
1410             else if (*pcbStructInfo < bytesNeeded)
1411             {
1412                 *pcbStructInfo = bytesNeeded;
1413                 SetLastError(ERROR_MORE_DATA);
1414                 ret = FALSE;
1415             }
1416             else
1417             {
1418                 SPC_LINK *link = (SPC_LINK *)pvStructInfo;
1419
1420                 link->u.pwszFile =
1421                  (LPWSTR)((BYTE *)pvStructInfo + sizeof(SPC_LINK));
1422                 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
1423                  lpszStructType, pbEncoded, cbEncoded, dwFlags, pvStructInfo,
1424                  pcbStructInfo);
1425             }
1426         }
1427     }
1428     __EXCEPT_PAGE_FAULT
1429     {
1430         SetLastError(STATUS_ACCESS_VIOLATION);
1431     }
1432     __ENDTRY
1433     TRACE("returning %d\n", ret);
1434     return ret;
1435 }
1436
1437 typedef BOOL (WINAPI *CryptDecodeObjectFunc)(DWORD, LPCSTR, const BYTE *,
1438  DWORD, DWORD, void *, DWORD *);
1439
1440 /* tag:
1441  *     The expected tag of the item.  If tag is 0, decodeFunc is called
1442  *     regardless of the tag value seen.
1443  * offset:
1444  *     A sequence is decoded into a struct.  The offset member is the
1445  *     offset of this item within that struct.
1446  * decodeFunc:
1447  *     The decoder function to use.  If this is NULL, then the member isn't
1448  *     decoded, but minSize space is reserved for it.
1449  * minSize:
1450  *     The minimum amount of space occupied after decoding.  You must set this.
1451  * optional:
1452  *     If true, and the tag doesn't match the expected tag for this item,
1453  *     or the decodeFunc fails with CRYPT_E_ASN1_BADTAG, then minSize space is
1454  *     filled with 0 for this member.
1455  * hasPointer, pointerOffset:
1456  *     If the item has dynamic data, set hasPointer to TRUE, pointerOffset to
1457  *     the offset within the struct of the data pointer (or to the
1458  *     first data pointer, if more than one exist).
1459  * size:
1460  *     Used by CRYPT_AsnDecodeSequence, not for your use.
1461  */
1462 struct AsnDecodeSequenceItem
1463 {
1464     BYTE                  tag;
1465     DWORD                 offset;
1466     CryptDecodeObjectFunc decodeFunc;
1467     DWORD                 minSize;
1468     BOOL                  optional;
1469     BOOL                  hasPointer;
1470     DWORD                 pointerOffset;
1471     DWORD                 size;
1472 };
1473
1474 /* Decodes the items in a sequence, where the items are described in items,
1475  * the encoded data are in pbEncoded with length cbEncoded.  Decodes into
1476  * pvStructInfo.  nextData is a pointer to the memory location at which the
1477  * first decoded item with a dynamic pointer should point.
1478  * Upon decoding, *cbDecoded is the total number of bytes decoded.
1479  */
1480 static BOOL CRYPT_AsnDecodeSequenceItems(DWORD dwCertEncodingType,
1481  struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded,
1482  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, BYTE *nextData,
1483  DWORD *cbDecoded)
1484 {
1485     BOOL ret;
1486     DWORD i, decoded = 0;
1487     const BYTE *ptr = pbEncoded;
1488
1489     TRACE("%p, %d, %p, %d, %08x, %p, %p, %p\n", items, cItem, pbEncoded,
1490      cbEncoded, dwFlags, pvStructInfo, nextData, cbDecoded);
1491
1492     for (i = 0, ret = TRUE; ret && i < cItem; i++)
1493     {
1494         if (cbEncoded - (ptr - pbEncoded) != 0)
1495         {
1496             DWORD nextItemLen;
1497
1498             if ((ret = CRYPT_GetLen(ptr, cbEncoded - (ptr - pbEncoded),
1499              &nextItemLen)))
1500             {
1501                 BYTE nextItemLenBytes = GET_LEN_BYTES(ptr[1]);
1502
1503                 if (ptr[0] == items[i].tag || !items[i].tag)
1504                 {
1505                     if (nextData && pvStructInfo && items[i].hasPointer)
1506                     {
1507                         TRACE("Setting next pointer to %p\n",
1508                          nextData);
1509                         *(BYTE **)((BYTE *)pvStructInfo +
1510                          items[i].pointerOffset) = nextData;
1511                     }
1512                     if (items[i].decodeFunc)
1513                     {
1514                         if (pvStructInfo)
1515                             TRACE("decoding item %d\n", i);
1516                         else
1517                             TRACE("sizing item %d\n", i);
1518                         ret = items[i].decodeFunc(dwCertEncodingType,
1519                          NULL, ptr, 1 + nextItemLenBytes + nextItemLen,
1520                          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
1521                          pvStructInfo ?  (BYTE *)pvStructInfo + items[i].offset
1522                          : NULL, &items[i].size);
1523                         if (ret)
1524                         {
1525                             /* Account for alignment padding */
1526                             if (items[i].size % sizeof(DWORD))
1527                                 items[i].size += sizeof(DWORD) -
1528                                  items[i].size % sizeof(DWORD);
1529                             TRACE("item %d size: %d\n", i, items[i].size);
1530                             if (nextData && items[i].hasPointer &&
1531                              items[i].size > items[i].minSize)
1532                                 nextData += items[i].size - items[i].minSize;
1533                             ptr += 1 + nextItemLenBytes + nextItemLen;
1534                             decoded += 1 + nextItemLenBytes + nextItemLen;
1535                             TRACE("item %d: decoded %d bytes\n", i,
1536                              1 + nextItemLenBytes + nextItemLen);
1537                         }
1538                         else if (items[i].optional &&
1539                          GetLastError() == CRYPT_E_ASN1_BADTAG)
1540                         {
1541                             TRACE("skipping optional item %d\n", i);
1542                             items[i].size = items[i].minSize;
1543                             SetLastError(NOERROR);
1544                             ret = TRUE;
1545                         }
1546                         else
1547                             TRACE("item %d failed: %08x\n", i,
1548                              GetLastError());
1549                     }
1550                     else
1551                     {
1552                         TRACE("item %d: decoded %d bytes\n", i,
1553                          1 + nextItemLenBytes + nextItemLen);
1554                         ptr += 1 + nextItemLenBytes + nextItemLen;
1555                         decoded += 1 + nextItemLenBytes + nextItemLen;
1556                         items[i].size = items[i].minSize;
1557                     }
1558                 }
1559                 else if (items[i].optional)
1560                 {
1561                     TRACE("skipping optional item %d\n", i);
1562                     items[i].size = items[i].minSize;
1563                 }
1564                 else
1565                 {
1566                     TRACE("item %d: tag %02x doesn't match expected %02x\n",
1567                      i, ptr[0], items[i].tag);
1568                     SetLastError(CRYPT_E_ASN1_BADTAG);
1569                     ret = FALSE;
1570                 }
1571             }
1572         }
1573         else if (items[i].optional)
1574         {
1575             TRACE("missing optional item %d, skipping\n", i);
1576             items[i].size = items[i].minSize;
1577         }
1578         else
1579         {
1580             TRACE("not enough bytes for item %d, failing\n", i);
1581             SetLastError(CRYPT_E_ASN1_CORRUPT);
1582             ret = FALSE;
1583         }
1584     }
1585     if (ret)
1586         *cbDecoded = decoded;
1587     TRACE("returning %d\n", ret);
1588     return ret;
1589 }
1590
1591 /* This decodes an arbitrary sequence into a contiguous block of memory
1592  * (basically, a struct.)  Each element being decoded is described by a struct
1593  * AsnDecodeSequenceItem, see above.
1594  * startingPointer is an optional pointer to the first place where dynamic
1595  * data will be stored.  If you know the starting offset, you may pass it
1596  * here.  Otherwise, pass NULL, and one will be inferred from the items.
1597  */
1598 static BOOL CRYPT_AsnDecodeSequence(DWORD dwCertEncodingType,
1599  struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded,
1600  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1601  void *startingPointer)
1602 {
1603     BOOL ret;
1604
1605     TRACE("%p, %d, %p, %d, %08x, %p, %d, %p\n", items, cItem, pbEncoded,
1606      cbEncoded, dwFlags, pvStructInfo, *pcbStructInfo, startingPointer);
1607
1608     if (pbEncoded[0] == ASN_SEQUENCE)
1609     {
1610         DWORD dataLen;
1611
1612         if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1613         {
1614             DWORD lenBytes = GET_LEN_BYTES(pbEncoded[1]), cbDecoded;
1615             const BYTE *ptr = pbEncoded + 1 + lenBytes;
1616
1617             cbEncoded -= 1 + lenBytes;
1618             if (cbEncoded < dataLen)
1619             {
1620                 TRACE("dataLen %d exceeds cbEncoded %d, failing\n", dataLen,
1621                  cbEncoded);
1622                 SetLastError(CRYPT_E_ASN1_CORRUPT);
1623                 ret = FALSE;
1624             }
1625             else
1626                 ret = CRYPT_AsnDecodeSequenceItems(dwFlags, items, cItem, ptr,
1627                  cbEncoded, dwFlags, NULL, NULL, &cbDecoded);
1628             if (ret && cbDecoded != dataLen)
1629             {
1630                 TRACE("expected %d decoded, got %d, failing\n", dataLen,
1631                  cbDecoded);
1632                 SetLastError(CRYPT_E_ASN1_CORRUPT);
1633                 ret = FALSE;
1634             }
1635             if (ret)
1636             {
1637                 DWORD i, bytesNeeded = 0, structSize = 0;
1638
1639                 for (i = 0; i < cItem; i++)
1640                 {
1641                     bytesNeeded += items[i].size;
1642                     structSize += items[i].minSize;
1643                 }
1644                 if (!pvStructInfo)
1645                     *pcbStructInfo = bytesNeeded;
1646                 else if (*pcbStructInfo < bytesNeeded)
1647                 {
1648                     SetLastError(ERROR_MORE_DATA);
1649                     *pcbStructInfo = bytesNeeded;
1650                     ret = FALSE;
1651                 }
1652                 else
1653                 {
1654                     BYTE *nextData;
1655
1656                     *pcbStructInfo = bytesNeeded;
1657                     if (startingPointer)
1658                         nextData = (BYTE *)startingPointer;
1659                     else
1660                         nextData = (BYTE *)pvStructInfo + structSize;
1661                     memset(pvStructInfo, 0, structSize);
1662                     ret = CRYPT_AsnDecodeSequenceItems(dwFlags, items, cItem,
1663                      ptr, cbEncoded, dwFlags, pvStructInfo, nextData,
1664                      &cbDecoded);
1665                 }
1666             }
1667         }
1668     }
1669     else
1670     {
1671         SetLastError(CRYPT_E_ASN1_BADTAG);
1672         ret = FALSE;
1673     }
1674     TRACE("returning %d (%08x)\n", ret, GetLastError());
1675     return ret;
1676 }
1677
1678 static BOOL WINAPI CRYPT_AsnDecodeBitsInternal(DWORD dwCertEncodingType,
1679  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1680  void *pvStructInfo, DWORD *pcbStructInfo)
1681 {
1682     BOOL ret;
1683
1684     TRACE("(%p, %d, 0x%08x, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
1685      pvStructInfo, *pcbStructInfo);
1686
1687     if (pbEncoded[0] == ASN_BITSTRING)
1688     {
1689         DWORD bytesNeeded, dataLen;
1690
1691         if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1692         {
1693             if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1694                 bytesNeeded = sizeof(CRYPT_BIT_BLOB);
1695             else
1696                 bytesNeeded = dataLen - 1 + sizeof(CRYPT_BIT_BLOB);
1697             if (!pvStructInfo)
1698                 *pcbStructInfo = bytesNeeded;
1699             else if (*pcbStructInfo < bytesNeeded)
1700             {
1701                 *pcbStructInfo = bytesNeeded;
1702                 SetLastError(ERROR_MORE_DATA);
1703                 ret = FALSE;
1704             }
1705             else
1706             {
1707                 CRYPT_BIT_BLOB *blob;
1708
1709                 blob = (CRYPT_BIT_BLOB *)pvStructInfo;
1710                 blob->cbData = dataLen - 1;
1711                 blob->cUnusedBits = *(pbEncoded + 1 +
1712                  GET_LEN_BYTES(pbEncoded[1]));
1713                 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1714                 {
1715                     blob->pbData = (BYTE *)pbEncoded + 2 +
1716                      GET_LEN_BYTES(pbEncoded[1]);
1717                 }
1718                 else
1719                 {
1720                     assert(blob->pbData);
1721                     if (blob->cbData)
1722                     {
1723                         BYTE mask = 0xff << blob->cUnusedBits;
1724
1725                         memcpy(blob->pbData, pbEncoded + 2 +
1726                          GET_LEN_BYTES(pbEncoded[1]), blob->cbData);
1727                         blob->pbData[blob->cbData - 1] &= mask;
1728                     }
1729                 }
1730             }
1731         }
1732     }
1733     else
1734     {
1735         SetLastError(CRYPT_E_ASN1_BADTAG);
1736         ret = FALSE;
1737     }
1738     TRACE("returning %d (%08x)\n", ret, GetLastError());
1739     return ret;
1740 }
1741
1742 static BOOL WINAPI CRYPT_AsnDecodeSPCLinkPointer(DWORD dwCertEncodingType,
1743  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1744  void *pvStructInfo, DWORD *pcbStructInfo)
1745 {
1746     BOOL ret = FALSE;
1747     DWORD dataLen;
1748
1749     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1750     {
1751         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1752         DWORD size;
1753         SPC_LINK **pLink = (SPC_LINK **)pvStructInfo;
1754
1755         ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType, lpszStructType,
1756          pbEncoded + 1 + lenBytes, dataLen, dwFlags, NULL, &size);
1757         if (ret)
1758         {
1759             if (!pvStructInfo)
1760                 *pcbStructInfo = size + sizeof(PSPC_LINK);
1761             else if (*pcbStructInfo < size + sizeof(PSPC_LINK))
1762             {
1763                 *pcbStructInfo = size + sizeof(PSPC_LINK);
1764                 SetLastError(ERROR_MORE_DATA);
1765                 ret = FALSE;
1766             }
1767             else
1768             {
1769                 *pcbStructInfo = size + sizeof(PSPC_LINK);
1770                 /* Set imageData's pointer if necessary */
1771                 if (size > sizeof(SPC_LINK))
1772                 {
1773                     (*pLink)->u.pwszUrl =
1774                      (LPWSTR)((BYTE *)*pLink + sizeof(SPC_LINK));
1775                 }
1776                 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
1777                  lpszStructType, pbEncoded + 1 + lenBytes, dataLen, dwFlags,
1778                  *pLink, pcbStructInfo);
1779             }
1780         }
1781     }
1782     return ret;
1783 }
1784
1785 BOOL WINAPI WVTAsn1SpcPeImageDataDecode(DWORD dwCertEncodingType,
1786  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1787  void *pvStructInfo, DWORD *pcbStructInfo)
1788 {
1789     BOOL ret = FALSE;
1790
1791     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1792      pvStructInfo, *pcbStructInfo);
1793
1794     __TRY
1795     {
1796         struct AsnDecodeSequenceItem items[] = {
1797          { ASN_BITSTRING, offsetof(SPC_PE_IMAGE_DATA, Flags),
1798            CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
1799            offsetof(SPC_PE_IMAGE_DATA, Flags.pbData), 0 },
1800          { ASN_CONSTRUCTOR | ASN_CONTEXT, offsetof(SPC_PE_IMAGE_DATA, pFile),
1801            CRYPT_AsnDecodeSPCLinkPointer, sizeof(PSPC_LINK), TRUE, TRUE,
1802            offsetof(SPC_PE_IMAGE_DATA, pFile), 0 },
1803         };
1804
1805         ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
1806          sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
1807          pvStructInfo, pcbStructInfo, NULL);
1808     }
1809     __EXCEPT_PAGE_FAULT
1810     {
1811         SetLastError(STATUS_ACCESS_VIOLATION);
1812     }
1813     __ENDTRY
1814     TRACE("returning %d\n", ret);
1815     return ret;
1816 }
1817
1818 static BOOL WINAPI CRYPT_AsnDecodeOidIgnoreTag(DWORD dwCertEncodingType,
1819  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1820  void *pvStructInfo, DWORD *pcbStructInfo)
1821 {
1822     BOOL ret = TRUE;
1823     DWORD dataLen;
1824
1825     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1826      pvStructInfo, *pcbStructInfo);
1827
1828     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1829     {
1830         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1831         DWORD bytesNeeded = sizeof(LPSTR);
1832
1833         if (dataLen)
1834         {
1835             /* The largest possible string for the first two components
1836              * is 2.175 (= 2 * 40 + 175 = 255), so this is big enough.
1837              */
1838             char firstTwo[6];
1839             const BYTE *ptr;
1840
1841             snprintf(firstTwo, sizeof(firstTwo), "%d.%d",
1842              pbEncoded[1 + lenBytes] / 40,
1843              pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] / 40)
1844              * 40);
1845             bytesNeeded += strlen(firstTwo) + 1;
1846             for (ptr = pbEncoded + 2 + lenBytes; ret &&
1847              ptr - pbEncoded - 1 - lenBytes < dataLen; )
1848             {
1849                 /* large enough for ".4000000" */
1850                 char str[9];
1851                 int val = 0;
1852
1853                 while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1854                  (*ptr & 0x80))
1855                 {
1856                     val <<= 7;
1857                     val |= *ptr & 0x7f;
1858                     ptr++;
1859                 }
1860                 if (ptr - pbEncoded - 1 - lenBytes >= dataLen ||
1861                  (*ptr & 0x80))
1862                 {
1863                     SetLastError(CRYPT_E_ASN1_CORRUPT);
1864                     ret = FALSE;
1865                 }
1866                 else
1867                 {
1868                     val <<= 7;
1869                     val |= *ptr++;
1870                     snprintf(str, sizeof(str), ".%d", val);
1871                     bytesNeeded += strlen(str);
1872                 }
1873             }
1874         }
1875         if (!pvStructInfo)
1876             *pcbStructInfo = bytesNeeded;
1877         else if (*pcbStructInfo < bytesNeeded)
1878         {
1879             *pcbStructInfo = bytesNeeded;
1880             SetLastError(ERROR_MORE_DATA);
1881             ret = FALSE;
1882         }
1883         else
1884         {
1885             if (dataLen)
1886             {
1887                 const BYTE *ptr;
1888                 LPSTR pszObjId = *(LPSTR *)pvStructInfo;
1889
1890                 *pszObjId = 0;
1891                 sprintf(pszObjId, "%d.%d", pbEncoded[1 + lenBytes] / 40,
1892                  pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] /
1893                  40) * 40);
1894                 pszObjId += strlen(pszObjId);
1895                 for (ptr = pbEncoded + 2 + lenBytes; ret &&
1896                  ptr - pbEncoded - 1 - lenBytes < dataLen; )
1897                 {
1898                     int val = 0;
1899
1900                     while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1901                      (*ptr & 0x80))
1902                     {
1903                         val <<= 7;
1904                         val |= *ptr & 0x7f;
1905                         ptr++;
1906                     }
1907                     val <<= 7;
1908                     val |= *ptr++;
1909                     sprintf(pszObjId, ".%d", val);
1910                     pszObjId += strlen(pszObjId);
1911                 }
1912             }
1913             else
1914                 *(LPSTR *)pvStructInfo = NULL;
1915             *pcbStructInfo = bytesNeeded;
1916         }
1917     }
1918     return ret;
1919 }
1920
1921 static BOOL WINAPI CRYPT_AsnDecodeOid(DWORD dwCertEncodingType,
1922  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1923  void *pvStructInfo, DWORD *pcbStructInfo)
1924 {
1925     BOOL ret = FALSE;
1926
1927     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1928      pvStructInfo, *pcbStructInfo);
1929
1930     if (!cbEncoded)
1931         SetLastError(CRYPT_E_ASN1_CORRUPT);
1932     else if (pbEncoded[0] == ASN_OBJECTIDENTIFIER)
1933         ret = CRYPT_AsnDecodeOidIgnoreTag(dwCertEncodingType, lpszStructType,
1934          pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo);
1935     else
1936         SetLastError(CRYPT_E_ASN1_BADTAG);
1937     return ret;
1938 }
1939
1940 static BOOL WINAPI CRYPT_AsnDecodeCopyBytes(DWORD dwCertEncodingType,
1941  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1942  void *pvStructInfo, DWORD *pcbStructInfo)
1943 {
1944     BOOL ret = TRUE;
1945     DWORD bytesNeeded = sizeof(CRYPT_OBJID_BLOB);
1946
1947     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1948      pvStructInfo, *pcbStructInfo);
1949
1950     if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1951         bytesNeeded += cbEncoded;
1952     if (!pvStructInfo)
1953         *pcbStructInfo = bytesNeeded;
1954     else if (*pcbStructInfo < bytesNeeded)
1955     {
1956         SetLastError(ERROR_MORE_DATA);
1957         *pcbStructInfo = bytesNeeded;
1958         ret = FALSE;
1959     }
1960     else
1961     {
1962         PCRYPT_OBJID_BLOB blob = (PCRYPT_OBJID_BLOB)pvStructInfo;
1963
1964         *pcbStructInfo = bytesNeeded;
1965         blob->cbData = cbEncoded;
1966         if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1967             blob->pbData = (LPBYTE)pbEncoded;
1968         else
1969         {
1970             assert(blob->pbData);
1971             memcpy(blob->pbData, pbEncoded, blob->cbData);
1972         }
1973     }
1974     return ret;
1975 }
1976
1977 static BOOL WINAPI CRYPT_AsnDecodeAttributeTypeValue(DWORD dwCertEncodingType,
1978  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1979  void *pvStructInfo, DWORD *pcbStructInfo)
1980 {
1981     CRYPT_ATTRIBUTE_TYPE_VALUE *typeValue =
1982      (CRYPT_ATTRIBUTE_TYPE_VALUE *)pvStructInfo;
1983     struct AsnDecodeSequenceItem items[] = {
1984      { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, pszObjId),
1985        CRYPT_AsnDecodeOid, sizeof(LPSTR), FALSE, TRUE,
1986        offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, pszObjId), 0 },
1987      { 0, offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, Value),
1988        CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_DATA_BLOB), TRUE, TRUE,
1989        offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, Value.pbData), 0 },
1990     };
1991
1992     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1993      pvStructInfo, *pcbStructInfo);
1994
1995     return CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
1996      sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
1997      pvStructInfo, pcbStructInfo,
1998      typeValue ? typeValue->pszObjId : NULL);
1999 }
2000
2001 static BOOL WINAPI CRYPT_AsnDecodeAlgorithmId(DWORD dwCertEncodingType,
2002  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2003  void *pvStructInfo, DWORD *pcbStructInfo)
2004 {
2005     CRYPT_ALGORITHM_IDENTIFIER *algo =
2006      (CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
2007     BOOL ret = TRUE;
2008     struct AsnDecodeSequenceItem items[] = {
2009      { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId),
2010        CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2011        offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId), 0 },
2012      { 0, offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters),
2013        CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
2014        offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters.pbData), 0 },
2015     };
2016
2017     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2018      pvStructInfo, *pcbStructInfo);
2019
2020     ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2021      sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2022      pvStructInfo, pcbStructInfo, algo ? algo->pszObjId : NULL);
2023     if (ret && pvStructInfo)
2024     {
2025         TRACE("pszObjId is %p (%s)\n", algo->pszObjId,
2026          debugstr_a(algo->pszObjId));
2027     }
2028     return ret;
2029 }
2030
2031 static BOOL WINAPI CRYPT_AsnDecodeSPCDigest(DWORD dwCertEncodingType,
2032  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2033  void *pvStructInfo, DWORD *pcbStructInfo)
2034 {
2035     struct SPCDigest *digest =
2036      (struct SPCDigest *)pvStructInfo;
2037     struct AsnDecodeSequenceItem items[] = {
2038      { ASN_SEQUENCEOF, offsetof(struct SPCDigest, DigestAlgorithm),
2039        CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
2040        FALSE, TRUE,
2041        offsetof(struct SPCDigest, DigestAlgorithm.pszObjId), 0 },
2042      { ASN_OCTETSTRING, offsetof(struct SPCDigest, Digest),
2043        CRYPT_AsnDecodeOctets, sizeof(CRYPT_DER_BLOB),
2044        FALSE, TRUE, offsetof(struct SPCDigest, Digest.pbData), 0 },
2045     };
2046
2047     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2048      pvStructInfo, *pcbStructInfo);
2049
2050     return CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2051      sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2052      pvStructInfo, pcbStructInfo,
2053      digest ? digest->DigestAlgorithm.pszObjId : NULL);
2054 }
2055
2056 BOOL WINAPI WVTAsn1SpcIndirectDataContentDecode(DWORD dwCertEncodingType,
2057  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2058  void *pvStructInfo, DWORD *pcbStructInfo)
2059 {
2060     BOOL ret = FALSE;
2061
2062     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2063      pvStructInfo, *pcbStructInfo);
2064
2065     __TRY
2066     {
2067         struct AsnDecodeSequenceItem items[] = {
2068          { ASN_SEQUENCEOF, offsetof(SPC_INDIRECT_DATA_CONTENT, Data),
2069            CRYPT_AsnDecodeAttributeTypeValue,
2070            sizeof(CRYPT_ATTRIBUTE_TYPE_VALUE), FALSE, TRUE,
2071            offsetof(SPC_INDIRECT_DATA_CONTENT, Data.pszObjId), 0 },
2072          { ASN_SEQUENCEOF, offsetof(SPC_INDIRECT_DATA_CONTENT, DigestAlgorithm),
2073            CRYPT_AsnDecodeSPCDigest, sizeof(struct SPCDigest),
2074            FALSE, TRUE,
2075            offsetof(SPC_INDIRECT_DATA_CONTENT, DigestAlgorithm.pszObjId), 0 },
2076         };
2077
2078         ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2079          sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2080          pvStructInfo, pcbStructInfo, NULL);
2081     }
2082     __EXCEPT_PAGE_FAULT
2083     {
2084         SetLastError(STATUS_ACCESS_VIOLATION);
2085     }
2086     __ENDTRY
2087     TRACE("returning %d\n", ret);
2088     return ret;
2089 }
2090
2091 BOOL WINAPI WVTAsn1SpcSpOpusInfoDecode(DWORD dwCertEncodingType,
2092  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2093  void *pvStructInfo, DWORD *pcbStructInfo)
2094 {
2095     FIXME("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2096      pvStructInfo, *pcbStructInfo);
2097     return FALSE;
2098 }
2099
2100 static BOOL WINAPI CRYPT_AsnDecodeBMPString(DWORD dwCertEncodingType,
2101  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2102  void *pvStructInfo, DWORD *pcbStructInfo)
2103 {
2104     BOOL ret;
2105     DWORD bytesNeeded, dataLen;
2106
2107     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2108     {
2109         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2110
2111         bytesNeeded = dataLen + 2 + sizeof(LPWSTR);
2112         if (!pvStructInfo)
2113             *pcbStructInfo = bytesNeeded;
2114         else if (*pcbStructInfo < bytesNeeded)
2115         {
2116             *pcbStructInfo = bytesNeeded;
2117             SetLastError(ERROR_MORE_DATA);
2118             ret = FALSE;
2119         }
2120         else
2121         {
2122             LPWSTR str;
2123             DWORD i;
2124
2125             *pcbStructInfo = bytesNeeded;
2126             assert(pvStructInfo);
2127             str = *(LPWSTR *)pvStructInfo;
2128             for (i = 0; i < dataLen / 2; i++)
2129                 str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
2130                  pbEncoded[1 + lenBytes + 2 * i + 1];
2131             /* Decoded string is always NULL-terminated */
2132             str[i] = '\0';
2133         }
2134     }
2135     return ret;
2136 }
2137
2138 static BOOL CRYPT_AsnDecodeInteger(const BYTE *pbEncoded,
2139  DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
2140 {
2141     BOOL ret;
2142     DWORD bytesNeeded, dataLen;
2143
2144     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2145     {
2146         BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2147
2148         bytesNeeded = dataLen + sizeof(CRYPT_INTEGER_BLOB);
2149         if (!pvStructInfo)
2150             *pcbStructInfo = bytesNeeded;
2151         else if (*pcbStructInfo < bytesNeeded)
2152         {
2153             *pcbStructInfo = bytesNeeded;
2154             SetLastError(ERROR_MORE_DATA);
2155             ret = FALSE;
2156         }
2157         else
2158         {
2159             CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)pvStructInfo;
2160
2161             *pcbStructInfo = bytesNeeded;
2162             blob->cbData = dataLen;
2163             assert(blob->pbData);
2164             if (blob->cbData)
2165             {
2166                 DWORD i;
2167
2168                 for (i = 0; i < blob->cbData; i++)
2169                 {
2170                     blob->pbData[i] = *(pbEncoded + 1 + lenBytes +
2171                      dataLen - i - 1);
2172                 }
2173             }
2174         }
2175     }
2176     return ret;
2177 }
2178
2179 /* Ignores tag.  Only allows integers 4 bytes or smaller in size. */
2180 static BOOL WINAPI CRYPT_AsnDecodeInt(DWORD dwCertEncodingType,
2181  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2182  void *pvStructInfo, DWORD *pcbStructInfo)
2183 {
2184     BOOL ret;
2185     BYTE buf[sizeof(CRYPT_INTEGER_BLOB) + sizeof(int)];
2186     CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)buf;
2187     DWORD size = sizeof(buf);
2188
2189     blob->pbData = buf + sizeof(CRYPT_INTEGER_BLOB);
2190     ret = CRYPT_AsnDecodeInteger(pbEncoded, cbEncoded, 0, buf, &size);
2191     if (ret)
2192     {
2193         if (!pvStructInfo)
2194             *pcbStructInfo = sizeof(int);
2195         else if (*pcbStructInfo < sizeof(int))
2196         {
2197             *pcbStructInfo = sizeof(int);
2198             SetLastError(ERROR_MORE_DATA);
2199             ret = FALSE;
2200         }
2201         else
2202         {
2203             int val;
2204             DWORD i;
2205
2206             *pcbStructInfo = sizeof(int);
2207             if (blob->pbData[blob->cbData - 1] & 0x80)
2208             {
2209                 /* initialize to a negative value to sign-extend */
2210                 val = -1;
2211             }
2212             else
2213                 val = 0;
2214             for (i = 0; i < blob->cbData; i++)
2215             {
2216                 val <<= 8;
2217                 val |= blob->pbData[blob->cbData - i - 1];
2218             }
2219             memcpy(pvStructInfo, &val, sizeof(int));
2220         }
2221     }
2222     else if (GetLastError() == ERROR_MORE_DATA)
2223         SetLastError(CRYPT_E_ASN1_LARGE);
2224     return ret;
2225 }
2226
2227 BOOL WINAPI WVTAsn1CatMemberInfoDecode(DWORD dwCertEncodingType,
2228  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2229  void *pvStructInfo, DWORD *pcbStructInfo)
2230 {
2231     BOOL ret = FALSE;
2232
2233     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2234      pvStructInfo, *pcbStructInfo);
2235
2236     __TRY
2237     {
2238         struct AsnDecodeSequenceItem items[] = {
2239          { ASN_BMPSTRING, offsetof(CAT_MEMBERINFO, pwszSubjGuid),
2240            CRYPT_AsnDecodeBMPString, sizeof(LPWSTR), FALSE, TRUE,
2241            offsetof(CAT_MEMBERINFO, pwszSubjGuid), 0 },
2242          { ASN_INTEGER, offsetof(CAT_MEMBERINFO, dwCertVersion),
2243            CRYPT_AsnDecodeInt, sizeof(DWORD),
2244            FALSE, FALSE, 0, 0 },
2245         };
2246
2247         ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2248          sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2249          pvStructInfo, pcbStructInfo, NULL);
2250     }
2251     __EXCEPT_PAGE_FAULT
2252     {
2253         SetLastError(STATUS_ACCESS_VIOLATION);
2254     }
2255     __ENDTRY
2256     TRACE("returning %d\n", ret);
2257     return ret;
2258 }
2259
2260 BOOL WINAPI WVTAsn1CatNameValueDecode(DWORD dwCertEncodingType,
2261  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2262  void *pvStructInfo, DWORD *pcbStructInfo)
2263 {
2264     BOOL ret = FALSE;
2265
2266     TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2267      pvStructInfo, *pcbStructInfo);
2268
2269     __TRY
2270     {
2271         struct AsnDecodeSequenceItem items[] = {
2272          { ASN_BMPSTRING, offsetof(CAT_NAMEVALUE, pwszTag),
2273            CRYPT_AsnDecodeBMPString, sizeof(LPWSTR), FALSE, TRUE,
2274            offsetof(CAT_NAMEVALUE, pwszTag), 0 },
2275          { ASN_INTEGER, offsetof(CAT_NAMEVALUE, fdwFlags),
2276            CRYPT_AsnDecodeInt, sizeof(DWORD), FALSE, FALSE, 0, 0 },
2277          { ASN_OCTETSTRING, offsetof(CAT_NAMEVALUE, Value),
2278            CRYPT_AsnDecodeOctets, sizeof(CRYPT_DER_BLOB), FALSE, TRUE,
2279            offsetof(CAT_NAMEVALUE, Value.pbData), 0 },
2280         };
2281
2282         ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2283          sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2284          pvStructInfo, pcbStructInfo, NULL);
2285     }
2286     __EXCEPT_PAGE_FAULT
2287     {
2288         SetLastError(STATUS_ACCESS_VIOLATION);
2289     }
2290     __ENDTRY
2291     TRACE("returning %d\n", ret);
2292     return ret;
2293 }
2294
2295 static BOOL WINAPI CRYPT_AsnDecodeBool(DWORD dwCertEncodingType,
2296  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2297  void *pvStructInfo, DWORD *pcbStructInfo)
2298 {
2299     BOOL ret;
2300
2301     if (cbEncoded < 3)
2302     {
2303         SetLastError(CRYPT_E_ASN1_CORRUPT);
2304         return FALSE;
2305     }
2306     if (GET_LEN_BYTES(pbEncoded[1]) > 1)
2307     {
2308         SetLastError(CRYPT_E_ASN1_CORRUPT);
2309         return FALSE;
2310     }
2311     if (pbEncoded[1] > 1)
2312     {
2313         SetLastError(CRYPT_E_ASN1_CORRUPT);
2314         return FALSE;
2315     }
2316     if (!pvStructInfo)
2317     {
2318         *pcbStructInfo = sizeof(BOOL);
2319         ret = TRUE;
2320     }
2321     else if (*pcbStructInfo < sizeof(BOOL))
2322     {
2323         *pcbStructInfo = sizeof(BOOL);
2324         SetLastError(ERROR_MORE_DATA);
2325         ret = FALSE;
2326     }
2327     else
2328     {
2329         *pcbStructInfo = sizeof(BOOL);
2330         *(BOOL *)pvStructInfo = pbEncoded[2] ? TRUE : FALSE;
2331         ret = TRUE;
2332     }
2333     TRACE("returning %d (%08x)\n", ret, GetLastError());
2334     return ret;
2335 }
2336
2337 BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoDecode(DWORD dwCertEncodingType,
2338  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2339  void *pvStructInfo, DWORD *pcbStructInfo)
2340 {
2341     BOOL ret = FALSE;
2342
2343     TRACE("(%p, %d, %08x, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
2344      pvStructInfo, *pcbStructInfo);
2345
2346     __TRY
2347     {
2348         struct AsnDecodeSequenceItem items[] = {
2349          { ASN_BOOL, offsetof(SPC_FINANCIAL_CRITERIA, fFinancialInfoAvailable),
2350            CRYPT_AsnDecodeBool, sizeof(BOOL), FALSE, FALSE, 0, 0 },
2351          { ASN_BOOL, offsetof(SPC_FINANCIAL_CRITERIA, fMeetsCriteria),
2352            CRYPT_AsnDecodeBool, sizeof(BOOL), FALSE, FALSE, 0, 0 },
2353         };
2354
2355         ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2356          sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2357          pvStructInfo, pcbStructInfo, NULL);
2358     }
2359     __EXCEPT_PAGE_FAULT
2360     {
2361         SetLastError(STATUS_ACCESS_VIOLATION);
2362     }
2363     __ENDTRY
2364     TRACE("returning %d\n", ret);
2365     return ret;
2366 }