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