?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wintrust: Correct alignment for 64-bit.
[wine.git] / dlls / wintrust / asn.c
blob002eab5374dc23ce6469eb8c6824c078fa07537d
1 /* wintrust asn functions
2 *
3 * Copyright 2007 Juan Lang
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 *
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <assert.h>
27 #define NONAMELESSUNION
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winerror.h"
31 #include "wincrypt.h"
32 #include "wintrust.h"
33 #include "snmp.h"
34 #include "winternl.h"
35 #include "wine/debug.h"
36 #include "wine/exception.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(cryptasn);
39
40 #ifdef WORDS_BIGENDIAN
41
42 #define hton16(x) (x)
43 #define n16toh(x) (x)
44
45 #else
46
47 #define hton16(x) RtlUshortByteSwap(x)
48 #define n16toh(x) RtlUshortByteSwap(x)
49
50 #endif
51
52 #define ASN_BOOL (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x01)
53 #define ASN_BITSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x03)
54 #define ASN_BMPSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1e)
55
56 static BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded)
57 {
58 DWORD bytesNeeded, significantBytes = 0;
59
60 if (len <= 0x7f)
61 bytesNeeded = 1;
62 else
63 {
64 DWORD temp;
65
66 for (temp = len, significantBytes = sizeof(temp); !(temp & 0xff000000);
67 temp <<= 8, significantBytes--)
68 ;
69 bytesNeeded = significantBytes + 1;
70 }
71 if (!pbEncoded)
72 {
73 *pcbEncoded = bytesNeeded;
74 return TRUE;
75 }
76 if (*pcbEncoded < bytesNeeded)
77 {
78 SetLastError(ERROR_MORE_DATA);
79 return FALSE;
80 }
81 if (len <= 0x7f)
82 *pbEncoded = (BYTE)len;
83 else
84 {
85 DWORD i;
86
87 *pbEncoded++ = significantBytes | 0x80;
88 for (i = 0; i < significantBytes; i++)
89 {
90 *(pbEncoded + significantBytes - i - 1) = (BYTE)(len & 0xff);
91 len >>= 8;
92 }
93 }
94 *pcbEncoded = bytesNeeded;
95 return TRUE;
96 }
97
98 static BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
99 LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
100 DWORD *pcbEncoded)
101 {
102 BOOL ret = TRUE;
103 const CRYPT_DATA_BLOB *blob = pvStructInfo;
104 DWORD bytesNeeded, lenBytes;
105
106 TRACE("(%d, %p), %p, %d\n", blob->cbData, blob->pbData, pbEncoded,
107 *pcbEncoded);
108
109 CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes);
110 bytesNeeded = 1 + lenBytes + blob->cbData;
111 if (!pbEncoded)
112 *pcbEncoded = bytesNeeded;
113 else if (*pcbEncoded < bytesNeeded)
114 {
115 *pcbEncoded = bytesNeeded;
116 SetLastError(ERROR_MORE_DATA);
117 ret = FALSE;
118 }
119 else
120 {
121 *pbEncoded++ = ASN_OCTETSTRING;
122 CRYPT_EncodeLen(blob->cbData, pbEncoded, &lenBytes);
123 pbEncoded += lenBytes;
124 if (blob->cbData)
125 memcpy(pbEncoded, blob->pbData, blob->cbData);
126 }
127 TRACE("returning %d\n", ret);
128 return ret;
129 }
130
131 BOOL WINAPI WVTAsn1SpcLinkEncode(DWORD dwCertEncodingType,
132 LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
133 DWORD *pcbEncoded)
134 {
135 BOOL ret = FALSE;
136
137 TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
138 debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
139 pcbEncoded);
140
141 __TRY
142 {
143 const SPC_LINK *link = pvStructInfo;
144 DWORD bytesNeeded, lenBytes;
145
146 switch (link->dwLinkChoice)
147 {
148 case SPC_FILE_LINK_CHOICE:
149 {
150 DWORD fileNameLen, fileNameLenBytes;
151 LPWSTR ptr;
152
153 fileNameLen = link->u.pwszFile ?
154 lstrlenW(link->u.pwszFile) * sizeof(WCHAR) : 0;
155 CRYPT_EncodeLen(fileNameLen, NULL, &fileNameLenBytes);
156 CRYPT_EncodeLen(1 + fileNameLenBytes + fileNameLen, NULL,
157 &lenBytes);
158 bytesNeeded = 2 + lenBytes + fileNameLenBytes + fileNameLen;
159 if (!pbEncoded)
160 {
161 *pcbEncoded = bytesNeeded;
162 ret = TRUE;
163 }
164 else if (*pcbEncoded < bytesNeeded)
165 {
166 SetLastError(ERROR_MORE_DATA);
167 *pcbEncoded = bytesNeeded;
168 }
169 else
170 {
171 *pcbEncoded = bytesNeeded;
172 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_CONTEXT | 2;
173 CRYPT_EncodeLen(1 + fileNameLenBytes + fileNameLen, pbEncoded,
174 &lenBytes);
175 pbEncoded += lenBytes;
176 *pbEncoded++ = ASN_CONTEXT;
177 CRYPT_EncodeLen(fileNameLen, pbEncoded, &fileNameLenBytes);
178 pbEncoded += fileNameLenBytes;
179 for (ptr = link->u.pwszFile; ptr && *ptr; ptr++)
180 {
181 *(WCHAR *)pbEncoded = hton16(*ptr);
182 pbEncoded += sizeof(WCHAR);
183 }
184 ret = TRUE;
185 }
186 break;
187 }
188 case SPC_MONIKER_LINK_CHOICE:
189 {
190 DWORD classIdLenBytes, dataLenBytes, dataLen;
191 CRYPT_DATA_BLOB classId = { sizeof(link->u.Moniker.ClassId),
192 (BYTE *)link->u.Moniker.ClassId };
193
194 CRYPT_EncodeLen(classId.cbData, NULL, &classIdLenBytes);
195 CRYPT_EncodeLen(link->u.Moniker.SerializedData.cbData, NULL,
196 &dataLenBytes);
197 dataLen = 2 + classIdLenBytes + classId.cbData +
198 dataLenBytes + link->u.Moniker.SerializedData.cbData;
199 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
200 bytesNeeded = 1 + dataLen + lenBytes;
201 if (!pbEncoded)
202 {
203 *pcbEncoded = bytesNeeded;
204 ret = TRUE;
205 }
206 else if (*pcbEncoded < bytesNeeded)
207 {
208 SetLastError(ERROR_MORE_DATA);
209 *pcbEncoded = bytesNeeded;
210 }
211 else
212 {
213 DWORD size;
214
215 *pcbEncoded = bytesNeeded;
216 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_CONTEXT | 1;
217 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
218 pbEncoded += lenBytes;
219 size = 1 + classIdLenBytes + classId.cbData;
220 CRYPT_AsnEncodeOctets(X509_ASN_ENCODING, NULL, &classId,
221 pbEncoded, &size);
222 pbEncoded += size;
223 size = 1 + dataLenBytes + link->u.Moniker.SerializedData.cbData;
224 CRYPT_AsnEncodeOctets(X509_ASN_ENCODING, NULL,
225 &link->u.Moniker.SerializedData, pbEncoded, &size);
226 pbEncoded += size;
227 ret = TRUE;
228 }
229 break;
230 }
231 case SPC_URL_LINK_CHOICE:
232 {
233 LPWSTR ptr;
234 DWORD urlLen;
235
236 /* Check for invalid characters in URL */
237 ret = TRUE;
238 urlLen = 0;
239 for (ptr = link->u.pwszUrl; ptr && *ptr && ret; ptr++)
240 if (*ptr > 0x7f)
241 {
242 *pcbEncoded = 0;
243 SetLastError(CRYPT_E_INVALID_IA5_STRING);
244 ret = FALSE;
245 }
246 else
247 urlLen++;
248 if (ret)
249 {
250 CRYPT_EncodeLen(urlLen, NULL, &lenBytes);
251 bytesNeeded = 1 + lenBytes + urlLen;
252 if (!pbEncoded)
253 *pcbEncoded = bytesNeeded;
254 else if (*pcbEncoded < bytesNeeded)
255 {
256 SetLastError(ERROR_MORE_DATA);
257 *pcbEncoded = bytesNeeded;
258 ret = FALSE;
259 }
260 else
261 {
262 *pcbEncoded = bytesNeeded;
263 *pbEncoded++ = ASN_CONTEXT;
264 CRYPT_EncodeLen(urlLen, pbEncoded, &lenBytes);
265 pbEncoded += lenBytes;
266 for (ptr = link->u.pwszUrl; ptr && *ptr; ptr++)
267 *pbEncoded++ = (BYTE)*ptr;
268 }
269 }
270 break;
271 }
272 default:
273 SetLastError(E_INVALIDARG);
274 }
275 }
276 __EXCEPT_PAGE_FAULT
277 {
278 SetLastError(STATUS_ACCESS_VIOLATION);
279 }
280 __ENDTRY
281 TRACE("returning %d\n", ret);
282 return ret;
283 }
284
285 typedef BOOL (WINAPI *CryptEncodeObjectFunc)(DWORD, LPCSTR, const void *,
286 BYTE *, DWORD *);
287
288 struct AsnEncodeSequenceItem
289 {
290 const void *pvStructInfo;
291 CryptEncodeObjectFunc encodeFunc;
292 DWORD size; /* used during encoding, not for your use */
293 };
294
295 static BOOL CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
296 struct AsnEncodeSequenceItem items[], DWORD cItem, BYTE *pbEncoded,
297 DWORD *pcbEncoded)
298 {
299 BOOL ret;
300 DWORD i, dataLen = 0;
301
302 TRACE("%p, %d, %p, %d\n", items, cItem, pbEncoded, *pcbEncoded);
303 for (i = 0, ret = TRUE; ret && i < cItem; i++)
304 {
305 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
306 items[i].pvStructInfo, NULL, &items[i].size);
307 /* Some functions propagate their errors through the size */
308 if (!ret)
309 *pcbEncoded = items[i].size;
310 dataLen += items[i].size;
311 }
312 if (ret)
313 {
314 DWORD lenBytes, bytesNeeded;
315
316 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
317 bytesNeeded = 1 + lenBytes + dataLen;
318 if (!pbEncoded)
319 *pcbEncoded = bytesNeeded;
320 else if (*pcbEncoded < bytesNeeded)
321 {
322 *pcbEncoded = bytesNeeded;
323 SetLastError(ERROR_MORE_DATA);
324 ret = FALSE;
325 }
326 else
327 {
328 *pcbEncoded = bytesNeeded;
329 *pbEncoded++ = ASN_SEQUENCE;
330 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
331 pbEncoded += lenBytes;
332 for (i = 0; ret && i < cItem; i++)
333 {
334 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
335 items[i].pvStructInfo, pbEncoded, &items[i].size);
336 /* Some functions propagate their errors through the size */
337 if (!ret)
338 *pcbEncoded = items[i].size;
339 pbEncoded += items[i].size;
340 }
341 }
342 }
343 TRACE("returning %d\n", ret);
344 return ret;
345 }
346
347 static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType,
348 LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
349 DWORD *pcbEncoded)
350 {
351 BOOL ret = FALSE;
352
353 __TRY
354 {
355 const CRYPT_BIT_BLOB *blob = pvStructInfo;
356 DWORD bytesNeeded, lenBytes, dataBytes;
357 BYTE unusedBits;
358
359 /* yep, MS allows cUnusedBits to be >= 8 */
360 if (!blob->cUnusedBits)
361 {
362 dataBytes = blob->cbData;
363 unusedBits = 0;
364 }
365 else if (blob->cbData * 8 > blob->cUnusedBits)
366 {
367 dataBytes = (blob->cbData * 8 - blob->cUnusedBits) / 8 + 1;
368 unusedBits = blob->cUnusedBits >= 8 ? blob->cUnusedBits / 8 :
369 blob->cUnusedBits;
370 }
371 else
372 {
373 dataBytes = 0;
374 unusedBits = 0;
375 }
376 CRYPT_EncodeLen(dataBytes + 1, NULL, &lenBytes);
377 bytesNeeded = 1 + lenBytes + dataBytes + 1;
378 if (!pbEncoded)
379 {
380 *pcbEncoded = bytesNeeded;
381 ret = TRUE;
382 }
383 else if (*pcbEncoded < bytesNeeded)
384 {
385 *pcbEncoded = bytesNeeded;
386 SetLastError(ERROR_MORE_DATA);
387 }
388 else
389 {
390 ret = TRUE;
391 *pcbEncoded = bytesNeeded;
392 *pbEncoded++ = ASN_BITSTRING;
393 CRYPT_EncodeLen(dataBytes + 1, pbEncoded, &lenBytes);
394 pbEncoded += lenBytes;
395 *pbEncoded++ = unusedBits;
396 if (dataBytes)
397 {
398 BYTE mask = 0xff << unusedBits;
399
400 if (dataBytes > 1)
401 {
402 memcpy(pbEncoded, blob->pbData, dataBytes - 1);
403 pbEncoded += dataBytes - 1;
404 }
405 *pbEncoded = *(blob->pbData + dataBytes - 1) & mask;
406 }
407 }
408 }
409 __EXCEPT_PAGE_FAULT
410 {
411 SetLastError(STATUS_ACCESS_VIOLATION);
412 }
413 __ENDTRY
414 return ret;
415 }
416
417 struct AsnConstructedItem
418 {
419 BYTE tag;
420 const void *pvStructInfo;
421 CryptEncodeObjectFunc encodeFunc;
422 };
423
424 static BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType,
425 LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
426 DWORD *pcbEncoded)
427 {
428 BOOL ret;
429 const struct AsnConstructedItem *item = 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 = 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,
488 WVTAsn1SpcLinkEncode };
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
504 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
505 pbEncoded, pcbEncoded);
506 }
507 __EXCEPT_PAGE_FAULT
508 {
509 SetLastError(STATUS_ACCESS_VIOLATION);
510 }
511 __ENDTRY
512 TRACE("returning %d\n", ret);
513 return ret;
514 }
515
516 static BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
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 {
535 SetLastError(CRYPT_E_ASN1_ERROR);
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 {
569 SetLastError(CRYPT_E_ASN1_ERROR);
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 {
582 SetLastError(ERROR_MORE_DATA);
583 ret = FALSE;
584 }
585 else
586 {
587 *pbEncoded++ = ASN_OBJECTIDENTIFIER;
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
634 static BOOL WINAPI CRYPT_CopyEncodedBlob(DWORD dwCertEncodingType,
635 LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
636 DWORD *pcbEncoded)
637 {
638 const CRYPT_DER_BLOB *blob = pvStructInfo;
639 BOOL ret = TRUE;
640
641 if (!pbEncoded)
642 *pcbEncoded = blob->cbData;
643 else if (*pcbEncoded < blob->cbData)
644 {
645 *pcbEncoded = blob->cbData;
646 SetLastError(ERROR_MORE_DATA);
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
658 static BOOL WINAPI CRYPT_AsnEncodeAlgorithmIdWithNullParams(
659 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
660 BYTE *pbEncoded, DWORD *pcbEncoded)
661 {
662 const CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
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;
676 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
677 sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
678 return ret;
679 }
680
681 static BOOL WINAPI CRYPT_AsnEncodeAttributeTypeValue(DWORD dwCertEncodingType,
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
691 return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
692 items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
693 }
694
695 struct SPCDigest
696 {
697 CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm;
698 CRYPT_HASH_BLOB Digest;
699 };
700
701 static BOOL WINAPI CRYPT_AsnEncodeSPCDigest(DWORD dwCertEncodingType,
702 LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
703 DWORD *pcbEncoded)
704 {
705 const struct SPCDigest *digest = pvStructInfo;
706 struct AsnEncodeSequenceItem items[] = {
707 { &digest->DigestAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams, 0 },
708 { &digest->Digest, CRYPT_CopyEncodedBlob, 0 },
709 };
710
711 return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
712 items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
713 }
714
715 BOOL WINAPI WVTAsn1SpcIndirectDataContentEncode(DWORD dwCertEncodingType,
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 {
726 const SPC_INDIRECT_DATA_CONTENT *data = pvStructInfo;
727 struct AsnEncodeSequenceItem items[] = {
728 { &data->Data, CRYPT_AsnEncodeAttributeTypeValue, 0 },
729 { &data->DigestAlgorithm, CRYPT_AsnEncodeSPCDigest, 0 },
730 };
731
732 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
733 items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
734 }
735 __EXCEPT_PAGE_FAULT
736 {
737 SetLastError(STATUS_ACCESS_VIOLATION);
738 }
739 __ENDTRY
740 return ret;
741 }
742
743 static BOOL WINAPI CRYPT_AsnEncodeBMPString(DWORD dwCertEncodingType,
744 LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
745 DWORD *pcbEncoded)
746 {
747 BOOL ret = TRUE;
748 LPCWSTR str = pvStructInfo;
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;
762 SetLastError(ERROR_MORE_DATA);
763 ret = FALSE;
764 }
765 else
766 {
767 DWORD i;
768
769 *pcbEncoded = bytesNeeded;
770 *pbEncoded++ = ASN_BMPSTRING;
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
782 struct AsnEncodeTagSwappedItem
783 {
784 BYTE tag;
785 const void *pvStructInfo;
786 CryptEncodeObjectFunc encodeFunc;
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 */
793 static BOOL WINAPI CRYPT_AsnEncodeSwapTag(DWORD dwCertEncodingType,
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
807 BOOL WINAPI WVTAsn1SpcSpOpusInfoEncode(DWORD dwCertEncodingType,
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 {
818 const SPC_SP_OPUS_INFO *info = pvStructInfo;
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)
824 SetLastError(E_INVALIDARG);
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)
829 SetLastError(E_INVALIDARG);
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;
841 swapped.encodeFunc = CRYPT_AsnEncodeBMPString;
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 }
870 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
871 items, cItem, pbEncoded, pcbEncoded);
872 }
873 }
874 __EXCEPT_PAGE_FAULT
875 {
876 SetLastError(STATUS_ACCESS_VIOLATION);
877 }
878 __ENDTRY
879 return ret;
880 }
881
882 static BOOL CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType,
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;
893 const CRYPT_INTEGER_BLOB *blob = pvStructInfo;
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;
940 SetLastError(ERROR_MORE_DATA);
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 }
963 __EXCEPT_PAGE_FAULT
964 {
965 SetLastError(STATUS_ACCESS_VIOLATION);
966 ret = FALSE;
967 }
968 __ENDTRY
969 return ret;
970 }
971
972 static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType,
973 LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded,
974 DWORD *pcbEncoded)
975 {
976 CRYPT_INTEGER_BLOB blob = { sizeof(INT), (BYTE *)pvStructInfo };
977
978 return CRYPT_AsnEncodeInteger(dwCertEncodingType, X509_MULTI_BYTE_INTEGER,
979 &blob, pbEncoded, pcbEncoded);
980 }
981
982 BOOL WINAPI WVTAsn1CatMemberInfoEncode(DWORD dwCertEncodingType,
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 {
993 const CAT_MEMBERINFO *info = pvStructInfo;
994 struct AsnEncodeSequenceItem items[] = {
995 { info->pwszSubjGuid, CRYPT_AsnEncodeBMPString, 0 },
996 { &info->dwCertVersion, CRYPT_AsnEncodeInt, 0 },
997 };
998
999 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
1000 items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
1001 }
1002 __EXCEPT_PAGE_FAULT
1003 {
1004 SetLastError(STATUS_ACCESS_VIOLATION);
1005 }
1006 __ENDTRY
1007 return ret;
1008 }
1009
1010 BOOL WINAPI WVTAsn1CatNameValueEncode(DWORD dwCertEncodingType,
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
1028 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
1029 items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
1030 }
1031 __EXCEPT_PAGE_FAULT
1032 {
1033 SetLastError(STATUS_ACCESS_VIOLATION);
1034 }
1035 __ENDTRY
1036 return ret;
1037 }
1038
1039 static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
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;
1055 SetLastError(ERROR_MORE_DATA);
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
1070 BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoEncode(DWORD dwCertEncodingType,
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
1087 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
1088 items, sizeof(items) / sizeof(items[0]), pbEncoded, pcbEncoded);
1089 }
1090 __EXCEPT_PAGE_FAULT
1091 {
1092 SetLastError(STATUS_ACCESS_VIOLATION);
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 {
1112 SetLastError(CRYPT_E_ASN1_CORRUPT);
1113 ret = FALSE;
1114 }
1115 else if (pbEncoded[1] <= 0x7f)
1116 {
1117 if (pbEncoded[1] + 1 > cbEncoded)
1118 {
1119 SetLastError(CRYPT_E_ASN1_EOD);
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");
1131 SetLastError(CRYPT_E_ASN1_CORRUPT);
1132 ret = FALSE;
1133 }
1134 else
1135 {
1136 BYTE lenLen = GET_LEN_BYTES(pbEncoded[1]);
1137
1138 if (lenLen > sizeof(DWORD) + 1)
1139 {
1140 SetLastError(CRYPT_E_ASN1_LARGE);
1141 ret = FALSE;
1142 }
1143 else if (lenLen + 2 > cbEncoded)
1144 {
1145 SetLastError(CRYPT_E_ASN1_CORRUPT);
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 {
1160 SetLastError(CRYPT_E_ASN1_EOD);
1161 ret = FALSE;
1162 }
1163 else
1164 {
1165 *len = out;
1166 ret = TRUE;
1167 }
1168 }
1169 }
1170 return ret;
1171 }
1172
1173 static BOOL WINAPI CRYPT_AsnDecodeOctets(DWORD dwCertEncodingType,
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 {
1185 SetLastError(CRYPT_E_ASN1_CORRUPT);
1186 ret = FALSE;
1187 }
1188 else if (pbEncoded[0] != ASN_OCTETSTRING)
1189 {
1190 SetLastError(CRYPT_E_ASN1_BADTAG);
1191 ret = FALSE;
1192 }
1193 else if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1194 {
1195 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
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 {
1203 SetLastError(ERROR_MORE_DATA);
1204 *pcbStructInfo = bytesNeeded;
1205 ret = FALSE;
1206 }
1207 else
1208 {
1209 CRYPT_DATA_BLOB *blob;
1210 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1211
1212 blob = pvStructInfo;
1213 blob->cbData = dataLen;
1214 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
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
1228 static BOOL CRYPT_AsnDecodeSPCLinkInternal(DWORD dwCertEncodingType,
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;
1252 SetLastError(ERROR_MORE_DATA);
1253 ret = FALSE;
1254 }
1255 else
1256 {
1257 PSPC_LINK link = pvStructInfo;
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
1273 if ((ret = CRYPT_AsnDecodeOctets(dwCertEncodingType, NULL,
1274 pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
1275 CRYPT_DECODE_NOCOPY_FLAG, &classId, &size)))
1276 {
1277 if (classId.cbData != sizeof(SPC_UUID))
1278 {
1279 SetLastError(CRYPT_E_BAD_ENCODE);
1280 ret = FALSE;
1281 }
1282 else
1283 {
1284 CRYPT_DATA_BLOB data;
1285
1286 /* The tag length for the classId must be 1 since the
1287 * length is correct.
1288 */
1289 size = sizeof(data);
1290 if ((ret = CRYPT_AsnDecodeOctets(dwCertEncodingType, NULL,
1291 pbEncoded + 3 + lenBytes + classId.cbData,
1292 cbEncoded - 3 - lenBytes - classId.cbData,
1293 CRYPT_DECODE_NOCOPY_FLAG, &data, &size)))
1294 {
1295 bytesNeeded += data.cbData;
1296 if (!pvStructInfo)
1297 *pcbStructInfo = bytesNeeded;
1298 else if (*pcbStructInfo < bytesNeeded)
1299 {
1300 *pcbStructInfo = bytesNeeded;
1301 SetLastError(ERROR_MORE_DATA);
1302 ret = FALSE;
1303 }
1304 else
1305 {
1306 PSPC_LINK link = pvStructInfo;
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)
1327 SetLastError(CRYPT_E_ASN1_BADTAG);
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;
1339 SetLastError(ERROR_MORE_DATA);
1340 ret = FALSE;
1341 }
1342 else
1343 {
1344 PSPC_LINK link = pvStructInfo;
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(*(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;
1364 SetLastError(ERROR_MORE_DATA);
1365 ret = FALSE;
1366 }
1367 else
1368 {
1369 PSPC_LINK link = pvStructInfo;
1370
1371 link->dwLinkChoice = SPC_FILE_LINK_CHOICE;
1372 link->u.pwszFile[0] = '\0';
1373 ret = TRUE;
1374 }
1375 }
1376 break;
1377 default:
1378 SetLastError(CRYPT_E_ASN1_BADTAG);
1379 }
1380 }
1381 TRACE("returning %d\n", ret);
1382 return ret;
1383 }
1384
1385 BOOL WINAPI WVTAsn1SpcLinkDecode(DWORD dwCertEncodingType,
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
1398 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
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;
1407 SetLastError(ERROR_MORE_DATA);
1408 ret = FALSE;
1409 }
1410 else
1411 {
1412 SPC_LINK *link = pvStructInfo;
1413
1414 link->u.pwszFile =
1415 (LPWSTR)((BYTE *)pvStructInfo + sizeof(SPC_LINK));
1416 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
1417 lpszStructType, pbEncoded, cbEncoded, dwFlags, pvStructInfo,
1418 pcbStructInfo);
1419 }
1420 }
1421 }
1422 __EXCEPT_PAGE_FAULT
1423 {
1424 SetLastError(STATUS_ACCESS_VIOLATION);
1425 }
1426 __ENDTRY
1427 TRACE("returning %d\n", ret);
1428 return ret;
1429 }
1430
1431 typedef BOOL (WINAPI *CryptDecodeObjectFunc)(DWORD, LPCSTR, const BYTE *,
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;
1460 CryptDecodeObjectFunc decodeFunc;
1461 DWORD minSize;
1462 BOOL optional;
1463 BOOL hasPointer;
1464 DWORD pointerOffset;
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 /* Decodes the items in a sequence, where the items are described in items,
1473 * the encoded data are in pbEncoded with length cbEncoded. Decodes into
1474 * pvStructInfo. nextData is a pointer to the memory location at which the
1475 * first decoded item with a dynamic pointer should point.
1476 * Upon decoding, *cbDecoded is the total number of bytes decoded.
1477 */
1478 static BOOL CRYPT_AsnDecodeSequenceItems(DWORD dwCertEncodingType,
1479 struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded,
1480 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, BYTE *nextData,
1481 DWORD *cbDecoded)
1482 {
1483 BOOL ret;
1484 DWORD i, decoded = 0;
1485 const BYTE *ptr = pbEncoded;
1486
1487 TRACE("%p, %d, %p, %d, %08x, %p, %p, %p\n", items, cItem, pbEncoded,
1488 cbEncoded, dwFlags, pvStructInfo, nextData, cbDecoded);
1489
1490 for (i = 0, ret = TRUE; ret && i < cItem; i++)
1491 {
1492 if (cbEncoded - (ptr - pbEncoded) != 0)
1493 {
1494 DWORD nextItemLen;
1495
1496 if ((ret = CRYPT_GetLen(ptr, cbEncoded - (ptr - pbEncoded),
1497 &nextItemLen)))
1498 {
1499 BYTE nextItemLenBytes = GET_LEN_BYTES(ptr[1]);
1500
1501 if (ptr[0] == items[i].tag || !items[i].tag)
1502 {
1503 if (nextData && pvStructInfo && items[i].hasPointer)
1504 {
1505 TRACE("Setting next pointer to %p\n",
1506 nextData);
1507 *(BYTE **)((BYTE *)pvStructInfo +
1508 items[i].pointerOffset) = nextData;
1509 }
1510 if (items[i].decodeFunc)
1511 {
1512 if (pvStructInfo)
1513 TRACE("decoding item %d\n", i);
1514 else
1515 TRACE("sizing item %d\n", i);
1516 ret = items[i].decodeFunc(dwCertEncodingType,
1517 NULL, ptr, 1 + nextItemLenBytes + nextItemLen,
1518 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
1519 pvStructInfo ? (BYTE *)pvStructInfo + items[i].offset
1520 : NULL, &items[i].size);
1521 if (ret)
1522 {
1523 /* Account for alignment padding */
1524 items[i].size = ALIGN_DWORD_PTR(items[i].size);
1525 TRACE("item %d size: %d\n", i, items[i].size);
1526 if (nextData && items[i].hasPointer &&
1527 items[i].size > items[i].minSize)
1528 nextData += items[i].size - items[i].minSize;
1529 ptr += 1 + nextItemLenBytes + nextItemLen;
1530 decoded += 1 + nextItemLenBytes + nextItemLen;
1531 TRACE("item %d: decoded %d bytes\n", i,
1532 1 + nextItemLenBytes + nextItemLen);
1533 }
1534 else if (items[i].optional &&
1535 GetLastError() == CRYPT_E_ASN1_BADTAG)
1536 {
1537 TRACE("skipping optional item %d\n", i);
1538 items[i].size = items[i].minSize;
1539 SetLastError(NOERROR);
1540 ret = TRUE;
1541 }
1542 else
1543 TRACE("item %d failed: %08x\n", i,
1544 GetLastError());
1545 }
1546 else
1547 {
1548 TRACE("item %d: decoded %d bytes\n", i,
1549 1 + nextItemLenBytes + nextItemLen);
1550 ptr += 1 + nextItemLenBytes + nextItemLen;
1551 decoded += 1 + nextItemLenBytes + nextItemLen;
1552 items[i].size = items[i].minSize;
1553 }
1554 }
1555 else if (items[i].optional)
1556 {
1557 TRACE("skipping optional item %d\n", i);
1558 items[i].size = items[i].minSize;
1559 }
1560 else
1561 {
1562 TRACE("item %d: tag %02x doesn't match expected %02x\n",
1563 i, ptr[0], items[i].tag);
1564 SetLastError(CRYPT_E_ASN1_BADTAG);
1565 ret = FALSE;
1566 }
1567 }
1568 }
1569 else if (items[i].optional)
1570 {
1571 TRACE("missing optional item %d, skipping\n", i);
1572 items[i].size = items[i].minSize;
1573 }
1574 else
1575 {
1576 TRACE("not enough bytes for item %d, failing\n", i);
1577 SetLastError(CRYPT_E_ASN1_CORRUPT);
1578 ret = FALSE;
1579 }
1580 }
1581 if (ret)
1582 *cbDecoded = decoded;
1583 TRACE("returning %d\n", ret);
1584 return ret;
1585 }
1586
1587 /* This decodes an arbitrary sequence into a contiguous block of memory
1588 * (basically, a struct.) Each element being decoded is described by a struct
1589 * AsnDecodeSequenceItem, see above.
1590 * startingPointer is an optional pointer to the first place where dynamic
1591 * data will be stored. If you know the starting offset, you may pass it
1592 * here. Otherwise, pass NULL, and one will be inferred from the items.
1593 */
1594 static BOOL CRYPT_AsnDecodeSequence(DWORD dwCertEncodingType,
1595 struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded,
1596 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
1597 void *startingPointer)
1598 {
1599 BOOL ret;
1600
1601 TRACE("%p, %d, %p, %d, %08x, %p, %d, %p\n", items, cItem, pbEncoded,
1602 cbEncoded, dwFlags, pvStructInfo, *pcbStructInfo, startingPointer);
1603
1604 if (pbEncoded[0] == ASN_SEQUENCE)
1605 {
1606 DWORD dataLen;
1607
1608 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1609 {
1610 DWORD lenBytes = GET_LEN_BYTES(pbEncoded[1]), cbDecoded;
1611 const BYTE *ptr = pbEncoded + 1 + lenBytes;
1612
1613 cbEncoded -= 1 + lenBytes;
1614 if (cbEncoded < dataLen)
1615 {
1616 TRACE("dataLen %d exceeds cbEncoded %d, failing\n", dataLen,
1617 cbEncoded);
1618 SetLastError(CRYPT_E_ASN1_CORRUPT);
1619 ret = FALSE;
1620 }
1621 else
1622 ret = CRYPT_AsnDecodeSequenceItems(dwFlags, items, cItem, ptr,
1623 cbEncoded, dwFlags, NULL, NULL, &cbDecoded);
1624 if (ret && cbDecoded != dataLen)
1625 {
1626 TRACE("expected %d decoded, got %d, failing\n", dataLen,
1627 cbDecoded);
1628 SetLastError(CRYPT_E_ASN1_CORRUPT);
1629 ret = FALSE;
1630 }
1631 if (ret)
1632 {
1633 DWORD i, bytesNeeded = 0, structSize = 0;
1634
1635 for (i = 0; i < cItem; i++)
1636 {
1637 bytesNeeded += items[i].size;
1638 structSize += items[i].minSize;
1639 }
1640 if (!pvStructInfo)
1641 *pcbStructInfo = bytesNeeded;
1642 else if (*pcbStructInfo < bytesNeeded)
1643 {
1644 SetLastError(ERROR_MORE_DATA);
1645 *pcbStructInfo = bytesNeeded;
1646 ret = FALSE;
1647 }
1648 else
1649 {
1650 BYTE *nextData;
1651
1652 *pcbStructInfo = bytesNeeded;
1653 if (startingPointer)
1654 nextData = startingPointer;
1655 else
1656 nextData = (BYTE *)pvStructInfo + structSize;
1657 memset(pvStructInfo, 0, structSize);
1658 ret = CRYPT_AsnDecodeSequenceItems(dwFlags, items, cItem,
1659 ptr, cbEncoded, dwFlags, pvStructInfo, nextData,
1660 &cbDecoded);
1661 }
1662 }
1663 }
1664 }
1665 else
1666 {
1667 SetLastError(CRYPT_E_ASN1_BADTAG);
1668 ret = FALSE;
1669 }
1670 TRACE("returning %d (%08x)\n", ret, GetLastError());
1671 return ret;
1672 }
1673
1674 static BOOL WINAPI CRYPT_AsnDecodeBitsInternal(DWORD dwCertEncodingType,
1675 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1676 void *pvStructInfo, DWORD *pcbStructInfo)
1677 {
1678 BOOL ret;
1679
1680 TRACE("(%p, %d, 0x%08x, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
1681 pvStructInfo, *pcbStructInfo);
1682
1683 if (pbEncoded[0] == ASN_BITSTRING)
1684 {
1685 DWORD bytesNeeded, dataLen;
1686
1687 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1688 {
1689 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1690 bytesNeeded = sizeof(CRYPT_BIT_BLOB);
1691 else
1692 bytesNeeded = dataLen - 1 + sizeof(CRYPT_BIT_BLOB);
1693 if (!pvStructInfo)
1694 *pcbStructInfo = bytesNeeded;
1695 else if (*pcbStructInfo < bytesNeeded)
1696 {
1697 *pcbStructInfo = bytesNeeded;
1698 SetLastError(ERROR_MORE_DATA);
1699 ret = FALSE;
1700 }
1701 else
1702 {
1703 CRYPT_BIT_BLOB *blob;
1704
1705 blob = pvStructInfo;
1706 blob->cbData = dataLen - 1;
1707 blob->cUnusedBits = *(pbEncoded + 1 +
1708 GET_LEN_BYTES(pbEncoded[1]));
1709 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1710 {
1711 blob->pbData = (BYTE *)pbEncoded + 2 +
1712 GET_LEN_BYTES(pbEncoded[1]);
1713 }
1714 else
1715 {
1716 assert(blob->pbData);
1717 if (blob->cbData)
1718 {
1719 BYTE mask = 0xff << blob->cUnusedBits;
1720
1721 memcpy(blob->pbData, pbEncoded + 2 +
1722 GET_LEN_BYTES(pbEncoded[1]), blob->cbData);
1723 blob->pbData[blob->cbData - 1] &= mask;
1724 }
1725 }
1726 }
1727 }
1728 }
1729 else
1730 {
1731 SetLastError(CRYPT_E_ASN1_BADTAG);
1732 ret = FALSE;
1733 }
1734 TRACE("returning %d (%08x)\n", ret, GetLastError());
1735 return ret;
1736 }
1737
1738 static BOOL WINAPI CRYPT_AsnDecodeSPCLinkPointer(DWORD dwCertEncodingType,
1739 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1740 void *pvStructInfo, DWORD *pcbStructInfo)
1741 {
1742 BOOL ret = FALSE;
1743 DWORD dataLen;
1744
1745 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1746 {
1747 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1748 DWORD size;
1749 SPC_LINK **pLink = pvStructInfo;
1750
1751 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType, lpszStructType,
1752 pbEncoded + 1 + lenBytes, dataLen, dwFlags, NULL, &size);
1753 if (ret)
1754 {
1755 if (!pvStructInfo)
1756 *pcbStructInfo = size + sizeof(PSPC_LINK);
1757 else if (*pcbStructInfo < size + sizeof(PSPC_LINK))
1758 {
1759 *pcbStructInfo = size + sizeof(PSPC_LINK);
1760 SetLastError(ERROR_MORE_DATA);
1761 ret = FALSE;
1762 }
1763 else
1764 {
1765 *pcbStructInfo = size + sizeof(PSPC_LINK);
1766 /* Set imageData's pointer if necessary */
1767 if (size > sizeof(SPC_LINK))
1768 {
1769 (*pLink)->u.pwszUrl =
1770 (LPWSTR)((BYTE *)*pLink + sizeof(SPC_LINK));
1771 }
1772 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
1773 lpszStructType, pbEncoded + 1 + lenBytes, dataLen, dwFlags,
1774 *pLink, pcbStructInfo);
1775 }
1776 }
1777 }
1778 return ret;
1779 }
1780
1781 BOOL WINAPI WVTAsn1SpcPeImageDataDecode(DWORD dwCertEncodingType,
1782 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1783 void *pvStructInfo, DWORD *pcbStructInfo)
1784 {
1785 BOOL ret = FALSE;
1786
1787 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1788 pvStructInfo, *pcbStructInfo);
1789
1790 __TRY
1791 {
1792 struct AsnDecodeSequenceItem items[] = {
1793 { ASN_BITSTRING, offsetof(SPC_PE_IMAGE_DATA, Flags),
1794 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
1795 offsetof(SPC_PE_IMAGE_DATA, Flags.pbData), 0 },
1796 { ASN_CONSTRUCTOR | ASN_CONTEXT, offsetof(SPC_PE_IMAGE_DATA, pFile),
1797 CRYPT_AsnDecodeSPCLinkPointer, sizeof(PSPC_LINK), TRUE, TRUE,
1798 offsetof(SPC_PE_IMAGE_DATA, pFile), 0 },
1799 };
1800
1801 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
1802 sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
1803 pvStructInfo, pcbStructInfo, NULL);
1804 }
1805 __EXCEPT_PAGE_FAULT
1806 {
1807 SetLastError(STATUS_ACCESS_VIOLATION);
1808 }
1809 __ENDTRY
1810 TRACE("returning %d\n", ret);
1811 return ret;
1812 }
1813
1814 static BOOL WINAPI CRYPT_AsnDecodeOidIgnoreTag(DWORD dwCertEncodingType,
1815 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1816 void *pvStructInfo, DWORD *pcbStructInfo)
1817 {
1818 BOOL ret = TRUE;
1819 DWORD dataLen;
1820
1821 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1822 pvStructInfo, *pcbStructInfo);
1823
1824 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1825 {
1826 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1827 DWORD bytesNeeded = sizeof(LPSTR);
1828
1829 if (dataLen)
1830 {
1831 /* The largest possible string for the first two components
1832 * is 2.175 (= 2 * 40 + 175 = 255), so this is big enough.
1833 */
1834 char firstTwo[6];
1835 const BYTE *ptr;
1836
1837 snprintf(firstTwo, sizeof(firstTwo), "%d.%d",
1838 pbEncoded[1 + lenBytes] / 40,
1839 pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] / 40)
1840 * 40);
1841 bytesNeeded += strlen(firstTwo) + 1;
1842 for (ptr = pbEncoded + 2 + lenBytes; ret &&
1843 ptr - pbEncoded - 1 - lenBytes < dataLen; )
1844 {
1845 /* large enough for ".4000000" */
1846 char str[9];
1847 int val = 0;
1848
1849 while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1850 (*ptr & 0x80))
1851 {
1852 val <<= 7;
1853 val |= *ptr & 0x7f;
1854 ptr++;
1855 }
1856 if (ptr - pbEncoded - 1 - lenBytes >= dataLen ||
1857 (*ptr & 0x80))
1858 {
1859 SetLastError(CRYPT_E_ASN1_CORRUPT);
1860 ret = FALSE;
1861 }
1862 else
1863 {
1864 val <<= 7;
1865 val |= *ptr++;
1866 snprintf(str, sizeof(str), ".%d", val);
1867 bytesNeeded += strlen(str);
1868 }
1869 }
1870 }
1871 if (!pvStructInfo)
1872 *pcbStructInfo = bytesNeeded;
1873 else if (*pcbStructInfo < bytesNeeded)
1874 {
1875 *pcbStructInfo = bytesNeeded;
1876 SetLastError(ERROR_MORE_DATA);
1877 ret = FALSE;
1878 }
1879 else
1880 {
1881 if (dataLen)
1882 {
1883 const BYTE *ptr;
1884 LPSTR pszObjId = *(LPSTR *)pvStructInfo;
1885
1886 *pszObjId = 0;
1887 sprintf(pszObjId, "%d.%d", pbEncoded[1 + lenBytes] / 40,
1888 pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] /
1889 40) * 40);
1890 pszObjId += strlen(pszObjId);
1891 for (ptr = pbEncoded + 2 + lenBytes; ret &&
1892 ptr - pbEncoded - 1 - lenBytes < dataLen; )
1893 {
1894 int val = 0;
1895
1896 while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1897 (*ptr & 0x80))
1898 {
1899 val <<= 7;
1900 val |= *ptr & 0x7f;
1901 ptr++;
1902 }
1903 val <<= 7;
1904 val |= *ptr++;
1905 sprintf(pszObjId, ".%d", val);
1906 pszObjId += strlen(pszObjId);
1907 }
1908 }
1909 else
1910 *(LPSTR *)pvStructInfo = NULL;
1911 *pcbStructInfo = bytesNeeded;
1912 }
1913 }
1914 return ret;
1915 }
1916
1917 static BOOL WINAPI CRYPT_AsnDecodeOid(DWORD dwCertEncodingType,
1918 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1919 void *pvStructInfo, DWORD *pcbStructInfo)
1920 {
1921 BOOL ret = FALSE;
1922
1923 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1924 pvStructInfo, *pcbStructInfo);
1925
1926 if (!cbEncoded)
1927 SetLastError(CRYPT_E_ASN1_CORRUPT);
1928 else if (pbEncoded[0] == ASN_OBJECTIDENTIFIER)
1929 ret = CRYPT_AsnDecodeOidIgnoreTag(dwCertEncodingType, lpszStructType,
1930 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo);
1931 else
1932 SetLastError(CRYPT_E_ASN1_BADTAG);
1933 return ret;
1934 }
1935
1936 static BOOL WINAPI CRYPT_AsnDecodeCopyBytes(DWORD dwCertEncodingType,
1937 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1938 void *pvStructInfo, DWORD *pcbStructInfo)
1939 {
1940 BOOL ret = TRUE;
1941 DWORD bytesNeeded = sizeof(CRYPT_OBJID_BLOB);
1942
1943 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1944 pvStructInfo, *pcbStructInfo);
1945
1946 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1947 bytesNeeded += cbEncoded;
1948 if (!pvStructInfo)
1949 *pcbStructInfo = bytesNeeded;
1950 else if (*pcbStructInfo < bytesNeeded)
1951 {
1952 SetLastError(ERROR_MORE_DATA);
1953 *pcbStructInfo = bytesNeeded;
1954 ret = FALSE;
1955 }
1956 else
1957 {
1958 PCRYPT_OBJID_BLOB blob = pvStructInfo;
1959
1960 *pcbStructInfo = bytesNeeded;
1961 blob->cbData = cbEncoded;
1962 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1963 blob->pbData = (LPBYTE)pbEncoded;
1964 else
1965 {
1966 assert(blob->pbData);
1967 memcpy(blob->pbData, pbEncoded, blob->cbData);
1968 }
1969 }
1970 return ret;
1971 }
1972
1973 static BOOL WINAPI CRYPT_AsnDecodeAttributeTypeValue(DWORD dwCertEncodingType,
1974 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1975 void *pvStructInfo, DWORD *pcbStructInfo)
1976 {
1977 CRYPT_ATTRIBUTE_TYPE_VALUE *typeValue = pvStructInfo;
1978 struct AsnDecodeSequenceItem items[] = {
1979 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, pszObjId),
1980 CRYPT_AsnDecodeOid, sizeof(LPSTR), FALSE, TRUE,
1981 offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, pszObjId), 0 },
1982 { 0, offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, Value),
1983 CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_DATA_BLOB), TRUE, TRUE,
1984 offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, Value.pbData), 0 },
1985 };
1986
1987 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
1988 pvStructInfo, *pcbStructInfo);
1989
1990 return CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
1991 sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
1992 pvStructInfo, pcbStructInfo,
1993 typeValue ? typeValue->pszObjId : NULL);
1994 }
1995
1996 static BOOL WINAPI CRYPT_AsnDecodeAlgorithmId(DWORD dwCertEncodingType,
1997 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
1998 void *pvStructInfo, DWORD *pcbStructInfo)
1999 {
2000 CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
2001 BOOL ret = TRUE;
2002 struct AsnDecodeSequenceItem items[] = {
2003 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId),
2004 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2005 offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId), 0 },
2006 { 0, offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters),
2007 CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
2008 offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters.pbData), 0 },
2009 };
2010
2011 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2012 pvStructInfo, *pcbStructInfo);
2013
2014 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2015 sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2016 pvStructInfo, pcbStructInfo, algo ? algo->pszObjId : NULL);
2017 if (ret && pvStructInfo)
2018 {
2019 TRACE("pszObjId is %p (%s)\n", algo->pszObjId,
2020 debugstr_a(algo->pszObjId));
2021 }
2022 return ret;
2023 }
2024
2025 static BOOL WINAPI CRYPT_AsnDecodeSPCDigest(DWORD dwCertEncodingType,
2026 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2027 void *pvStructInfo, DWORD *pcbStructInfo)
2028 {
2029 struct SPCDigest *digest = pvStructInfo;
2030 struct AsnDecodeSequenceItem items[] = {
2031 { ASN_SEQUENCEOF, offsetof(struct SPCDigest, DigestAlgorithm),
2032 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
2033 FALSE, TRUE,
2034 offsetof(struct SPCDigest, DigestAlgorithm.pszObjId), 0 },
2035 { ASN_OCTETSTRING, offsetof(struct SPCDigest, Digest),
2036 CRYPT_AsnDecodeOctets, sizeof(CRYPT_DER_BLOB),
2037 FALSE, TRUE, offsetof(struct SPCDigest, Digest.pbData), 0 },
2038 };
2039
2040 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2041 pvStructInfo, *pcbStructInfo);
2042
2043 return CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2044 sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2045 pvStructInfo, pcbStructInfo,
2046 digest ? digest->DigestAlgorithm.pszObjId : NULL);
2047 }
2048
2049 BOOL WINAPI WVTAsn1SpcIndirectDataContentDecode(DWORD dwCertEncodingType,
2050 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2051 void *pvStructInfo, DWORD *pcbStructInfo)
2052 {
2053 BOOL ret = FALSE;
2054
2055 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2056 pvStructInfo, *pcbStructInfo);
2057
2058 __TRY
2059 {
2060 struct AsnDecodeSequenceItem items[] = {
2061 { ASN_SEQUENCEOF, offsetof(SPC_INDIRECT_DATA_CONTENT, Data),
2062 CRYPT_AsnDecodeAttributeTypeValue,
2063 sizeof(CRYPT_ATTRIBUTE_TYPE_VALUE), FALSE, TRUE,
2064 offsetof(SPC_INDIRECT_DATA_CONTENT, Data.pszObjId), 0 },
2065 { ASN_SEQUENCEOF, offsetof(SPC_INDIRECT_DATA_CONTENT, DigestAlgorithm),
2066 CRYPT_AsnDecodeSPCDigest, sizeof(struct SPCDigest),
2067 FALSE, TRUE,
2068 offsetof(SPC_INDIRECT_DATA_CONTENT, DigestAlgorithm.pszObjId), 0 },
2069 };
2070
2071 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2072 sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2073 pvStructInfo, pcbStructInfo, NULL);
2074 }
2075 __EXCEPT_PAGE_FAULT
2076 {
2077 SetLastError(STATUS_ACCESS_VIOLATION);
2078 }
2079 __ENDTRY
2080 TRACE("returning %d\n", ret);
2081 return ret;
2082 }
2083
2084 static BOOL WINAPI CRYPT_AsnDecodeBMPString(DWORD dwCertEncodingType,
2085 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2086 void *pvStructInfo, DWORD *pcbStructInfo)
2087 {
2088 BOOL ret;
2089 DWORD bytesNeeded, dataLen;
2090
2091 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2092 {
2093 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2094
2095 bytesNeeded = dataLen + 2 + sizeof(LPWSTR);
2096 if (!pvStructInfo)
2097 *pcbStructInfo = bytesNeeded;
2098 else if (*pcbStructInfo < bytesNeeded)
2099 {
2100 *pcbStructInfo = bytesNeeded;
2101 SetLastError(ERROR_MORE_DATA);
2102 ret = FALSE;
2103 }
2104 else
2105 {
2106 LPWSTR str;
2107 DWORD i;
2108
2109 *pcbStructInfo = bytesNeeded;
2110 assert(pvStructInfo);
2111 str = *(LPWSTR *)pvStructInfo;
2112 for (i = 0; i < dataLen / 2; i++)
2113 str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
2114 pbEncoded[1 + lenBytes + 2 * i + 1];
2115 /* Decoded string is always NULL-terminated */
2116 str[i] = '\0';
2117 }
2118 }
2119 return ret;
2120 }
2121
2122 static BOOL WINAPI CRYPT_AsnDecodeProgramName(DWORD dwCertEncodingType,
2123 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2124 void *pvStructInfo, DWORD *pcbStructInfo)
2125 {
2126 BOOL ret = FALSE;
2127 DWORD dataLen;
2128
2129 TRACE("(%p, %d, %08x, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
2130 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
2131
2132 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2133 {
2134 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2135
2136 ret = CRYPT_AsnDecodeBMPString(dwCertEncodingType, lpszStructType,
2137 pbEncoded + 1 + lenBytes, dataLen, dwFlags, pvStructInfo,
2138 pcbStructInfo);
2139 }
2140 return ret;
2141 }
2142
2143 BOOL WINAPI WVTAsn1SpcSpOpusInfoDecode(DWORD dwCertEncodingType,
2144 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2145 void *pvStructInfo, DWORD *pcbStructInfo)
2146 {
2147 BOOL ret = FALSE;
2148
2149 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2150 pvStructInfo, *pcbStructInfo);
2151
2152 __TRY
2153 {
2154 struct AsnDecodeSequenceItem items[] = {
2155 { ASN_CONSTRUCTOR | ASN_CONTEXT,
2156 offsetof(SPC_SP_OPUS_INFO, pwszProgramName),
2157 CRYPT_AsnDecodeProgramName, sizeof(LPCWSTR), TRUE, TRUE,
2158 offsetof(SPC_SP_OPUS_INFO, pwszProgramName), 0 },
2159 { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
2160 offsetof(SPC_SP_OPUS_INFO, pMoreInfo),
2161 CRYPT_AsnDecodeSPCLinkPointer, sizeof(PSPC_LINK), TRUE, TRUE,
2162 offsetof(SPC_SP_OPUS_INFO, pMoreInfo), 0 },
2163 { ASN_CONSTRUCTOR | ASN_CONTEXT | 2,
2164 offsetof(SPC_SP_OPUS_INFO, pPublisherInfo),
2165 CRYPT_AsnDecodeSPCLinkPointer, sizeof(PSPC_LINK), TRUE, TRUE,
2166 offsetof(SPC_SP_OPUS_INFO, pPublisherInfo), 0 },
2167 };
2168
2169 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2170 sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2171 pvStructInfo, pcbStructInfo, NULL);
2172 }
2173 __EXCEPT_PAGE_FAULT
2174 {
2175 SetLastError(STATUS_ACCESS_VIOLATION);
2176 }
2177 __ENDTRY
2178 TRACE("returning %d\n", ret);
2179 return ret;
2180 }
2181
2182 static BOOL CRYPT_AsnDecodeInteger(const BYTE *pbEncoded,
2183 DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
2184 {
2185 BOOL ret;
2186 DWORD bytesNeeded, dataLen;
2187
2188 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2189 {
2190 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2191
2192 bytesNeeded = dataLen + sizeof(CRYPT_INTEGER_BLOB);
2193 if (!pvStructInfo)
2194 *pcbStructInfo = bytesNeeded;
2195 else if (*pcbStructInfo < bytesNeeded)
2196 {
2197 *pcbStructInfo = bytesNeeded;
2198 SetLastError(ERROR_MORE_DATA);
2199 ret = FALSE;
2200 }
2201 else
2202 {
2203 CRYPT_INTEGER_BLOB *blob = pvStructInfo;
2204
2205 *pcbStructInfo = bytesNeeded;
2206 blob->cbData = dataLen;
2207 assert(blob->pbData);
2208 if (blob->cbData)
2209 {
2210 DWORD i;
2211
2212 for (i = 0; i < blob->cbData; i++)
2213 {
2214 blob->pbData[i] = *(pbEncoded + 1 + lenBytes +
2215 dataLen - i - 1);
2216 }
2217 }
2218 }
2219 }
2220 return ret;
2221 }
2222
2223 /* Ignores tag. Only allows integers 4 bytes or smaller in size. */
2224 static BOOL WINAPI CRYPT_AsnDecodeInt(DWORD dwCertEncodingType,
2225 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2226 void *pvStructInfo, DWORD *pcbStructInfo)
2227 {
2228 BOOL ret;
2229 BYTE buf[sizeof(CRYPT_INTEGER_BLOB) + sizeof(int)];
2230 CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)buf;
2231 DWORD size = sizeof(buf);
2232
2233 blob->pbData = buf + sizeof(CRYPT_INTEGER_BLOB);
2234 ret = CRYPT_AsnDecodeInteger(pbEncoded, cbEncoded, 0, buf, &size);
2235 if (ret)
2236 {
2237 if (!pvStructInfo)
2238 *pcbStructInfo = sizeof(int);
2239 else if (*pcbStructInfo < sizeof(int))
2240 {
2241 *pcbStructInfo = sizeof(int);
2242 SetLastError(ERROR_MORE_DATA);
2243 ret = FALSE;
2244 }
2245 else
2246 {
2247 int val;
2248 DWORD i;
2249
2250 *pcbStructInfo = sizeof(int);
2251 if (blob->pbData[blob->cbData - 1] & 0x80)
2252 {
2253 /* initialize to a negative value to sign-extend */
2254 val = -1;
2255 }
2256 else
2257 val = 0;
2258 for (i = 0; i < blob->cbData; i++)
2259 {
2260 val <<= 8;
2261 val |= blob->pbData[blob->cbData - i - 1];
2262 }
2263 memcpy(pvStructInfo, &val, sizeof(int));
2264 }
2265 }
2266 else if (GetLastError() == ERROR_MORE_DATA)
2267 SetLastError(CRYPT_E_ASN1_LARGE);
2268 return ret;
2269 }
2270
2271 BOOL WINAPI WVTAsn1CatMemberInfoDecode(DWORD dwCertEncodingType,
2272 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2273 void *pvStructInfo, DWORD *pcbStructInfo)
2274 {
2275 BOOL ret = FALSE;
2276
2277 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2278 pvStructInfo, *pcbStructInfo);
2279
2280 __TRY
2281 {
2282 struct AsnDecodeSequenceItem items[] = {
2283 { ASN_BMPSTRING, offsetof(CAT_MEMBERINFO, pwszSubjGuid),
2284 CRYPT_AsnDecodeBMPString, sizeof(LPWSTR), FALSE, TRUE,
2285 offsetof(CAT_MEMBERINFO, pwszSubjGuid), 0 },
2286 { ASN_INTEGER, offsetof(CAT_MEMBERINFO, dwCertVersion),
2287 CRYPT_AsnDecodeInt, sizeof(DWORD),
2288 FALSE, FALSE, 0, 0 },
2289 };
2290
2291 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2292 sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2293 pvStructInfo, pcbStructInfo, NULL);
2294 }
2295 __EXCEPT_PAGE_FAULT
2296 {
2297 SetLastError(STATUS_ACCESS_VIOLATION);
2298 }
2299 __ENDTRY
2300 TRACE("returning %d\n", ret);
2301 return ret;
2302 }
2303
2304 BOOL WINAPI WVTAsn1CatNameValueDecode(DWORD dwCertEncodingType,
2305 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2306 void *pvStructInfo, DWORD *pcbStructInfo)
2307 {
2308 BOOL ret = FALSE;
2309
2310 TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
2311 pvStructInfo, *pcbStructInfo);
2312
2313 __TRY
2314 {
2315 struct AsnDecodeSequenceItem items[] = {
2316 { ASN_BMPSTRING, offsetof(CAT_NAMEVALUE, pwszTag),
2317 CRYPT_AsnDecodeBMPString, sizeof(LPWSTR), FALSE, TRUE,
2318 offsetof(CAT_NAMEVALUE, pwszTag), 0 },
2319 { ASN_INTEGER, offsetof(CAT_NAMEVALUE, fdwFlags),
2320 CRYPT_AsnDecodeInt, sizeof(DWORD), FALSE, FALSE, 0, 0 },
2321 { ASN_OCTETSTRING, offsetof(CAT_NAMEVALUE, Value),
2322 CRYPT_AsnDecodeOctets, sizeof(CRYPT_DER_BLOB), FALSE, TRUE,
2323 offsetof(CAT_NAMEVALUE, Value.pbData), 0 },
2324 };
2325
2326 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2327 sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2328 pvStructInfo, pcbStructInfo, NULL);
2329 }
2330 __EXCEPT_PAGE_FAULT
2331 {
2332 SetLastError(STATUS_ACCESS_VIOLATION);
2333 }
2334 __ENDTRY
2335 TRACE("returning %d\n", ret);
2336 return ret;
2337 }
2338
2339 static BOOL WINAPI CRYPT_AsnDecodeBool(DWORD dwCertEncodingType,
2340 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2341 void *pvStructInfo, DWORD *pcbStructInfo)
2342 {
2343 BOOL ret;
2344
2345 if (cbEncoded < 3)
2346 {
2347 SetLastError(CRYPT_E_ASN1_CORRUPT);
2348 return FALSE;
2349 }
2350 if (GET_LEN_BYTES(pbEncoded[1]) > 1)
2351 {
2352 SetLastError(CRYPT_E_ASN1_CORRUPT);
2353 return FALSE;
2354 }
2355 if (pbEncoded[1] > 1)
2356 {
2357 SetLastError(CRYPT_E_ASN1_CORRUPT);
2358 return FALSE;
2359 }
2360 if (!pvStructInfo)
2361 {
2362 *pcbStructInfo = sizeof(BOOL);
2363 ret = TRUE;
2364 }
2365 else if (*pcbStructInfo < sizeof(BOOL))
2366 {
2367 *pcbStructInfo = sizeof(BOOL);
2368 SetLastError(ERROR_MORE_DATA);
2369 ret = FALSE;
2370 }
2371 else
2372 {
2373 *pcbStructInfo = sizeof(BOOL);
2374 *(BOOL *)pvStructInfo = pbEncoded[2] ? TRUE : FALSE;
2375 ret = TRUE;
2376 }
2377 TRACE("returning %d (%08x)\n", ret, GetLastError());
2378 return ret;
2379 }
2380
2381 BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoDecode(DWORD dwCertEncodingType,
2382 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
2383 void *pvStructInfo, DWORD *pcbStructInfo)
2384 {
2385 BOOL ret = FALSE;
2386
2387 TRACE("(%p, %d, %08x, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
2388 pvStructInfo, *pcbStructInfo);
2389
2390 __TRY
2391 {
2392 struct AsnDecodeSequenceItem items[] = {
2393 { ASN_BOOL, offsetof(SPC_FINANCIAL_CRITERIA, fFinancialInfoAvailable),
2394 CRYPT_AsnDecodeBool, sizeof(BOOL), FALSE, FALSE, 0, 0 },
2395 { ASN_BOOL, offsetof(SPC_FINANCIAL_CRITERIA, fMeetsCriteria),
2396 CRYPT_AsnDecodeBool, sizeof(BOOL), FALSE, FALSE, 0, 0 },
2397 };
2398
2399 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
2400 sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
2401 pvStructInfo, pcbStructInfo, NULL);
2402 }
2403 __EXCEPT_PAGE_FAULT
2404 {
2405 SetLastError(STATUS_ACCESS_VIOLATION);
2406 }
2407 __ENDTRY
2408 TRACE("returning %d\n", ret);
2409 return ret;
2410 }
Windows API implementation