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