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