?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32: Fix SPI_SETMOUSESPEED handling, the parameter is not a pointer.
[wine/wine64.git] / dlls / crypt32 / encode.c
blob2440d1696f14652b8ebf943f5b293c5f34630c60
1 /*
2 * Copyright 2005-2008 Juan Lang
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 *
18 * This file implements ASN.1 DER encoding of a limited set of types.
19 * It isn't a full ASN.1 implementation. Microsoft implements BER
20 * encoding of many of the basic types in msasn1.dll, but that interface isn't
21 * implemented, so I implement them here.
22 *
23 * References:
24 * "A Layman's Guide to a Subset of ASN.1, BER, and DER", by Burton Kaliski
25 * (available online, look for a PDF copy as the HTML versions tend to have
26 * translation errors.)
27 *
28 * RFC3280, http://www.faqs.org/rfcs/rfc3280.html
29 *
30 * MSDN, especially "Constants for CryptEncodeObject and CryptDecodeObject"
31 */
32
33 #include "config.h"
34 #include "wine/port.h"
35
36 #include <assert.h>
37 #include <stdarg.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40
41 #define NONAMELESSUNION
42
43 #include "windef.h"
44 #include "winbase.h"
45 #include "wincrypt.h"
46 #include "snmp.h"
47 #include "wine/debug.h"
48 #include "wine/exception.h"
49 #include "wine/unicode.h"
50 #include "crypt32_private.h"
51
52 WINE_DEFAULT_DEBUG_CHANNEL(cryptasn);
53 WINE_DECLARE_DEBUG_CHANNEL(crypt);
54
55 typedef BOOL (WINAPI *CryptEncodeObjectFunc)(DWORD, LPCSTR, const void *,
56 BYTE *, DWORD *);
57
58 /* Prototypes for built-in encoders. They follow the Ex style prototypes.
59 * The dwCertEncodingType and lpszStructType are ignored by the built-in
60 * functions, but the parameters are retained to simplify CryptEncodeObjectEx,
61 * since it must call functions in external DLLs that follow these signatures.
62 */
63 BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
64 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
65 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
66 static BOOL WINAPI CRYPT_AsnEncodeExtensions(DWORD dwCertEncodingType,
67 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
68 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
69 static BOOL WINAPI CRYPT_AsnEncodeSequenceOfAny(DWORD dwCertEncodingType,
70 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
71 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
72 static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
73 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
74 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
75 static BOOL WINAPI CRYPT_AsnEncodePubKeyInfo(DWORD dwCertEncodingType,
76 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
77 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
78 static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType,
79 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
80 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
81 static BOOL WINAPI CRYPT_AsnEncodeBitsSwapBytes(DWORD dwCertEncodingType,
82 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
83 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
84 static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType,
85 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
86 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
87 static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType,
88 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
89 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
90 static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType,
91 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
92 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
93 static BOOL WINAPI CRYPT_AsnEncodeChoiceOfTime(DWORD dwCertEncodingType,
94 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
95 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
96 static BOOL WINAPI CRYPT_AsnEncodeEnhancedKeyUsage(DWORD dwCertEncodingType,
97 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
98 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
99 static BOOL WINAPI CRYPT_AsnEncodePKCSAttributes(DWORD dwCertEncodingType,
100 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
101 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
102
103 BOOL CRYPT_EncodeEnsureSpace(DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara,
104 BYTE *pbEncoded, DWORD *pcbEncoded, DWORD bytesNeeded)
105 {
106 BOOL ret = TRUE;
107
108 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
109 {
110 if (pEncodePara && pEncodePara->pfnAlloc)
111 *(BYTE **)pbEncoded = pEncodePara->pfnAlloc(bytesNeeded);
112 else
113 *(BYTE **)pbEncoded = LocalAlloc(0, bytesNeeded);
114 if (!*(BYTE **)pbEncoded)
115 ret = FALSE;
116 else
117 *pcbEncoded = bytesNeeded;
118 }
119 else if (bytesNeeded > *pcbEncoded)
120 {
121 *pcbEncoded = bytesNeeded;
122 SetLastError(ERROR_MORE_DATA);
123 ret = FALSE;
124 }
125 else
126 *pcbEncoded = bytesNeeded;
127 return ret;
128 }
129
130 BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded)
131 {
132 DWORD bytesNeeded, significantBytes = 0;
133
134 if (len <= 0x7f)
135 bytesNeeded = 1;
136 else
137 {
138 DWORD temp;
139
140 for (temp = len, significantBytes = sizeof(temp); !(temp & 0xff000000);
141 temp <<= 8, significantBytes--)
142 ;
143 bytesNeeded = significantBytes + 1;
144 }
145 if (!pbEncoded)
146 {
147 *pcbEncoded = bytesNeeded;
148 return TRUE;
149 }
150 if (*pcbEncoded < bytesNeeded)
151 {
152 SetLastError(ERROR_MORE_DATA);
153 return FALSE;
154 }
155 if (len <= 0x7f)
156 *pbEncoded = (BYTE)len;
157 else
158 {
159 DWORD i;
160
161 *pbEncoded++ = significantBytes | 0x80;
162 for (i = 0; i < significantBytes; i++)
163 {
164 *(pbEncoded + significantBytes - i - 1) = (BYTE)(len & 0xff);
165 len >>= 8;
166 }
167 }
168 *pcbEncoded = bytesNeeded;
169 return TRUE;
170 }
171
172 BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
173 struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags,
174 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
175 {
176 BOOL ret;
177 DWORD i, dataLen = 0;
178
179 TRACE("%p, %d, %08x, %p, %p, %d\n", items, cItem, dwFlags, pEncodePara,
180 pbEncoded, *pcbEncoded);
181 for (i = 0, ret = TRUE; ret && i < cItem; i++)
182 {
183 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
184 items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL,
185 NULL, &items[i].size);
186 /* Some functions propagate their errors through the size */
187 if (!ret)
188 *pcbEncoded = items[i].size;
189 dataLen += items[i].size;
190 }
191 if (ret)
192 {
193 DWORD lenBytes, bytesNeeded;
194
195 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
196 bytesNeeded = 1 + lenBytes + dataLen;
197 if (!pbEncoded)
198 *pcbEncoded = bytesNeeded;
199 else
200 {
201 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
202 pcbEncoded, bytesNeeded)))
203 {
204 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
205 pbEncoded = *(BYTE **)pbEncoded;
206 *pbEncoded++ = ASN_SEQUENCE;
207 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
208 pbEncoded += lenBytes;
209 for (i = 0; ret && i < cItem; i++)
210 {
211 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
212 items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG,
213 NULL, pbEncoded, &items[i].size);
214 /* Some functions propagate their errors through the size */
215 if (!ret)
216 *pcbEncoded = items[i].size;
217 pbEncoded += items[i].size;
218 }
219 }
220 }
221 }
222 TRACE("returning %d (%08x)\n", ret, GetLastError());
223 return ret;
224 }
225
226 BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType,
227 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
228 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
229 {
230 BOOL ret;
231 const struct AsnConstructedItem *item =
232 (const struct AsnConstructedItem *)pvStructInfo;
233 DWORD len;
234
235 if ((ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
236 item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &len)))
237 {
238 DWORD dataLen, bytesNeeded;
239
240 CRYPT_EncodeLen(len, NULL, &dataLen);
241 bytesNeeded = 1 + dataLen + len;
242 if (!pbEncoded)
243 *pcbEncoded = bytesNeeded;
244 else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
245 pbEncoded, pcbEncoded, bytesNeeded)))
246 {
247 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
248 pbEncoded = *(BYTE **)pbEncoded;
249 *pbEncoded++ = ASN_CONTEXT | ASN_CONSTRUCTOR | item->tag;
250 CRYPT_EncodeLen(len, pbEncoded, &dataLen);
251 pbEncoded += dataLen;
252 ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
253 item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL,
254 pbEncoded, &len);
255 if (!ret)
256 {
257 /* Some functions propagate their errors through the size */
258 *pcbEncoded = len;
259 }
260 }
261 }
262 else
263 {
264 /* Some functions propagate their errors through the size */
265 *pcbEncoded = len;
266 }
267 return ret;
268 }
269
270 struct AsnEncodeTagSwappedItem
271 {
272 BYTE tag;
273 const void *pvStructInfo;
274 CryptEncodeObjectExFunc encodeFunc;
275 };
276
277 /* Sort of a wacky hack, it encodes something using the struct
278 * AsnEncodeTagSwappedItem's encodeFunc, then replaces the tag byte with the tag
279 * given in the struct AsnEncodeTagSwappedItem.
280 */
281 static BOOL WINAPI CRYPT_AsnEncodeSwapTag(DWORD dwCertEncodingType,
282 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
283 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
284 {
285 BOOL ret;
286 const struct AsnEncodeTagSwappedItem *item =
287 (const struct AsnEncodeTagSwappedItem *)pvStructInfo;
288
289 ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
290 item->pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
291 if (ret && pbEncoded)
292 *pbEncoded = item->tag;
293 return ret;
294 }
295
296 static BOOL WINAPI CRYPT_AsnEncodeCertVersion(DWORD dwCertEncodingType,
297 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
298 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
299 {
300 const DWORD *ver = (const DWORD *)pvStructInfo;
301 BOOL ret;
302
303 /* CERT_V1 is not encoded */
304 if (*ver == CERT_V1)
305 {
306 *pcbEncoded = 0;
307 ret = TRUE;
308 }
309 else
310 {
311 struct AsnConstructedItem item = { 0, ver, CRYPT_AsnEncodeInt };
312
313 ret = CRYPT_AsnEncodeConstructed(dwCertEncodingType, X509_INTEGER,
314 &item, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
315 }
316 return ret;
317 }
318
319 static BOOL WINAPI CRYPT_CopyEncodedBlob(DWORD dwCertEncodingType,
320 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
321 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
322 {
323 const CRYPT_DER_BLOB *blob = (const CRYPT_DER_BLOB *)pvStructInfo;
324 BOOL ret;
325
326 if (!pbEncoded)
327 {
328 *pcbEncoded = blob->cbData;
329 ret = TRUE;
330 }
331 else
332 {
333 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
334 pcbEncoded, blob->cbData)))
335 {
336 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
337 pbEncoded = *(BYTE **)pbEncoded;
338 if (blob->cbData)
339 memcpy(pbEncoded, blob->pbData, blob->cbData);
340 *pcbEncoded = blob->cbData;
341 ret = TRUE;
342 }
343 }
344 return ret;
345 }
346
347 static BOOL WINAPI CRYPT_AsnEncodeValidity(DWORD dwCertEncodingType,
348 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
349 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
350 {
351 BOOL ret;
352 /* This has two filetimes in a row, a NotBefore and a NotAfter */
353 const FILETIME *timePtr = (const FILETIME *)pvStructInfo;
354 struct AsnEncodeSequenceItem items[] = {
355 { timePtr, CRYPT_AsnEncodeChoiceOfTime, 0 },
356 { timePtr + 1, CRYPT_AsnEncodeChoiceOfTime, 0 },
357 };
358
359 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
360 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
361 pcbEncoded);
362 return ret;
363 }
364
365 /* Like CRYPT_AsnEncodeAlgorithmId, but encodes parameters as an asn.1 NULL
366 * if they are empty.
367 */
368 static BOOL WINAPI CRYPT_AsnEncodeAlgorithmIdWithNullParams(
369 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
370 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
371 DWORD *pcbEncoded)
372 {
373 const CRYPT_ALGORITHM_IDENTIFIER *algo =
374 (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
375 static const BYTE asn1Null[] = { ASN_NULL, 0 };
376 static const CRYPT_DATA_BLOB nullBlob = { sizeof(asn1Null),
377 (LPBYTE)asn1Null };
378 BOOL ret;
379 struct AsnEncodeSequenceItem items[2] = {
380 { algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
381 { NULL, CRYPT_CopyEncodedBlob, 0 },
382 };
383
384 if (algo->Parameters.cbData)
385 items[1].pvStructInfo = &algo->Parameters;
386 else
387 items[1].pvStructInfo = &nullBlob;
388 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
389 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
390 pcbEncoded);
391 return ret;
392 }
393
394 static BOOL WINAPI CRYPT_AsnEncodeAlgorithmId(DWORD dwCertEncodingType,
395 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
396 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
397 {
398 const CRYPT_ALGORITHM_IDENTIFIER *algo =
399 (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
400 BOOL ret;
401 struct AsnEncodeSequenceItem items[] = {
402 { algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
403 { &algo->Parameters, CRYPT_CopyEncodedBlob, 0 },
404 };
405
406 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
407 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
408 pcbEncoded);
409 return ret;
410 }
411
412 static BOOL WINAPI CRYPT_AsnEncodePubKeyInfo(DWORD dwCertEncodingType,
413 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
414 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
415 {
416 BOOL ret;
417
418 __TRY
419 {
420 const CERT_PUBLIC_KEY_INFO *info =
421 (const CERT_PUBLIC_KEY_INFO *)pvStructInfo;
422 struct AsnEncodeSequenceItem items[] = {
423 { &info->Algorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
424 { &info->PublicKey, CRYPT_AsnEncodeBits, 0 },
425 };
426
427 TRACE("Encoding public key with OID %s\n",
428 debugstr_a(info->Algorithm.pszObjId));
429 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
430 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
431 pcbEncoded);
432 }
433 __EXCEPT_PAGE_FAULT
434 {
435 SetLastError(STATUS_ACCESS_VIOLATION);
436 ret = FALSE;
437 }
438 __ENDTRY
439 return ret;
440 }
441
442 static BOOL WINAPI CRYPT_AsnEncodeCert(DWORD dwCertEncodingType,
443 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
444 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
445 {
446 BOOL ret;
447
448 __TRY
449 {
450 const CERT_SIGNED_CONTENT_INFO *info =
451 (const CERT_SIGNED_CONTENT_INFO *)pvStructInfo;
452 struct AsnEncodeSequenceItem items[] = {
453 { &info->ToBeSigned, CRYPT_CopyEncodedBlob, 0 },
454 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
455 { &info->Signature, CRYPT_AsnEncodeBitsSwapBytes, 0 },
456 };
457
458 if (dwFlags & CRYPT_ENCODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG)
459 items[2].encodeFunc = CRYPT_AsnEncodeBits;
460 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
461 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
462 pcbEncoded);
463 }
464 __EXCEPT_PAGE_FAULT
465 {
466 SetLastError(STATUS_ACCESS_VIOLATION);
467 ret = FALSE;
468 }
469 __ENDTRY
470 return ret;
471 }
472
473 /* Like in Windows, this blithely ignores the validity of the passed-in
474 * CERT_INFO, and just encodes it as-is. The resulting encoded data may not
475 * decode properly, see CRYPT_AsnDecodeCertInfo.
476 */
477 static BOOL WINAPI CRYPT_AsnEncodeCertInfo(DWORD dwCertEncodingType,
478 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
479 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
480 {
481 BOOL ret;
482
483 __TRY
484 {
485 const CERT_INFO *info = (const CERT_INFO *)pvStructInfo;
486 struct AsnEncodeSequenceItem items[10] = {
487 { &info->dwVersion, CRYPT_AsnEncodeCertVersion, 0 },
488 { &info->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
489 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
490 { &info->Issuer, CRYPT_CopyEncodedBlob, 0 },
491 { &info->NotBefore, CRYPT_AsnEncodeValidity, 0 },
492 { &info->Subject, CRYPT_CopyEncodedBlob, 0 },
493 { &info->SubjectPublicKeyInfo, CRYPT_AsnEncodePubKeyInfo, 0 },
494 { 0 }
495 };
496 struct AsnConstructedItem constructed[3] = { { 0 } };
497 DWORD cItem = 7, cConstructed = 0;
498
499 if (info->IssuerUniqueId.cbData)
500 {
501 constructed[cConstructed].tag = 1;
502 constructed[cConstructed].pvStructInfo = &info->IssuerUniqueId;
503 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeBits;
504 items[cItem].pvStructInfo = &constructed[cConstructed];
505 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
506 cConstructed++;
507 cItem++;
508 }
509 if (info->SubjectUniqueId.cbData)
510 {
511 constructed[cConstructed].tag = 2;
512 constructed[cConstructed].pvStructInfo = &info->SubjectUniqueId;
513 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeBits;
514 items[cItem].pvStructInfo = &constructed[cConstructed];
515 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
516 cConstructed++;
517 cItem++;
518 }
519 if (info->cExtension)
520 {
521 constructed[cConstructed].tag = 3;
522 constructed[cConstructed].pvStructInfo = &info->cExtension;
523 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeExtensions;
524 items[cItem].pvStructInfo = &constructed[cConstructed];
525 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
526 cConstructed++;
527 cItem++;
528 }
529
530 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
531 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
532 }
533 __EXCEPT_PAGE_FAULT
534 {
535 SetLastError(STATUS_ACCESS_VIOLATION);
536 ret = FALSE;
537 }
538 __ENDTRY
539 return ret;
540 }
541
542 static BOOL CRYPT_AsnEncodeCRLEntry(const CRL_ENTRY *entry,
543 BYTE *pbEncoded, DWORD *pcbEncoded)
544 {
545 struct AsnEncodeSequenceItem items[3] = {
546 { &entry->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
547 { &entry->RevocationDate, CRYPT_AsnEncodeChoiceOfTime, 0 },
548 { 0 }
549 };
550 DWORD cItem = 2;
551 BOOL ret;
552
553 TRACE("%p, %p, %p\n", entry, pbEncoded, pcbEncoded);
554
555 if (entry->cExtension)
556 {
557 items[cItem].pvStructInfo = &entry->cExtension;
558 items[cItem].encodeFunc = CRYPT_AsnEncodeExtensions;
559 cItem++;
560 }
561
562 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
563 pbEncoded, pcbEncoded);
564
565 TRACE("returning %d (%08x)\n", ret, GetLastError());
566 return ret;
567 }
568
569 static BOOL WINAPI CRYPT_AsnEncodeCRLEntries(DWORD dwCertEncodingType,
570 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
571 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
572 {
573 DWORD cCRLEntry = *(const DWORD *)pvStructInfo;
574 DWORD bytesNeeded, dataLen, lenBytes, i;
575 const CRL_ENTRY *rgCRLEntry = *(const CRL_ENTRY *const *)
576 ((const BYTE *)pvStructInfo + sizeof(DWORD));
577 BOOL ret = TRUE;
578
579 for (i = 0, dataLen = 0; ret && i < cCRLEntry; i++)
580 {
581 DWORD size;
582
583 ret = CRYPT_AsnEncodeCRLEntry(&rgCRLEntry[i], NULL, &size);
584 if (ret)
585 dataLen += size;
586 }
587 if (ret)
588 {
589 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
590 bytesNeeded = 1 + lenBytes + dataLen;
591 if (!pbEncoded)
592 *pcbEncoded = bytesNeeded;
593 else
594 {
595 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
596 pcbEncoded, bytesNeeded)))
597 {
598 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
599 pbEncoded = *(BYTE **)pbEncoded;
600 *pbEncoded++ = ASN_SEQUENCEOF;
601 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
602 pbEncoded += lenBytes;
603 for (i = 0; i < cCRLEntry; i++)
604 {
605 DWORD size = dataLen;
606
607 ret = CRYPT_AsnEncodeCRLEntry(&rgCRLEntry[i], pbEncoded,
608 &size);
609 pbEncoded += size;
610 dataLen -= size;
611 }
612 }
613 }
614 }
615 return ret;
616 }
617
618 static BOOL WINAPI CRYPT_AsnEncodeCRLVersion(DWORD dwCertEncodingType,
619 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
620 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
621 {
622 const DWORD *ver = (const DWORD *)pvStructInfo;
623 BOOL ret;
624
625 /* CRL_V1 is not encoded */
626 if (*ver == CRL_V1)
627 {
628 *pcbEncoded = 0;
629 ret = TRUE;
630 }
631 else
632 ret = CRYPT_AsnEncodeInt(dwCertEncodingType, X509_INTEGER, ver,
633 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
634 return ret;
635 }
636
637 /* Like in Windows, this blithely ignores the validity of the passed-in
638 * CRL_INFO, and just encodes it as-is. The resulting encoded data may not
639 * decode properly, see CRYPT_AsnDecodeCRLInfo.
640 */
641 static BOOL WINAPI CRYPT_AsnEncodeCRLInfo(DWORD dwCertEncodingType,
642 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
643 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
644 {
645 BOOL ret;
646
647 __TRY
648 {
649 const CRL_INFO *info = (const CRL_INFO *)pvStructInfo;
650 struct AsnEncodeSequenceItem items[7] = {
651 { &info->dwVersion, CRYPT_AsnEncodeCRLVersion, 0 },
652 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
653 { &info->Issuer, CRYPT_CopyEncodedBlob, 0 },
654 { &info->ThisUpdate, CRYPT_AsnEncodeChoiceOfTime, 0 },
655 { 0 }
656 };
657 struct AsnConstructedItem constructed[1] = { { 0 } };
658 DWORD cItem = 4, cConstructed = 0;
659
660 if (info->NextUpdate.dwLowDateTime || info->NextUpdate.dwHighDateTime)
661 {
662 items[cItem].pvStructInfo = &info->NextUpdate;
663 items[cItem].encodeFunc = CRYPT_AsnEncodeChoiceOfTime;
664 cItem++;
665 }
666 if (info->cCRLEntry)
667 {
668 items[cItem].pvStructInfo = &info->cCRLEntry;
669 items[cItem].encodeFunc = CRYPT_AsnEncodeCRLEntries;
670 cItem++;
671 }
672 if (info->cExtension)
673 {
674 constructed[cConstructed].tag = 0;
675 constructed[cConstructed].pvStructInfo = &info->cExtension;
676 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeExtensions;
677 items[cItem].pvStructInfo = &constructed[cConstructed];
678 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
679 cConstructed++;
680 cItem++;
681 }
682
683 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
684 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
685 }
686 __EXCEPT_PAGE_FAULT
687 {
688 SetLastError(STATUS_ACCESS_VIOLATION);
689 ret = FALSE;
690 }
691 __ENDTRY
692 return ret;
693 }
694
695 static BOOL CRYPT_AsnEncodeExtension(CERT_EXTENSION *ext, BYTE *pbEncoded,
696 DWORD *pcbEncoded)
697 {
698 BOOL ret;
699 struct AsnEncodeSequenceItem items[3] = {
700 { ext->pszObjId, CRYPT_AsnEncodeOid, 0 },
701 { NULL, NULL, 0 },
702 { NULL, NULL, 0 },
703 };
704 DWORD cItem = 1;
705
706 TRACE("%p, %p, %d\n", ext, pbEncoded, *pcbEncoded);
707
708 if (ext->fCritical)
709 {
710 items[cItem].pvStructInfo = &ext->fCritical;
711 items[cItem].encodeFunc = CRYPT_AsnEncodeBool;
712 cItem++;
713 }
714 items[cItem].pvStructInfo = &ext->Value;
715 items[cItem].encodeFunc = CRYPT_AsnEncodeOctets;
716 cItem++;
717
718 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
719 pbEncoded, pcbEncoded);
720 TRACE("returning %d (%08x)\n", ret, GetLastError());
721 return ret;
722 }
723
724 static BOOL WINAPI CRYPT_AsnEncodeExtensions(DWORD dwCertEncodingType,
725 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
726 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
727 {
728 BOOL ret;
729
730 __TRY
731 {
732 DWORD bytesNeeded, dataLen, lenBytes, i;
733 const CERT_EXTENSIONS *exts = (const CERT_EXTENSIONS *)pvStructInfo;
734
735 ret = TRUE;
736 for (i = 0, dataLen = 0; ret && i < exts->cExtension; i++)
737 {
738 DWORD size;
739
740 ret = CRYPT_AsnEncodeExtension(&exts->rgExtension[i], NULL, &size);
741 if (ret)
742 dataLen += size;
743 }
744 if (ret)
745 {
746 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
747 bytesNeeded = 1 + lenBytes + dataLen;
748 if (!pbEncoded)
749 *pcbEncoded = bytesNeeded;
750 else
751 {
752 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
753 pbEncoded, pcbEncoded, bytesNeeded)))
754 {
755 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
756 pbEncoded = *(BYTE **)pbEncoded;
757 *pbEncoded++ = ASN_SEQUENCEOF;
758 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
759 pbEncoded += lenBytes;
760 for (i = 0; i < exts->cExtension; i++)
761 {
762 DWORD size = dataLen;
763
764 ret = CRYPT_AsnEncodeExtension(&exts->rgExtension[i],
765 pbEncoded, &size);
766 pbEncoded += size;
767 dataLen -= size;
768 }
769 }
770 }
771 }
772 }
773 __EXCEPT_PAGE_FAULT
774 {
775 SetLastError(STATUS_ACCESS_VIOLATION);
776 ret = FALSE;
777 }
778 __ENDTRY
779 return ret;
780 }
781
782 BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
783 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
784 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
785 {
786 LPCSTR pszObjId = (LPCSTR)pvStructInfo;
787 DWORD bytesNeeded = 0, lenBytes;
788 BOOL ret = TRUE;
789 int firstPos = 0;
790 BYTE firstByte = 0;
791
792 TRACE("%s\n", debugstr_a(pszObjId));
793
794 if (pszObjId)
795 {
796 const char *ptr;
797 int val1, val2;
798
799 if (sscanf(pszObjId, "%d.%d%n", &val1, &val2, &firstPos) != 2)
800 {
801 SetLastError(CRYPT_E_ASN1_ERROR);
802 return FALSE;
803 }
804 bytesNeeded++;
805 firstByte = val1 * 40 + val2;
806 ptr = pszObjId + firstPos;
807 if (*ptr == '.')
808 {
809 ptr++;
810 firstPos++;
811 }
812 while (ret && *ptr)
813 {
814 int pos;
815
816 /* note I assume each component is at most 32-bits long in base 2 */
817 if (sscanf(ptr, "%d%n", &val1, &pos) == 1)
818 {
819 if (val1 >= 0x10000000)
820 bytesNeeded += 5;
821 else if (val1 >= 0x200000)
822 bytesNeeded += 4;
823 else if (val1 >= 0x4000)
824 bytesNeeded += 3;
825 else if (val1 >= 0x80)
826 bytesNeeded += 2;
827 else
828 bytesNeeded += 1;
829 ptr += pos;
830 if (*ptr == '.')
831 ptr++;
832 }
833 else
834 {
835 SetLastError(CRYPT_E_ASN1_ERROR);
836 return FALSE;
837 }
838 }
839 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
840 }
841 else
842 lenBytes = 1;
843 bytesNeeded += 1 + lenBytes;
844 if (pbEncoded)
845 {
846 if (*pcbEncoded < bytesNeeded)
847 {
848 SetLastError(ERROR_MORE_DATA);
849 ret = FALSE;
850 }
851 else
852 {
853 *pbEncoded++ = ASN_OBJECTIDENTIFIER;
854 CRYPT_EncodeLen(bytesNeeded - 1 - lenBytes, pbEncoded, &lenBytes);
855 pbEncoded += lenBytes;
856 if (pszObjId)
857 {
858 const char *ptr;
859 int val, pos;
860
861 *pbEncoded++ = firstByte;
862 ptr = pszObjId + firstPos;
863 while (ret && *ptr)
864 {
865 sscanf(ptr, "%d%n", &val, &pos);
866 {
867 unsigned char outBytes[5];
868 int numBytes, i;
869
870 if (val >= 0x10000000)
871 numBytes = 5;
872 else if (val >= 0x200000)
873 numBytes = 4;
874 else if (val >= 0x4000)
875 numBytes = 3;
876 else if (val >= 0x80)
877 numBytes = 2;
878 else
879 numBytes = 1;
880 for (i = numBytes; i > 0; i--)
881 {
882 outBytes[i - 1] = val & 0x7f;
883 val >>= 7;
884 }
885 for (i = 0; i < numBytes - 1; i++)
886 *pbEncoded++ = outBytes[i] | 0x80;
887 *pbEncoded++ = outBytes[i];
888 ptr += pos;
889 if (*ptr == '.')
890 ptr++;
891 }
892 }
893 }
894 }
895 }
896 *pcbEncoded = bytesNeeded;
897 return ret;
898 }
899
900 static BOOL CRYPT_AsnEncodeStringCoerce(const CERT_NAME_VALUE *value,
901 BYTE tag, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
902 DWORD *pcbEncoded)
903 {
904 BOOL ret = TRUE;
905 LPCSTR str = (LPCSTR)value->Value.pbData;
906 DWORD bytesNeeded, lenBytes, encodedLen;
907
908 encodedLen = value->Value.cbData ? value->Value.cbData : strlen(str);
909 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
910 bytesNeeded = 1 + lenBytes + encodedLen;
911 if (!pbEncoded)
912 *pcbEncoded = bytesNeeded;
913 else
914 {
915 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
916 pbEncoded, pcbEncoded, bytesNeeded)))
917 {
918 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
919 pbEncoded = *(BYTE **)pbEncoded;
920 *pbEncoded++ = tag;
921 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
922 pbEncoded += lenBytes;
923 memcpy(pbEncoded, str, encodedLen);
924 }
925 }
926 return ret;
927 }
928
929 static BOOL CRYPT_AsnEncodeBMPString(const CERT_NAME_VALUE *value,
930 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
931 DWORD *pcbEncoded)
932 {
933 BOOL ret = TRUE;
934 LPCWSTR str = (LPCWSTR)value->Value.pbData;
935 DWORD bytesNeeded, lenBytes, strLen;
936
937 if (value->Value.cbData)
938 strLen = value->Value.cbData / sizeof(WCHAR);
939 else if (value->Value.pbData)
940 strLen = lstrlenW(str);
941 else
942 strLen = 0;
943 CRYPT_EncodeLen(strLen * 2, NULL, &lenBytes);
944 bytesNeeded = 1 + lenBytes + strLen * 2;
945 if (!pbEncoded)
946 *pcbEncoded = bytesNeeded;
947 else
948 {
949 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
950 pbEncoded, pcbEncoded, bytesNeeded)))
951 {
952 DWORD i;
953
954 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
955 pbEncoded = *(BYTE **)pbEncoded;
956 *pbEncoded++ = ASN_BMPSTRING;
957 CRYPT_EncodeLen(strLen * 2, pbEncoded, &lenBytes);
958 pbEncoded += lenBytes;
959 for (i = 0; i < strLen; i++)
960 {
961 *pbEncoded++ = (str[i] & 0xff00) >> 8;
962 *pbEncoded++ = str[i] & 0x00ff;
963 }
964 }
965 }
966 return ret;
967 }
968
969 static BOOL CRYPT_AsnEncodeUTF8String(const CERT_NAME_VALUE *value,
970 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
971 DWORD *pcbEncoded)
972 {
973 BOOL ret = TRUE;
974 LPCWSTR str = (LPCWSTR)value->Value.pbData;
975 DWORD bytesNeeded, lenBytes, encodedLen, strLen;
976
977 strLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
978 strlenW(str);
979 encodedLen = WideCharToMultiByte(CP_UTF8, 0, str, strLen, NULL, 0, NULL,
980 NULL);
981 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
982 bytesNeeded = 1 + lenBytes + encodedLen;
983 if (!pbEncoded)
984 *pcbEncoded = bytesNeeded;
985 else
986 {
987 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
988 pbEncoded, pcbEncoded, bytesNeeded)))
989 {
990 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
991 pbEncoded = *(BYTE **)pbEncoded;
992 *pbEncoded++ = ASN_UTF8STRING;
993 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
994 pbEncoded += lenBytes;
995 WideCharToMultiByte(CP_UTF8, 0, str, strLen, (LPSTR)pbEncoded,
996 bytesNeeded - lenBytes - 1, NULL, NULL);
997 }
998 }
999 return ret;
1000 }
1001
1002 static BOOL WINAPI CRYPT_AsnEncodeNameValue(DWORD dwCertEncodingType,
1003 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1004 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1005 {
1006 BOOL ret = TRUE;
1007
1008 __TRY
1009 {
1010 const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
1011
1012 switch (value->dwValueType)
1013 {
1014 case CERT_RDN_ANY_TYPE:
1015 /* explicitly disallowed */
1016 SetLastError(E_INVALIDARG);
1017 ret = FALSE;
1018 break;
1019 case CERT_RDN_ENCODED_BLOB:
1020 ret = CRYPT_CopyEncodedBlob(dwCertEncodingType, NULL,
1021 &value->Value, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1022 break;
1023 case CERT_RDN_OCTET_STRING:
1024 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_OCTETSTRING,
1025 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1026 break;
1027 case CERT_RDN_NUMERIC_STRING:
1028 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_NUMERICSTRING,
1029 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1030 break;
1031 case CERT_RDN_PRINTABLE_STRING:
1032 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_PRINTABLESTRING,
1033 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1034 break;
1035 case CERT_RDN_TELETEX_STRING:
1036 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_T61STRING,
1037 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1038 break;
1039 case CERT_RDN_VIDEOTEX_STRING:
1040 ret = CRYPT_AsnEncodeStringCoerce(value,
1041 ASN_VIDEOTEXSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1042 break;
1043 case CERT_RDN_IA5_STRING:
1044 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_IA5STRING,
1045 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1046 break;
1047 case CERT_RDN_GRAPHIC_STRING:
1048 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_GRAPHICSTRING,
1049 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1050 break;
1051 case CERT_RDN_VISIBLE_STRING:
1052 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_VISIBLESTRING,
1053 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1054 break;
1055 case CERT_RDN_GENERAL_STRING:
1056 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_GENERALSTRING,
1057 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1058 break;
1059 case CERT_RDN_UNIVERSAL_STRING:
1060 FIXME("CERT_RDN_UNIVERSAL_STRING: unimplemented\n");
1061 SetLastError(CRYPT_E_ASN1_CHOICE);
1062 ret = FALSE;
1063 break;
1064 case CERT_RDN_BMP_STRING:
1065 ret = CRYPT_AsnEncodeBMPString(value, dwFlags, pEncodePara,
1066 pbEncoded, pcbEncoded);
1067 break;
1068 case CERT_RDN_UTF8_STRING:
1069 ret = CRYPT_AsnEncodeUTF8String(value, dwFlags, pEncodePara,
1070 pbEncoded, pcbEncoded);
1071 break;
1072 default:
1073 SetLastError(CRYPT_E_ASN1_CHOICE);
1074 ret = FALSE;
1075 }
1076 }
1077 __EXCEPT_PAGE_FAULT
1078 {
1079 SetLastError(STATUS_ACCESS_VIOLATION);
1080 ret = FALSE;
1081 }
1082 __ENDTRY
1083 return ret;
1084 }
1085
1086 static BOOL CRYPT_AsnEncodeRdnAttr(DWORD dwCertEncodingType,
1087 CERT_RDN_ATTR *attr, CryptEncodeObjectExFunc nameValueEncodeFunc,
1088 BYTE *pbEncoded, DWORD *pcbEncoded)
1089 {
1090 DWORD bytesNeeded = 0, lenBytes, size;
1091 BOOL ret;
1092
1093 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL, attr->pszObjId,
1094 0, NULL, NULL, &size);
1095 if (ret)
1096 {
1097 bytesNeeded += size;
1098 /* hack: a CERT_RDN_ATTR is identical to a CERT_NAME_VALUE beginning
1099 * with dwValueType, so "cast" it to get its encoded size
1100 */
1101 ret = nameValueEncodeFunc(dwCertEncodingType, NULL,
1102 (CERT_NAME_VALUE *)&attr->dwValueType, 0, NULL, NULL, &size);
1103 if (ret)
1104 {
1105 bytesNeeded += size;
1106 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1107 bytesNeeded += 1 + lenBytes;
1108 if (pbEncoded)
1109 {
1110 if (*pcbEncoded < bytesNeeded)
1111 {
1112 SetLastError(ERROR_MORE_DATA);
1113 ret = FALSE;
1114 }
1115 else
1116 {
1117 *pbEncoded++ = ASN_SEQUENCE;
1118 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
1119 &lenBytes);
1120 pbEncoded += lenBytes;
1121 size = bytesNeeded - 1 - lenBytes;
1122 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
1123 attr->pszObjId, 0, NULL, pbEncoded, &size);
1124 if (ret)
1125 {
1126 pbEncoded += size;
1127 size = bytesNeeded - 1 - lenBytes - size;
1128 ret = nameValueEncodeFunc(dwCertEncodingType,
1129 NULL, (CERT_NAME_VALUE *)&attr->dwValueType,
1130 0, NULL, pbEncoded, &size);
1131 if (!ret)
1132 *pcbEncoded = size;
1133 }
1134 }
1135 }
1136 if (ret)
1137 *pcbEncoded = bytesNeeded;
1138 }
1139 else
1140 {
1141 /* Have to propagate index of failing character */
1142 *pcbEncoded = size;
1143 }
1144 }
1145 return ret;
1146 }
1147
1148 static int BLOBComp(const void *l, const void *r)
1149 {
1150 const CRYPT_DER_BLOB *a = (const CRYPT_DER_BLOB *)l, *b = (const CRYPT_DER_BLOB *)r;
1151 int ret;
1152
1153 if (!(ret = memcmp(a->pbData, b->pbData, min(a->cbData, b->cbData))))
1154 ret = a->cbData - b->cbData;
1155 return ret;
1156 }
1157
1158 /* This encodes a SET OF, which in DER must be lexicographically sorted.
1159 */
1160 static BOOL WINAPI CRYPT_DEREncodeSet(DWORD dwCertEncodingType,
1161 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1162 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1163 {
1164 const CRYPT_BLOB_ARRAY *set = (const CRYPT_BLOB_ARRAY *)pvStructInfo;
1165 DWORD bytesNeeded = 0, lenBytes, i;
1166 BOOL ret;
1167
1168 for (i = 0; i < set->cBlob; i++)
1169 bytesNeeded += set->rgBlob[i].cbData;
1170 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1171 bytesNeeded += 1 + lenBytes;
1172 if (!pbEncoded)
1173 {
1174 *pcbEncoded = bytesNeeded;
1175 ret = TRUE;
1176 }
1177 else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1178 pbEncoded, pcbEncoded, bytesNeeded)))
1179 {
1180 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1181 pbEncoded = *(BYTE **)pbEncoded;
1182 qsort(set->rgBlob, set->cBlob, sizeof(CRYPT_DER_BLOB), BLOBComp);
1183 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_SETOF;
1184 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded, &lenBytes);
1185 pbEncoded += lenBytes;
1186 for (i = 0; ret && i < set->cBlob; i++)
1187 {
1188 memcpy(pbEncoded, set->rgBlob[i].pbData, set->rgBlob[i].cbData);
1189 pbEncoded += set->rgBlob[i].cbData;
1190 }
1191 }
1192 return ret;
1193 }
1194
1195 struct DERSetDescriptor
1196 {
1197 DWORD cItems;
1198 const void *items;
1199 size_t itemSize;
1200 size_t itemOffset;
1201 CryptEncodeObjectExFunc encode;
1202 };
1203
1204 static BOOL WINAPI CRYPT_DEREncodeItemsAsSet(DWORD dwCertEncodingType,
1205 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1206 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1207 {
1208 const struct DERSetDescriptor *desc =
1209 (const struct DERSetDescriptor *)pvStructInfo;
1210 CRYPT_BLOB_ARRAY setOf = { 0, NULL };
1211 BOOL ret = TRUE;
1212 DWORD i;
1213
1214 if (desc->cItems)
1215 {
1216 setOf.rgBlob = CryptMemAlloc(desc->cItems * sizeof(CRYPT_DER_BLOB));
1217 if (!setOf.rgBlob)
1218 ret = FALSE;
1219 else
1220 {
1221 setOf.cBlob = desc->cItems;
1222 memset(setOf.rgBlob, 0, setOf.cBlob * sizeof(CRYPT_DER_BLOB));
1223 }
1224 }
1225 for (i = 0; ret && i < setOf.cBlob; i++)
1226 {
1227 ret = desc->encode(dwCertEncodingType, lpszStructType,
1228 (const BYTE *)desc->items + i * desc->itemSize + desc->itemOffset,
1229 0, NULL, NULL, &setOf.rgBlob[i].cbData);
1230 if (ret)
1231 {
1232 setOf.rgBlob[i].pbData = CryptMemAlloc(setOf.rgBlob[i].cbData);
1233 if (!setOf.rgBlob[i].pbData)
1234 ret = FALSE;
1235 else
1236 ret = desc->encode(dwCertEncodingType, lpszStructType,
1237 (const BYTE *)desc->items + i * desc->itemSize +
1238 desc->itemOffset, 0, NULL, setOf.rgBlob[i].pbData,
1239 &setOf.rgBlob[i].cbData);
1240 }
1241 /* Some functions propagate their errors through the size */
1242 if (!ret)
1243 *pcbEncoded = setOf.rgBlob[i].cbData;
1244 }
1245 if (ret)
1246 {
1247 DWORD bytesNeeded = 0, lenBytes;
1248
1249 for (i = 0; i < setOf.cBlob; i++)
1250 bytesNeeded += setOf.rgBlob[i].cbData;
1251 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1252 bytesNeeded += 1 + lenBytes;
1253 if (!pbEncoded)
1254 *pcbEncoded = bytesNeeded;
1255 else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1256 pbEncoded, pcbEncoded, bytesNeeded)))
1257 {
1258 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1259 pbEncoded = *(BYTE **)pbEncoded;
1260 qsort(setOf.rgBlob, setOf.cBlob, sizeof(CRYPT_DER_BLOB),
1261 BLOBComp);
1262 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_SETOF;
1263 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded, &lenBytes);
1264 pbEncoded += lenBytes;
1265 for (i = 0; i < setOf.cBlob; i++)
1266 {
1267 memcpy(pbEncoded, setOf.rgBlob[i].pbData,
1268 setOf.rgBlob[i].cbData);
1269 pbEncoded += setOf.rgBlob[i].cbData;
1270 }
1271 }
1272 }
1273 for (i = 0; i < setOf.cBlob; i++)
1274 CryptMemFree(setOf.rgBlob[i].pbData);
1275 CryptMemFree(setOf.rgBlob);
1276 return ret;
1277 }
1278
1279 static BOOL CRYPT_AsnEncodeRdn(DWORD dwCertEncodingType, CERT_RDN *rdn,
1280 CryptEncodeObjectExFunc nameValueEncodeFunc, BYTE *pbEncoded,
1281 DWORD *pcbEncoded)
1282 {
1283 BOOL ret;
1284 CRYPT_BLOB_ARRAY setOf = { 0, NULL };
1285
1286 __TRY
1287 {
1288 DWORD i;
1289
1290 ret = TRUE;
1291 if (rdn->cRDNAttr)
1292 {
1293 setOf.cBlob = rdn->cRDNAttr;
1294 setOf.rgBlob = CryptMemAlloc(rdn->cRDNAttr *
1295 sizeof(CRYPT_DER_BLOB));
1296 if (!setOf.rgBlob)
1297 ret = FALSE;
1298 else
1299 memset(setOf.rgBlob, 0, setOf.cBlob * sizeof(CRYPT_DER_BLOB));
1300 }
1301 for (i = 0; ret && i < rdn->cRDNAttr; i++)
1302 {
1303 setOf.rgBlob[i].cbData = 0;
1304 ret = CRYPT_AsnEncodeRdnAttr(dwCertEncodingType, &rdn->rgRDNAttr[i],
1305 nameValueEncodeFunc, NULL, &setOf.rgBlob[i].cbData);
1306 if (ret)
1307 {
1308 setOf.rgBlob[i].pbData = CryptMemAlloc(setOf.rgBlob[i].cbData);
1309 if (!setOf.rgBlob[i].pbData)
1310 ret = FALSE;
1311 else
1312 ret = CRYPT_AsnEncodeRdnAttr(dwCertEncodingType,
1313 &rdn->rgRDNAttr[i], nameValueEncodeFunc,
1314 setOf.rgBlob[i].pbData, &setOf.rgBlob[i].cbData);
1315 }
1316 if (!ret)
1317 {
1318 /* Have to propagate index of failing character */
1319 *pcbEncoded = setOf.rgBlob[i].cbData;
1320 }
1321 }
1322 if (ret)
1323 ret = CRYPT_DEREncodeSet(X509_ASN_ENCODING, NULL, &setOf, 0, NULL,
1324 pbEncoded, pcbEncoded);
1325 for (i = 0; i < setOf.cBlob; i++)
1326 CryptMemFree(setOf.rgBlob[i].pbData);
1327 }
1328 __EXCEPT_PAGE_FAULT
1329 {
1330 SetLastError(STATUS_ACCESS_VIOLATION);
1331 ret = FALSE;
1332 }
1333 __ENDTRY
1334 CryptMemFree(setOf.rgBlob);
1335 return ret;
1336 }
1337
1338 static BOOL WINAPI CRYPT_AsnEncodeUnicodeNameValue(DWORD dwCertEncodingType,
1339 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1340 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
1341
1342 static BOOL WINAPI CRYPT_AsnEncodeOrCopyUnicodeNameValue(
1343 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
1344 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1345 DWORD *pcbEncoded)
1346 {
1347 const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
1348 BOOL ret;
1349
1350 if (value->dwValueType == CERT_RDN_ENCODED_BLOB)
1351 ret = CRYPT_CopyEncodedBlob(dwCertEncodingType, NULL, &value->Value,
1352 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1353 else
1354 ret = CRYPT_AsnEncodeUnicodeNameValue(dwCertEncodingType, NULL, value,
1355 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1356 return ret;
1357 }
1358
1359 static BOOL WINAPI CRYPT_AsnEncodeUnicodeName(DWORD dwCertEncodingType,
1360 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1361 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1362 {
1363 BOOL ret = TRUE;
1364
1365 __TRY
1366 {
1367 const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo;
1368 DWORD bytesNeeded = 0, lenBytes, size, i;
1369
1370 TRACE("encoding name with %d RDNs\n", info->cRDN);
1371 ret = TRUE;
1372 for (i = 0; ret && i < info->cRDN; i++)
1373 {
1374 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType, &info->rgRDN[i],
1375 CRYPT_AsnEncodeOrCopyUnicodeNameValue, NULL, &size);
1376 if (ret)
1377 bytesNeeded += size;
1378 else
1379 *pcbEncoded = size;
1380 }
1381 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1382 bytesNeeded += 1 + lenBytes;
1383 if (ret)
1384 {
1385 if (!pbEncoded)
1386 *pcbEncoded = bytesNeeded;
1387 else
1388 {
1389 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1390 pbEncoded, pcbEncoded, bytesNeeded)))
1391 {
1392 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1393 pbEncoded = *(BYTE **)pbEncoded;
1394 *pbEncoded++ = ASN_SEQUENCEOF;
1395 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
1396 &lenBytes);
1397 pbEncoded += lenBytes;
1398 for (i = 0; ret && i < info->cRDN; i++)
1399 {
1400 size = bytesNeeded;
1401 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType,
1402 &info->rgRDN[i], CRYPT_AsnEncodeOrCopyUnicodeNameValue,
1403 pbEncoded, &size);
1404 if (ret)
1405 {
1406 pbEncoded += size;
1407 bytesNeeded -= size;
1408 }
1409 else
1410 *pcbEncoded = size;
1411 }
1412 }
1413 }
1414 }
1415 }
1416 __EXCEPT_PAGE_FAULT
1417 {
1418 SetLastError(STATUS_ACCESS_VIOLATION);
1419 ret = FALSE;
1420 }
1421 __ENDTRY
1422 return ret;
1423 }
1424
1425 static BOOL WINAPI CRYPT_AsnEncodeCTLVersion(DWORD dwCertEncodingType,
1426 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1427 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1428 {
1429 const DWORD *ver = (const DWORD *)pvStructInfo;
1430 BOOL ret;
1431
1432 /* CTL_V1 is not encoded */
1433 if (*ver == CTL_V1)
1434 {
1435 *pcbEncoded = 0;
1436 ret = TRUE;
1437 }
1438 else
1439 ret = CRYPT_AsnEncodeInt(dwCertEncodingType, X509_INTEGER, ver,
1440 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1441 return ret;
1442 }
1443
1444 /* Like CRYPT_AsnEncodeAlgorithmId, but encodes parameters as an asn.1 NULL
1445 * if they are empty and the OID is not empty (otherwise omits them.)
1446 */
1447 static BOOL WINAPI CRYPT_AsnEncodeCTLSubjectAlgorithm(
1448 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
1449 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1450 DWORD *pcbEncoded)
1451 {
1452 const CRYPT_ALGORITHM_IDENTIFIER *algo =
1453 (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
1454 BOOL ret;
1455 struct AsnEncodeSequenceItem items[2] = {
1456 { algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
1457 };
1458 DWORD cItem = 1;
1459
1460 if (algo->pszObjId)
1461 {
1462 static const BYTE asn1Null[] = { ASN_NULL, 0 };
1463 static const CRYPT_DATA_BLOB nullBlob = { sizeof(asn1Null),
1464 (LPBYTE)asn1Null };
1465
1466 if (algo->Parameters.cbData)
1467 items[cItem].pvStructInfo = &algo->Parameters;
1468 else
1469 items[cItem].pvStructInfo = &nullBlob;
1470 items[cItem].encodeFunc = CRYPT_CopyEncodedBlob;
1471 cItem++;
1472 }
1473 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
1474 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1475 return ret;
1476 }
1477
1478 static BOOL CRYPT_AsnEncodeCTLEntry(const CTL_ENTRY *entry,
1479 BYTE *pbEncoded, DWORD *pcbEncoded)
1480 {
1481 struct AsnEncodeSequenceItem items[2] = {
1482 { &entry->SubjectIdentifier, CRYPT_AsnEncodeOctets, 0 },
1483 { &entry->cAttribute, CRYPT_AsnEncodePKCSAttributes, 0 },
1484 };
1485 BOOL ret;
1486
1487 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items,
1488 sizeof(items) / sizeof(items[0]), 0, NULL, pbEncoded, pcbEncoded);
1489 return ret;
1490 }
1491
1492 struct CTLEntries
1493 {
1494 DWORD cEntry;
1495 CTL_ENTRY *rgEntry;
1496 };
1497
1498 static BOOL WINAPI CRYPT_AsnEncodeCTLEntries(DWORD dwCertEncodingType,
1499 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1500 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1501 {
1502 BOOL ret;
1503 DWORD bytesNeeded, dataLen, lenBytes, i;
1504 const struct CTLEntries *entries = (const struct CTLEntries *)pvStructInfo;
1505
1506 ret = TRUE;
1507 for (i = 0, dataLen = 0; ret && i < entries->cEntry; i++)
1508 {
1509 DWORD size;
1510
1511 ret = CRYPT_AsnEncodeCTLEntry(&entries->rgEntry[i], NULL, &size);
1512 if (ret)
1513 dataLen += size;
1514 }
1515 if (ret)
1516 {
1517 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
1518 bytesNeeded = 1 + lenBytes + dataLen;
1519 if (!pbEncoded)
1520 *pcbEncoded = bytesNeeded;
1521 else
1522 {
1523 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1524 pbEncoded, pcbEncoded, bytesNeeded)))
1525 {
1526 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1527 pbEncoded = *(BYTE **)pbEncoded;
1528 *pbEncoded++ = ASN_SEQUENCEOF;
1529 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
1530 pbEncoded += lenBytes;
1531 for (i = 0; ret && i < entries->cEntry; i++)
1532 {
1533 DWORD size = dataLen;
1534
1535 ret = CRYPT_AsnEncodeCTLEntry(&entries->rgEntry[i],
1536 pbEncoded, &size);
1537 pbEncoded += size;
1538 dataLen -= size;
1539 }
1540 }
1541 }
1542 }
1543 return ret;
1544 }
1545
1546 static BOOL WINAPI CRYPT_AsnEncodeCTL(DWORD dwCertEncodingType,
1547 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1548 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1549 {
1550 BOOL ret = FALSE;
1551
1552 __TRY
1553 {
1554 const CTL_INFO *info = (const CTL_INFO *)pvStructInfo;
1555 struct AsnEncodeSequenceItem items[9] = {
1556 { &info->dwVersion, CRYPT_AsnEncodeCTLVersion, 0 },
1557 { &info->SubjectUsage, CRYPT_AsnEncodeEnhancedKeyUsage, 0 },
1558 };
1559 struct AsnConstructedItem constructed = { 0 };
1560 DWORD cItem = 2;
1561
1562 if (info->ListIdentifier.cbData)
1563 {
1564 items[cItem].pvStructInfo = &info->ListIdentifier;
1565 items[cItem].encodeFunc = CRYPT_AsnEncodeOctets;
1566 cItem++;
1567 }
1568 if (info->SequenceNumber.cbData)
1569 {
1570 items[cItem].pvStructInfo = &info->SequenceNumber;
1571 items[cItem].encodeFunc = CRYPT_AsnEncodeInteger;
1572 cItem++;
1573 }
1574 items[cItem].pvStructInfo = &info->ThisUpdate;
1575 items[cItem].encodeFunc = CRYPT_AsnEncodeChoiceOfTime;
1576 cItem++;
1577 if (info->NextUpdate.dwLowDateTime || info->NextUpdate.dwHighDateTime)
1578 {
1579 items[cItem].pvStructInfo = &info->NextUpdate;
1580 items[cItem].encodeFunc = CRYPT_AsnEncodeChoiceOfTime;
1581 cItem++;
1582 }
1583 items[cItem].pvStructInfo = &info->SubjectAlgorithm;
1584 items[cItem].encodeFunc = CRYPT_AsnEncodeCTLSubjectAlgorithm;
1585 cItem++;
1586 if (info->cCTLEntry)
1587 {
1588 items[cItem].pvStructInfo = &info->cCTLEntry;
1589 items[cItem].encodeFunc = CRYPT_AsnEncodeCTLEntries;
1590 cItem++;
1591 }
1592 if (info->cExtension)
1593 {
1594 constructed.tag = 0;
1595 constructed.pvStructInfo = &info->cExtension;
1596 constructed.encodeFunc = CRYPT_AsnEncodeExtensions;
1597 items[cItem].pvStructInfo = &constructed;
1598 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
1599 cItem++;
1600 }
1601 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
1602 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1603 }
1604 __EXCEPT_PAGE_FAULT
1605 {
1606 SetLastError(STATUS_ACCESS_VIOLATION);
1607 }
1608 __ENDTRY
1609 return ret;
1610 }
1611
1612 static BOOL CRYPT_AsnEncodeSMIMECapability(DWORD dwCertEncodingType,
1613 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1614 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1615 {
1616 BOOL ret = FALSE;
1617
1618 __TRY
1619 {
1620 const CRYPT_SMIME_CAPABILITY *capability =
1621 (const CRYPT_SMIME_CAPABILITY *)pvStructInfo;
1622
1623 if (!capability->pszObjId)
1624 SetLastError(E_INVALIDARG);
1625 else
1626 {
1627 struct AsnEncodeSequenceItem items[] = {
1628 { capability->pszObjId, CRYPT_AsnEncodeOid, 0 },
1629 { &capability->Parameters, CRYPT_CopyEncodedBlob, 0 },
1630 };
1631
1632 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
1633 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
1634 pcbEncoded);
1635 }
1636 }
1637 __EXCEPT_PAGE_FAULT
1638 {
1639 SetLastError(STATUS_ACCESS_VIOLATION);
1640 }
1641 __ENDTRY
1642 return ret;
1643 }
1644
1645 static BOOL WINAPI CRYPT_AsnEncodeSMIMECapabilities(DWORD dwCertEncodingType,
1646 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1647 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1648 {
1649 BOOL ret = FALSE;
1650
1651 __TRY
1652 {
1653 DWORD bytesNeeded, dataLen, lenBytes, i;
1654 const CRYPT_SMIME_CAPABILITIES *capabilities =
1655 (const CRYPT_SMIME_CAPABILITIES *)pvStructInfo;
1656
1657 ret = TRUE;
1658 for (i = 0, dataLen = 0; ret && i < capabilities->cCapability; i++)
1659 {
1660 DWORD size;
1661
1662 ret = CRYPT_AsnEncodeSMIMECapability(dwCertEncodingType, NULL,
1663 &capabilities->rgCapability[i], 0, NULL, NULL, &size);
1664 if (ret)
1665 dataLen += size;
1666 }
1667 if (ret)
1668 {
1669 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
1670 bytesNeeded = 1 + lenBytes + dataLen;
1671 if (!pbEncoded)
1672 *pcbEncoded = bytesNeeded;
1673 else
1674 {
1675 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1676 pbEncoded, pcbEncoded, bytesNeeded)))
1677 {
1678 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1679 pbEncoded = *(BYTE **)pbEncoded;
1680 *pbEncoded++ = ASN_SEQUENCEOF;
1681 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
1682 pbEncoded += lenBytes;
1683 for (i = 0; i < capabilities->cCapability; i++)
1684 {
1685 DWORD size = dataLen;
1686
1687 ret = CRYPT_AsnEncodeSMIMECapability(dwCertEncodingType,
1688 NULL, &capabilities->rgCapability[i], 0, NULL,
1689 pbEncoded, &size);
1690 pbEncoded += size;
1691 dataLen -= size;
1692 }
1693 }
1694 }
1695 }
1696 }
1697 __EXCEPT_PAGE_FAULT
1698 {
1699 SetLastError(STATUS_ACCESS_VIOLATION);
1700 }
1701 __ENDTRY
1702 return ret;
1703 }
1704
1705 static BOOL WINAPI CRYPT_AsnEncodeNoticeNumbers(DWORD dwCertEncodingType,
1706 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1707 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1708 {
1709 const CERT_POLICY_QUALIFIER_NOTICE_REFERENCE *noticeRef = pvStructInfo;
1710 DWORD bytesNeeded, dataLen, lenBytes, i;
1711 BOOL ret = TRUE;
1712
1713 for (i = 0, dataLen = 0; ret && i < noticeRef->cNoticeNumbers; i++)
1714 {
1715 DWORD size;
1716
1717 ret = CRYPT_AsnEncodeInt(dwCertEncodingType, X509_INTEGER,
1718 &noticeRef->rgNoticeNumbers[i], 0, NULL, NULL, &size);
1719 if (ret)
1720 dataLen += size;
1721 }
1722 if (ret)
1723 {
1724 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
1725 bytesNeeded = 1 + lenBytes + dataLen;
1726 if (!pbEncoded)
1727 *pcbEncoded = bytesNeeded;
1728 else
1729 {
1730 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
1731 pcbEncoded, bytesNeeded)))
1732 {
1733 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1734 pbEncoded = *(BYTE **)pbEncoded;
1735 *pbEncoded++ = ASN_SEQUENCE;
1736 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
1737 pbEncoded += lenBytes;
1738 for (i = 0; i < noticeRef->cNoticeNumbers; i++)
1739 {
1740 DWORD size = dataLen;
1741
1742 ret = CRYPT_AsnEncodeInt(dwCertEncodingType, X509_INTEGER,
1743 &noticeRef->rgNoticeNumbers[i], 0, NULL, pbEncoded, &size);
1744 pbEncoded += size;
1745 dataLen -= size;
1746 }
1747 }
1748 }
1749 }
1750 return ret;
1751 }
1752
1753 static BOOL WINAPI CRYPT_AsnEncodeNoticeReference(DWORD dwCertEncodingType,
1754 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1755 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1756 {
1757 const CERT_POLICY_QUALIFIER_NOTICE_REFERENCE *noticeRef = pvStructInfo;
1758 BOOL ret;
1759 CERT_NAME_VALUE orgValue = { CERT_RDN_IA5_STRING,
1760 { 0, (LPBYTE)noticeRef->pszOrganization } };
1761 struct AsnEncodeSequenceItem items[] = {
1762 { &orgValue, CRYPT_AsnEncodeNameValue, 0 },
1763 { noticeRef, CRYPT_AsnEncodeNoticeNumbers, 0 },
1764 };
1765
1766 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
1767 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
1768 pcbEncoded);
1769 return ret;
1770 }
1771
1772 static BOOL WINAPI CRYPT_AsnEncodePolicyQualifierUserNotice(
1773 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
1774 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1775 DWORD *pcbEncoded)
1776 {
1777 BOOL ret = FALSE;
1778
1779 __TRY
1780 {
1781 const CERT_POLICY_QUALIFIER_USER_NOTICE *notice = pvStructInfo;
1782 struct AsnEncodeSequenceItem items[2];
1783 CERT_NAME_VALUE displayTextValue;
1784 DWORD cItem = 0;
1785
1786 ret = TRUE;
1787 if (notice->pNoticeReference)
1788 {
1789 items[cItem].encodeFunc = CRYPT_AsnEncodeNoticeReference;
1790 items[cItem].pvStructInfo = notice->pNoticeReference;
1791 cItem++;
1792 }
1793 if (notice->pszDisplayText)
1794 {
1795 displayTextValue.dwValueType = CERT_RDN_BMP_STRING;
1796 displayTextValue.Value.cbData = 0;
1797 displayTextValue.Value.pbData = (LPBYTE)notice->pszDisplayText;
1798 items[cItem].encodeFunc = CRYPT_AsnEncodeNameValue;
1799 items[cItem].pvStructInfo = &displayTextValue;
1800 cItem++;
1801 }
1802 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
1803 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1804 }
1805 __EXCEPT_PAGE_FAULT
1806 {
1807 SetLastError(STATUS_ACCESS_VIOLATION);
1808 }
1809 __ENDTRY
1810 return ret;
1811 }
1812
1813 static BOOL WINAPI CRYPT_AsnEncodePKCSAttribute(DWORD dwCertEncodingType,
1814 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1815 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1816 {
1817 BOOL ret = FALSE;
1818
1819 __TRY
1820 {
1821 const CRYPT_ATTRIBUTE *attr = (const CRYPT_ATTRIBUTE *)pvStructInfo;
1822
1823 if (!attr->pszObjId)
1824 SetLastError(E_INVALIDARG);
1825 else
1826 {
1827 struct AsnEncodeSequenceItem items[2] = {
1828 { attr->pszObjId, CRYPT_AsnEncodeOid, 0 },
1829 { &attr->cValue, CRYPT_DEREncodeSet, 0 },
1830 };
1831
1832 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
1833 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
1834 pcbEncoded);
1835 }
1836 }
1837 __EXCEPT_PAGE_FAULT
1838 {
1839 SetLastError(STATUS_ACCESS_VIOLATION);
1840 }
1841 __ENDTRY
1842 return ret;
1843 }
1844
1845 static BOOL WINAPI CRYPT_AsnEncodePKCSAttributes(DWORD dwCertEncodingType,
1846 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1847 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1848 {
1849 BOOL ret = FALSE;
1850
1851 __TRY
1852 {
1853 const CRYPT_ATTRIBUTES *attributes =
1854 (const CRYPT_ATTRIBUTES *)pvStructInfo;
1855 struct DERSetDescriptor desc = { attributes->cAttr, attributes->rgAttr,
1856 sizeof(CRYPT_ATTRIBUTE), 0, CRYPT_AsnEncodePKCSAttribute };
1857
1858 ret = CRYPT_DEREncodeItemsAsSet(X509_ASN_ENCODING, lpszStructType,
1859 &desc, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1860 }
1861 __EXCEPT_PAGE_FAULT
1862 {
1863 SetLastError(STATUS_ACCESS_VIOLATION);
1864 }
1865 __ENDTRY
1866 return ret;
1867 }
1868
1869 /* Like CRYPT_AsnEncodePKCSContentInfo, but allows the OID to be NULL */
1870 static BOOL WINAPI CRYPT_AsnEncodePKCSContentInfoInternal(
1871 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
1872 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1873 DWORD *pcbEncoded)
1874 {
1875 const CRYPT_CONTENT_INFO *info = (const CRYPT_CONTENT_INFO *)pvStructInfo;
1876 struct AsnEncodeSequenceItem items[2] = {
1877 { info->pszObjId, CRYPT_AsnEncodeOid, 0 },
1878 { NULL, NULL, 0 },
1879 };
1880 struct AsnConstructedItem constructed = { 0 };
1881 DWORD cItem = 1;
1882
1883 if (info->Content.cbData)
1884 {
1885 constructed.tag = 0;
1886 constructed.pvStructInfo = &info->Content;
1887 constructed.encodeFunc = CRYPT_CopyEncodedBlob;
1888 items[cItem].pvStructInfo = &constructed;
1889 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
1890 cItem++;
1891 }
1892 return CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
1893 cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1894 }
1895
1896 BOOL CRYPT_AsnEncodePKCSDigestedData(CRYPT_DIGESTED_DATA *digestedData,
1897 void *pvData, DWORD *pcbData)
1898 {
1899 struct AsnEncodeSequenceItem items[] = {
1900 { &digestedData->version, CRYPT_AsnEncodeInt, 0 },
1901 { &digestedData->DigestAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams,
1902 0 },
1903 { &digestedData->ContentInfo, CRYPT_AsnEncodePKCSContentInfoInternal, 0 },
1904 { &digestedData->hash, CRYPT_AsnEncodeOctets, 0 },
1905 };
1906
1907 return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items,
1908 sizeof(items) / sizeof(items[0]), 0, NULL, pvData, pcbData);
1909 }
1910
1911 static BOOL WINAPI CRYPT_AsnEncodePKCSContentInfo(DWORD dwCertEncodingType,
1912 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1913 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1914 {
1915 BOOL ret = FALSE;
1916
1917 __TRY
1918 {
1919 const CRYPT_CONTENT_INFO *info =
1920 (const CRYPT_CONTENT_INFO *)pvStructInfo;
1921
1922 if (!info->pszObjId)
1923 SetLastError(E_INVALIDARG);
1924 else
1925 ret = CRYPT_AsnEncodePKCSContentInfoInternal(dwCertEncodingType,
1926 lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded,
1927 pcbEncoded);
1928 }
1929 __EXCEPT_PAGE_FAULT
1930 {
1931 SetLastError(STATUS_ACCESS_VIOLATION);
1932 }
1933 __ENDTRY
1934 return ret;
1935 }
1936
1937 static BOOL CRYPT_AsnEncodeUnicodeStringCoerce(const CERT_NAME_VALUE *value,
1938 BYTE tag, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1939 DWORD *pcbEncoded)
1940 {
1941 BOOL ret = TRUE;
1942 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1943 DWORD bytesNeeded, lenBytes, encodedLen;
1944
1945 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1946 strlenW(str);
1947 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
1948 bytesNeeded = 1 + lenBytes + encodedLen;
1949 if (!pbEncoded)
1950 *pcbEncoded = bytesNeeded;
1951 else
1952 {
1953 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1954 pbEncoded, pcbEncoded, bytesNeeded)))
1955 {
1956 DWORD i;
1957
1958 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1959 pbEncoded = *(BYTE **)pbEncoded;
1960 *pbEncoded++ = tag;
1961 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
1962 pbEncoded += lenBytes;
1963 for (i = 0; i < encodedLen; i++)
1964 *pbEncoded++ = (BYTE)str[i];
1965 }
1966 }
1967 return ret;
1968 }
1969
1970 static void CRYPT_FreeSpace(PCRYPT_ENCODE_PARA pEncodePara, LPVOID pv)
1971 {
1972 if (pEncodePara && pEncodePara->pfnFree)
1973 pEncodePara->pfnFree(pv);
1974 else
1975 LocalFree(pv);
1976 }
1977
1978 static BOOL CRYPT_AsnEncodeNumericString(const CERT_NAME_VALUE *value,
1979 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1980 DWORD *pcbEncoded)
1981 {
1982 BOOL ret = TRUE;
1983 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1984 DWORD bytesNeeded, lenBytes, encodedLen;
1985
1986 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1987 strlenW(str);
1988 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
1989 bytesNeeded = 1 + lenBytes + encodedLen;
1990 if (!pbEncoded)
1991 *pcbEncoded = bytesNeeded;
1992 else
1993 {
1994 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1995 pbEncoded, pcbEncoded, bytesNeeded)))
1996 {
1997 DWORD i;
1998 BYTE *ptr;
1999
2000 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2001 ptr = *(BYTE **)pbEncoded;
2002 else
2003 ptr = pbEncoded;
2004 *ptr++ = ASN_NUMERICSTRING;
2005 CRYPT_EncodeLen(encodedLen, ptr, &lenBytes);
2006 ptr += lenBytes;
2007 for (i = 0; ret && i < encodedLen; i++)
2008 {
2009 if (isdigitW(str[i]))
2010 *ptr++ = (BYTE)str[i];
2011 else
2012 {
2013 *pcbEncoded = i;
2014 SetLastError(CRYPT_E_INVALID_NUMERIC_STRING);
2015 ret = FALSE;
2016 }
2017 }
2018 if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG))
2019 CRYPT_FreeSpace(pEncodePara, *(BYTE **)pbEncoded);
2020 }
2021 }
2022 return ret;
2023 }
2024
2025 static inline int isprintableW(WCHAR wc)
2026 {
2027 return isalnumW(wc) || isspaceW(wc) || wc == '\'' || wc == '(' ||
2028 wc == ')' || wc == '+' || wc == ',' || wc == '-' || wc == '.' ||
2029 wc == '/' || wc == ':' || wc == '=' || wc == '?';
2030 }
2031
2032 static BOOL CRYPT_AsnEncodePrintableString(const CERT_NAME_VALUE *value,
2033 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
2034 DWORD *pcbEncoded)
2035 {
2036 BOOL ret = TRUE;
2037 LPCWSTR str = (LPCWSTR)value->Value.pbData;
2038 DWORD bytesNeeded, lenBytes, encodedLen;
2039
2040 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
2041 strlenW(str);
2042 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
2043 bytesNeeded = 1 + lenBytes + encodedLen;
2044 if (!pbEncoded)
2045 *pcbEncoded = bytesNeeded;
2046 else
2047 {
2048 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2049 pbEncoded, pcbEncoded, bytesNeeded)))
2050 {
2051 DWORD i;
2052 BYTE *ptr;
2053
2054 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2055 ptr = *(BYTE **)pbEncoded;
2056 else
2057 ptr = pbEncoded;
2058 *ptr++ = ASN_PRINTABLESTRING;
2059 CRYPT_EncodeLen(encodedLen, ptr, &lenBytes);
2060 ptr += lenBytes;
2061 for (i = 0; ret && i < encodedLen; i++)
2062 {
2063 if (isprintableW(str[i]))
2064 *ptr++ = (BYTE)str[i];
2065 else
2066 {
2067 *pcbEncoded = i;
2068 SetLastError(CRYPT_E_INVALID_PRINTABLE_STRING);
2069 ret = FALSE;
2070 }
2071 }
2072 if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG))
2073 CRYPT_FreeSpace(pEncodePara, *(BYTE **)pbEncoded);
2074 }
2075 }
2076 return ret;
2077 }
2078
2079 static BOOL CRYPT_AsnEncodeIA5String(const CERT_NAME_VALUE *value,
2080 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
2081 DWORD *pcbEncoded)
2082 {
2083 BOOL ret = TRUE;
2084 LPCWSTR str = (LPCWSTR)value->Value.pbData;
2085 DWORD bytesNeeded, lenBytes, encodedLen;
2086
2087 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
2088 strlenW(str);
2089 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
2090 bytesNeeded = 1 + lenBytes + encodedLen;
2091 if (!pbEncoded)
2092 *pcbEncoded = bytesNeeded;
2093 else
2094 {
2095 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2096 pbEncoded, pcbEncoded, bytesNeeded)))
2097 {
2098 DWORD i;
2099 BYTE *ptr;
2100
2101 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2102 ptr = *(BYTE **)pbEncoded;
2103 else
2104 ptr = pbEncoded;
2105 *ptr++ = ASN_IA5STRING;
2106 CRYPT_EncodeLen(encodedLen, ptr, &lenBytes);
2107 ptr += lenBytes;
2108 for (i = 0; ret && i < encodedLen; i++)
2109 {
2110 if (str[i] <= 0x7f)
2111 *ptr++ = (BYTE)str[i];
2112 else
2113 {
2114 *pcbEncoded = i;
2115 SetLastError(CRYPT_E_INVALID_IA5_STRING);
2116 ret = FALSE;
2117 }
2118 }
2119 if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG))
2120 CRYPT_FreeSpace(pEncodePara, *(BYTE **)pbEncoded);
2121 }
2122 }
2123 return ret;
2124 }
2125
2126 static BOOL CRYPT_AsnEncodeUniversalString(const CERT_NAME_VALUE *value,
2127 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
2128 DWORD *pcbEncoded)
2129 {
2130 BOOL ret = TRUE;
2131 LPCWSTR str = (LPCWSTR)value->Value.pbData;
2132 DWORD bytesNeeded, lenBytes, strLen;
2133
2134 /* FIXME: doesn't handle composite characters */
2135 strLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
2136 strlenW(str);
2137 CRYPT_EncodeLen(strLen * 4, NULL, &lenBytes);
2138 bytesNeeded = 1 + lenBytes + strLen * 4;
2139 if (!pbEncoded)
2140 *pcbEncoded = bytesNeeded;
2141 else
2142 {
2143 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2144 pbEncoded, pcbEncoded, bytesNeeded)))
2145 {
2146 DWORD i;
2147
2148 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2149 pbEncoded = *(BYTE **)pbEncoded;
2150 *pbEncoded++ = ASN_UNIVERSALSTRING;
2151 CRYPT_EncodeLen(strLen * 4, pbEncoded, &lenBytes);
2152 pbEncoded += lenBytes;
2153 for (i = 0; i < strLen; i++)
2154 {
2155 *pbEncoded++ = 0;
2156 *pbEncoded++ = 0;
2157 *pbEncoded++ = (BYTE)((str[i] & 0xff00) >> 8);
2158 *pbEncoded++ = (BYTE)(str[i] & 0x00ff);
2159 }
2160 }
2161 }
2162 return ret;
2163 }
2164
2165 static BOOL WINAPI CRYPT_AsnEncodeUnicodeNameValue(DWORD dwCertEncodingType,
2166 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2167 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2168 {
2169 BOOL ret = FALSE;
2170
2171 __TRY
2172 {
2173 const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
2174
2175 switch (value->dwValueType)
2176 {
2177 case CERT_RDN_ANY_TYPE:
2178 case CERT_RDN_ENCODED_BLOB:
2179 case CERT_RDN_OCTET_STRING:
2180 SetLastError(CRYPT_E_NOT_CHAR_STRING);
2181 break;
2182 case CERT_RDN_NUMERIC_STRING:
2183 ret = CRYPT_AsnEncodeNumericString(value, dwFlags, pEncodePara,
2184 pbEncoded, pcbEncoded);
2185 break;
2186 case CERT_RDN_PRINTABLE_STRING:
2187 ret = CRYPT_AsnEncodePrintableString(value, dwFlags, pEncodePara,
2188 pbEncoded, pcbEncoded);
2189 break;
2190 case CERT_RDN_TELETEX_STRING:
2191 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_T61STRING,
2192 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2193 break;
2194 case CERT_RDN_VIDEOTEX_STRING:
2195 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value,
2196 ASN_VIDEOTEXSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2197 break;
2198 case CERT_RDN_IA5_STRING:
2199 ret = CRYPT_AsnEncodeIA5String(value, dwFlags, pEncodePara,
2200 pbEncoded, pcbEncoded);
2201 break;
2202 case CERT_RDN_GRAPHIC_STRING:
2203 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_GRAPHICSTRING,
2204 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2205 break;
2206 case CERT_RDN_VISIBLE_STRING:
2207 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_VISIBLESTRING,
2208 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2209 break;
2210 case CERT_RDN_GENERAL_STRING:
2211 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_GENERALSTRING,
2212 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2213 break;
2214 case CERT_RDN_UNIVERSAL_STRING:
2215 ret = CRYPT_AsnEncodeUniversalString(value, dwFlags, pEncodePara,
2216 pbEncoded, pcbEncoded);
2217 break;
2218 case CERT_RDN_BMP_STRING:
2219 ret = CRYPT_AsnEncodeBMPString(value, dwFlags, pEncodePara,
2220 pbEncoded, pcbEncoded);
2221 break;
2222 case CERT_RDN_UTF8_STRING:
2223 ret = CRYPT_AsnEncodeUTF8String(value, dwFlags, pEncodePara,
2224 pbEncoded, pcbEncoded);
2225 break;
2226 default:
2227 SetLastError(CRYPT_E_ASN1_CHOICE);
2228 }
2229 }
2230 __EXCEPT_PAGE_FAULT
2231 {
2232 SetLastError(STATUS_ACCESS_VIOLATION);
2233 }
2234 __ENDTRY
2235 return ret;
2236 }
2237
2238 static BOOL WINAPI CRYPT_AsnEncodeName(DWORD dwCertEncodingType,
2239 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2240 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2241 {
2242 BOOL ret;
2243
2244 __TRY
2245 {
2246 const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo;
2247 DWORD bytesNeeded = 0, lenBytes, size, i;
2248
2249 TRACE("encoding name with %d RDNs\n", info->cRDN);
2250 ret = TRUE;
2251 for (i = 0; ret && i < info->cRDN; i++)
2252 {
2253 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType, &info->rgRDN[i],
2254 CRYPT_AsnEncodeNameValue, NULL, &size);
2255 if (ret)
2256 bytesNeeded += size;
2257 }
2258 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
2259 bytesNeeded += 1 + lenBytes;
2260 if (ret)
2261 {
2262 if (!pbEncoded)
2263 *pcbEncoded = bytesNeeded;
2264 else
2265 {
2266 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2267 pbEncoded, pcbEncoded, bytesNeeded)))
2268 {
2269 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2270 pbEncoded = *(BYTE **)pbEncoded;
2271 *pbEncoded++ = ASN_SEQUENCEOF;
2272 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
2273 &lenBytes);
2274 pbEncoded += lenBytes;
2275 for (i = 0; ret && i < info->cRDN; i++)
2276 {
2277 size = bytesNeeded;
2278 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType,
2279 &info->rgRDN[i], CRYPT_AsnEncodeNameValue, pbEncoded,
2280 &size);
2281 if (ret)
2282 {
2283 pbEncoded += size;
2284 bytesNeeded -= size;
2285 }
2286 }
2287 }
2288 }
2289 }
2290 }
2291 __EXCEPT_PAGE_FAULT
2292 {
2293 SetLastError(STATUS_ACCESS_VIOLATION);
2294 ret = FALSE;
2295 }
2296 __ENDTRY
2297 return ret;
2298 }
2299
2300 static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
2301 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2302 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2303 {
2304 BOOL val = *(const BOOL *)pvStructInfo, ret;
2305
2306 TRACE("%d\n", val);
2307
2308 if (!pbEncoded)
2309 {
2310 *pcbEncoded = 3;
2311 ret = TRUE;
2312 }
2313 else if (*pcbEncoded < 3)
2314 {
2315 *pcbEncoded = 3;
2316 SetLastError(ERROR_MORE_DATA);
2317 ret = FALSE;
2318 }
2319 else
2320 {
2321 *pcbEncoded = 3;
2322 *pbEncoded++ = ASN_BOOL;
2323 *pbEncoded++ = 1;
2324 *pbEncoded++ = val ? 0xff : 0;
2325 ret = TRUE;
2326 }
2327 TRACE("returning %d (%08x)\n", ret, GetLastError());
2328 return ret;
2329 }
2330
2331 static BOOL WINAPI CRYPT_AsnEncodeAltNameEntry(DWORD dwCertEncodingType,
2332 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2333 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2334 {
2335 const CERT_ALT_NAME_ENTRY *entry =
2336 (const CERT_ALT_NAME_ENTRY *)pvStructInfo;
2337 BOOL ret;
2338 DWORD dataLen;
2339 BYTE tag;
2340
2341 ret = TRUE;
2342 switch (entry->dwAltNameChoice)
2343 {
2344 case CERT_ALT_NAME_RFC822_NAME:
2345 case CERT_ALT_NAME_DNS_NAME:
2346 case CERT_ALT_NAME_URL:
2347 tag = ASN_CONTEXT | (entry->dwAltNameChoice - 1);
2348 if (entry->u.pwszURL)
2349 {
2350 DWORD i;
2351
2352 /* Not + 1: don't encode the NULL-terminator */
2353 dataLen = lstrlenW(entry->u.pwszURL);
2354 for (i = 0; ret && i < dataLen; i++)
2355 {
2356 if (entry->u.pwszURL[i] > 0x7f)
2357 {
2358 SetLastError(CRYPT_E_INVALID_IA5_STRING);
2359 ret = FALSE;
2360 *pcbEncoded = i;
2361 }
2362 }
2363 }
2364 else
2365 dataLen = 0;
2366 break;
2367 case CERT_ALT_NAME_DIRECTORY_NAME:
2368 tag = ASN_CONTEXT | ASN_CONSTRUCTOR | (entry->dwAltNameChoice - 1);
2369 dataLen = entry->u.DirectoryName.cbData;
2370 break;
2371 case CERT_ALT_NAME_IP_ADDRESS:
2372 tag = ASN_CONTEXT | (entry->dwAltNameChoice - 1);
2373 dataLen = entry->u.IPAddress.cbData;
2374 break;
2375 case CERT_ALT_NAME_REGISTERED_ID:
2376 {
2377 struct AsnEncodeTagSwappedItem swapped =
2378 { ASN_CONTEXT | (entry->dwAltNameChoice - 1), entry->u.pszRegisteredID,
2379 CRYPT_AsnEncodeOid };
2380
2381 return CRYPT_AsnEncodeSwapTag(0, NULL, &swapped, 0, NULL, pbEncoded,
2382 pcbEncoded);
2383 }
2384 case CERT_ALT_NAME_OTHER_NAME:
2385 FIXME("name type %d unimplemented\n", entry->dwAltNameChoice);
2386 return FALSE;
2387 default:
2388 SetLastError(E_INVALIDARG);
2389 return FALSE;
2390 }
2391 if (ret)
2392 {
2393 DWORD bytesNeeded, lenBytes;
2394
2395 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
2396 bytesNeeded = 1 + dataLen + lenBytes;
2397 if (!pbEncoded)
2398 *pcbEncoded = bytesNeeded;
2399 else if (*pcbEncoded < bytesNeeded)
2400 {
2401 SetLastError(ERROR_MORE_DATA);
2402 *pcbEncoded = bytesNeeded;
2403 ret = FALSE;
2404 }
2405 else
2406 {
2407 *pbEncoded++ = tag;
2408 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
2409 pbEncoded += lenBytes;
2410 switch (entry->dwAltNameChoice)
2411 {
2412 case CERT_ALT_NAME_RFC822_NAME:
2413 case CERT_ALT_NAME_DNS_NAME:
2414 case CERT_ALT_NAME_URL:
2415 {
2416 DWORD i;
2417
2418 for (i = 0; i < dataLen; i++)
2419 *pbEncoded++ = (BYTE)entry->u.pwszURL[i];
2420 break;
2421 }
2422 case CERT_ALT_NAME_DIRECTORY_NAME:
2423 memcpy(pbEncoded, entry->u.DirectoryName.pbData, dataLen);
2424 break;
2425 case CERT_ALT_NAME_IP_ADDRESS:
2426 memcpy(pbEncoded, entry->u.IPAddress.pbData, dataLen);
2427 break;
2428 }
2429 if (ret)
2430 *pcbEncoded = bytesNeeded;
2431 }
2432 }
2433 TRACE("returning %d (%08x)\n", ret, GetLastError());
2434 return ret;
2435 }
2436
2437 static BOOL WINAPI CRYPT_AsnEncodeIntegerSwapBytes(DWORD dwCertEncodingType,
2438 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2439 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2440 {
2441 BOOL ret;
2442
2443 __TRY
2444 {
2445 const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo;
2446 CRYPT_DATA_BLOB newBlob = { blob->cbData, NULL };
2447
2448 ret = TRUE;
2449 if (newBlob.cbData)
2450 {
2451 newBlob.pbData = CryptMemAlloc(newBlob.cbData);
2452 if (newBlob.pbData)
2453 {
2454 DWORD i;
2455
2456 for (i = 0; i < newBlob.cbData; i++)
2457 newBlob.pbData[newBlob.cbData - i - 1] = blob->pbData[i];
2458 }
2459 else
2460 ret = FALSE;
2461 }
2462 if (ret)
2463 ret = CRYPT_AsnEncodeInteger(dwCertEncodingType, lpszStructType,
2464 &newBlob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2465 CryptMemFree(newBlob.pbData);
2466 }
2467 __EXCEPT_PAGE_FAULT
2468 {
2469 SetLastError(STATUS_ACCESS_VIOLATION);
2470 ret = FALSE;
2471 }
2472 __ENDTRY
2473 return ret;
2474 }
2475
2476 static BOOL WINAPI CRYPT_AsnEncodeAuthorityKeyId(DWORD dwCertEncodingType,
2477 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2478 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2479 {
2480 BOOL ret;
2481
2482 __TRY
2483 {
2484 const CERT_AUTHORITY_KEY_ID_INFO *info =
2485 (const CERT_AUTHORITY_KEY_ID_INFO *)pvStructInfo;
2486 struct AsnEncodeSequenceItem items[3] = { { 0 } };
2487 struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
2488 struct AsnConstructedItem constructed = { 0 };
2489 DWORD cItem = 0, cSwapped = 0;
2490
2491 if (info->KeyId.cbData)
2492 {
2493 swapped[cSwapped].tag = ASN_CONTEXT | 0;
2494 swapped[cSwapped].pvStructInfo = &info->KeyId;
2495 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeIntegerSwapBytes;
2496 items[cItem].pvStructInfo = &swapped[cSwapped];
2497 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2498 cSwapped++;
2499 cItem++;
2500 }
2501 if (info->CertIssuer.cbData)
2502 {
2503 constructed.tag = 1;
2504 constructed.pvStructInfo = &info->CertIssuer;
2505 constructed.encodeFunc = CRYPT_CopyEncodedBlob;
2506 items[cItem].pvStructInfo = &constructed;
2507 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
2508 cItem++;
2509 }
2510 if (info->CertSerialNumber.cbData)
2511 {
2512 swapped[cSwapped].tag = ASN_CONTEXT | 2;
2513 swapped[cSwapped].pvStructInfo = &info->CertSerialNumber;
2514 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInteger;
2515 items[cItem].pvStructInfo = &swapped[cSwapped];
2516 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2517 cSwapped++;
2518 cItem++;
2519 }
2520 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, dwFlags,
2521 pEncodePara, pbEncoded, pcbEncoded);
2522 }
2523 __EXCEPT_PAGE_FAULT
2524 {
2525 SetLastError(STATUS_ACCESS_VIOLATION);
2526 ret = FALSE;
2527 }
2528 __ENDTRY
2529 return ret;
2530 }
2531
2532 static BOOL WINAPI CRYPT_AsnEncodeAltName(DWORD dwCertEncodingType,
2533 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2534 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2535 {
2536 BOOL ret;
2537
2538 __TRY
2539 {
2540 const CERT_ALT_NAME_INFO *info =
2541 (const CERT_ALT_NAME_INFO *)pvStructInfo;
2542 DWORD bytesNeeded, dataLen, lenBytes, i;
2543
2544 ret = TRUE;
2545 /* FIXME: should check that cAltEntry is not bigger than 0xff, since we
2546 * can't encode an erroneous entry index if it's bigger than this.
2547 */
2548 for (i = 0, dataLen = 0; ret && i < info->cAltEntry; i++)
2549 {
2550 DWORD len;
2551
2552 ret = CRYPT_AsnEncodeAltNameEntry(dwCertEncodingType, NULL,
2553 &info->rgAltEntry[i], 0, NULL, NULL, &len);
2554 if (ret)
2555 dataLen += len;
2556 else if (GetLastError() == CRYPT_E_INVALID_IA5_STRING)
2557 {
2558 /* CRYPT_AsnEncodeAltNameEntry encoded the index of
2559 * the bad character, now set the index of the bad
2560 * entry
2561 */
2562 *pcbEncoded = (BYTE)i <<
2563 CERT_ALT_NAME_ENTRY_ERR_INDEX_SHIFT | len;
2564 }
2565 }
2566 if (ret)
2567 {
2568 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
2569 bytesNeeded = 1 + lenBytes + dataLen;
2570 if (!pbEncoded)
2571 {
2572 *pcbEncoded = bytesNeeded;
2573 ret = TRUE;
2574 }
2575 else
2576 {
2577 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2578 pbEncoded, pcbEncoded, bytesNeeded)))
2579 {
2580 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2581 pbEncoded = *(BYTE **)pbEncoded;
2582 *pbEncoded++ = ASN_SEQUENCEOF;
2583 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
2584 pbEncoded += lenBytes;
2585 for (i = 0; ret && i < info->cAltEntry; i++)
2586 {
2587 DWORD len = dataLen;
2588
2589 ret = CRYPT_AsnEncodeAltNameEntry(dwCertEncodingType,
2590 NULL, &info->rgAltEntry[i], 0, NULL, pbEncoded, &len);
2591 if (ret)
2592 {
2593 pbEncoded += len;
2594 dataLen -= len;
2595 }
2596 }
2597 }
2598 }
2599 }
2600 }
2601 __EXCEPT_PAGE_FAULT
2602 {
2603 SetLastError(STATUS_ACCESS_VIOLATION);
2604 ret = FALSE;
2605 }
2606 __ENDTRY
2607 return ret;
2608 }
2609
2610 static BOOL WINAPI CRYPT_AsnEncodeAuthorityKeyId2(DWORD dwCertEncodingType,
2611 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2612 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2613 {
2614 BOOL ret;
2615
2616 __TRY
2617 {
2618 const CERT_AUTHORITY_KEY_ID2_INFO *info =
2619 (const CERT_AUTHORITY_KEY_ID2_INFO *)pvStructInfo;
2620 struct AsnEncodeSequenceItem items[3] = { { 0 } };
2621 struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
2622 DWORD cItem = 0, cSwapped = 0;
2623
2624 if (info->KeyId.cbData)
2625 {
2626 swapped[cSwapped].tag = ASN_CONTEXT | 0;
2627 swapped[cSwapped].pvStructInfo = &info->KeyId;
2628 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeIntegerSwapBytes;
2629 items[cItem].pvStructInfo = &swapped[cSwapped];
2630 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2631 cSwapped++;
2632 cItem++;
2633 }
2634 if (info->AuthorityCertIssuer.cAltEntry)
2635 {
2636 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1;
2637 swapped[cSwapped].pvStructInfo = &info->AuthorityCertIssuer;
2638 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
2639 items[cItem].pvStructInfo = &swapped[cSwapped];
2640 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2641 cSwapped++;
2642 cItem++;
2643 }
2644 if (info->AuthorityCertSerialNumber.cbData)
2645 {
2646 swapped[cSwapped].tag = ASN_CONTEXT | 2;
2647 swapped[cSwapped].pvStructInfo = &info->AuthorityCertSerialNumber;
2648 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInteger;
2649 items[cItem].pvStructInfo = &swapped[cSwapped];
2650 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2651 cSwapped++;
2652 cItem++;
2653 }
2654 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, dwFlags,
2655 pEncodePara, pbEncoded, pcbEncoded);
2656 }
2657 __EXCEPT_PAGE_FAULT
2658 {
2659 SetLastError(STATUS_ACCESS_VIOLATION);
2660 ret = FALSE;
2661 }
2662 __ENDTRY
2663 return ret;
2664 }
2665
2666 static BOOL CRYPT_AsnEncodeAccessDescription(
2667 const CERT_ACCESS_DESCRIPTION *descr, BYTE *pbEncoded, DWORD *pcbEncoded)
2668 {
2669 struct AsnEncodeSequenceItem items[] = {
2670 { descr->pszAccessMethod, CRYPT_AsnEncodeOid, 0 },
2671 { &descr->AccessLocation, CRYPT_AsnEncodeAltNameEntry, 0 },
2672 };
2673
2674 if (!descr->pszAccessMethod)
2675 {
2676 SetLastError(E_INVALIDARG);
2677 return FALSE;
2678 }
2679 return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items,
2680 sizeof(items) / sizeof(items[0]), 0, NULL, pbEncoded, pcbEncoded);
2681 }
2682
2683 static BOOL WINAPI CRYPT_AsnEncodeAuthorityInfoAccess(DWORD dwCertEncodingType,
2684 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2685 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2686 {
2687 BOOL ret;
2688
2689 __TRY
2690 {
2691 DWORD bytesNeeded, dataLen, lenBytes, i;
2692 const CERT_AUTHORITY_INFO_ACCESS *info =
2693 (const CERT_AUTHORITY_INFO_ACCESS *)pvStructInfo;
2694
2695 ret = TRUE;
2696 for (i = 0, dataLen = 0; ret && i < info->cAccDescr; i++)
2697 {
2698 DWORD size;
2699
2700 ret = CRYPT_AsnEncodeAccessDescription(&info->rgAccDescr[i], NULL,
2701 &size);
2702 if (ret)
2703 dataLen += size;
2704 }
2705 if (ret)
2706 {
2707 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
2708 bytesNeeded = 1 + lenBytes + dataLen;
2709 if (!pbEncoded)
2710 *pcbEncoded = bytesNeeded;
2711 else
2712 {
2713 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2714 pbEncoded, pcbEncoded, bytesNeeded)))
2715 {
2716 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2717 pbEncoded = *(BYTE **)pbEncoded;
2718 *pbEncoded++ = ASN_SEQUENCEOF;
2719 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
2720 pbEncoded += lenBytes;
2721 for (i = 0; i < info->cAccDescr; i++)
2722 {
2723 DWORD size = dataLen;
2724
2725 ret = CRYPT_AsnEncodeAccessDescription(
2726 &info->rgAccDescr[i], pbEncoded, &size);
2727 pbEncoded += size;
2728 dataLen -= size;
2729 }
2730 }
2731 }
2732 }
2733 }
2734 __EXCEPT_PAGE_FAULT
2735 {
2736 SetLastError(STATUS_ACCESS_VIOLATION);
2737 ret = FALSE;
2738 }
2739 __ENDTRY
2740 return ret;
2741 }
2742
2743 static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints(DWORD dwCertEncodingType,
2744 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2745 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2746 {
2747 BOOL ret;
2748
2749 __TRY
2750 {
2751 const CERT_BASIC_CONSTRAINTS_INFO *info =
2752 (const CERT_BASIC_CONSTRAINTS_INFO *)pvStructInfo;
2753 struct AsnEncodeSequenceItem items[3] = {
2754 { &info->SubjectType, CRYPT_AsnEncodeBits, 0 },
2755 { 0 }
2756 };
2757 DWORD cItem = 1;
2758
2759 if (info->fPathLenConstraint)
2760 {
2761 items[cItem].pvStructInfo = &info->dwPathLenConstraint;
2762 items[cItem].encodeFunc = CRYPT_AsnEncodeInt;
2763 cItem++;
2764 }
2765 if (info->cSubtreesConstraint)
2766 {
2767 items[cItem].pvStructInfo = &info->cSubtreesConstraint;
2768 items[cItem].encodeFunc = CRYPT_AsnEncodeSequenceOfAny;
2769 cItem++;
2770 }
2771 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
2772 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2773 }
2774 __EXCEPT_PAGE_FAULT
2775 {
2776 SetLastError(STATUS_ACCESS_VIOLATION);
2777 ret = FALSE;
2778 }
2779 __ENDTRY
2780 return ret;
2781 }
2782
2783 static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints2(DWORD dwCertEncodingType,
2784 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2785 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2786 {
2787 BOOL ret;
2788
2789 __TRY
2790 {
2791 const CERT_BASIC_CONSTRAINTS2_INFO *info =
2792 (const CERT_BASIC_CONSTRAINTS2_INFO *)pvStructInfo;
2793 struct AsnEncodeSequenceItem items[2] = { { 0 } };
2794 DWORD cItem = 0;
2795
2796 if (info->fCA)
2797 {
2798 items[cItem].pvStructInfo = &info->fCA;
2799 items[cItem].encodeFunc = CRYPT_AsnEncodeBool;
2800 cItem++;
2801 }
2802 if (info->fPathLenConstraint)
2803 {
2804 items[cItem].pvStructInfo = &info->dwPathLenConstraint;
2805 items[cItem].encodeFunc = CRYPT_AsnEncodeInt;
2806 cItem++;
2807 }
2808 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
2809 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2810 }
2811 __EXCEPT_PAGE_FAULT
2812 {
2813 SetLastError(STATUS_ACCESS_VIOLATION);
2814 ret = FALSE;
2815 }
2816 __ENDTRY
2817 return ret;
2818 }
2819
2820 static BOOL WINAPI CRYPT_AsnEncodeCertPolicyQualifiers(DWORD dwCertEncodingType,
2821 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2822 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2823 {
2824 DWORD cPolicyQualifier = *(DWORD *)pvStructInfo;
2825 const CERT_POLICY_QUALIFIER_INFO *rgPolicyQualifier =
2826 *(const CERT_POLICY_QUALIFIER_INFO **)
2827 ((LPBYTE)pvStructInfo + sizeof(DWORD));
2828 BOOL ret;
2829
2830 if (!cPolicyQualifier)
2831 {
2832 *pcbEncoded = 0;
2833 ret = TRUE;
2834 }
2835 else
2836 {
2837 struct AsnEncodeSequenceItem items[2] = {
2838 { NULL, CRYPT_AsnEncodeOid, 0 },
2839 { NULL, CRYPT_CopyEncodedBlob, 0 },
2840 };
2841 DWORD bytesNeeded = 0, lenBytes, size, i;
2842
2843 ret = TRUE;
2844 for (i = 0; ret && i < cPolicyQualifier; i++)
2845 {
2846 items[0].pvStructInfo = rgPolicyQualifier[i].pszPolicyQualifierId;
2847 items[1].pvStructInfo = &rgPolicyQualifier[i].Qualifier;
2848 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
2849 sizeof(items) / sizeof(items[0]),
2850 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &size);
2851 if (ret)
2852 bytesNeeded += size;
2853 }
2854 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
2855 bytesNeeded += 1 + lenBytes;
2856 if (ret)
2857 {
2858 if (!pbEncoded)
2859 *pcbEncoded = bytesNeeded;
2860 else
2861 {
2862 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2863 pbEncoded, pcbEncoded, bytesNeeded)))
2864 {
2865 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2866 pbEncoded = *(BYTE **)pbEncoded;
2867 *pbEncoded++ = ASN_SEQUENCEOF;
2868 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
2869 &lenBytes);
2870 pbEncoded += lenBytes;
2871 for (i = 0; ret && i < cPolicyQualifier; i++)
2872 {
2873 items[0].pvStructInfo =
2874 rgPolicyQualifier[i].pszPolicyQualifierId;
2875 items[1].pvStructInfo =
2876 &rgPolicyQualifier[i].Qualifier;
2877 size = bytesNeeded;
2878 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
2879 sizeof(items) / sizeof(items[0]),
2880 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, pbEncoded,
2881 &size);
2882 if (ret)
2883 {
2884 pbEncoded += size;
2885 bytesNeeded -= size;
2886 }
2887 }
2888 }
2889 }
2890 }
2891 }
2892 return ret;
2893 }
2894
2895 static BOOL CRYPT_AsnEncodeCertPolicy(DWORD dwCertEncodingType,
2896 const CERT_POLICY_INFO *info, DWORD dwFlags, BYTE *pbEncoded,
2897 DWORD *pcbEncoded)
2898 {
2899 struct AsnEncodeSequenceItem items[2] = {
2900 { info->pszPolicyIdentifier, CRYPT_AsnEncodeOid, 0 },
2901 { &info->cPolicyQualifier, CRYPT_AsnEncodeCertPolicyQualifiers, 0 },
2902 };
2903 BOOL ret;
2904
2905 if (!info->pszPolicyIdentifier)
2906 {
2907 SetLastError(E_INVALIDARG);
2908 return FALSE;
2909 }
2910 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
2911 sizeof(items) / sizeof(items[0]), dwFlags, NULL, pbEncoded, pcbEncoded);
2912 return ret;
2913 }
2914
2915 static BOOL WINAPI CRYPT_AsnEncodeCertPolicies(DWORD dwCertEncodingType,
2916 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2917 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2918 {
2919 BOOL ret = FALSE;
2920
2921 __TRY
2922 {
2923 const CERT_POLICIES_INFO *info = pvStructInfo;
2924 DWORD bytesNeeded = 0, lenBytes, size, i;
2925
2926 ret = TRUE;
2927 for (i = 0; ret && i < info->cPolicyInfo; i++)
2928 {
2929 ret = CRYPT_AsnEncodeCertPolicy(dwCertEncodingType,
2930 &info->rgPolicyInfo[i], dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL,
2931 &size);
2932 if (ret)
2933 bytesNeeded += size;
2934 }
2935 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
2936 bytesNeeded += 1 + lenBytes;
2937 if (ret)
2938 {
2939 if (!pbEncoded)
2940 *pcbEncoded = bytesNeeded;
2941 else
2942 {
2943 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2944 pbEncoded, pcbEncoded, bytesNeeded)))
2945 {
2946 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2947 pbEncoded = *(BYTE **)pbEncoded;
2948 *pbEncoded++ = ASN_SEQUENCEOF;
2949 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
2950 &lenBytes);
2951 pbEncoded += lenBytes;
2952 for (i = 0; ret && i < info->cPolicyInfo; i++)
2953 {
2954 size = bytesNeeded;
2955 ret = CRYPT_AsnEncodeCertPolicy(dwCertEncodingType,
2956 &info->rgPolicyInfo[i],
2957 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, pbEncoded, &size);
2958 if (ret)
2959 {
2960 pbEncoded += size;
2961 bytesNeeded -= size;
2962 }
2963 }
2964 }
2965 }
2966 }
2967 }
2968 __EXCEPT_PAGE_FAULT
2969 {
2970 SetLastError(STATUS_ACCESS_VIOLATION);
2971 }
2972 __ENDTRY
2973 return ret;
2974 }
2975
2976 static BOOL WINAPI CRYPT_AsnEncodeRsaPubKey(DWORD dwCertEncodingType,
2977 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2978 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2979 {
2980 BOOL ret;
2981
2982 __TRY
2983 {
2984 const BLOBHEADER *hdr =
2985 (const BLOBHEADER *)pvStructInfo;
2986
2987 if (hdr->bType != PUBLICKEYBLOB)
2988 {
2989 SetLastError(E_INVALIDARG);
2990 ret = FALSE;
2991 }
2992 else
2993 {
2994 const RSAPUBKEY *rsaPubKey = (const RSAPUBKEY *)
2995 ((const BYTE *)pvStructInfo + sizeof(BLOBHEADER));
2996 CRYPT_INTEGER_BLOB blob = { rsaPubKey->bitlen / 8,
2997 (BYTE *)pvStructInfo + sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) };
2998 struct AsnEncodeSequenceItem items[] = {
2999 { &blob, CRYPT_AsnEncodeUnsignedInteger, 0 },
3000 { &rsaPubKey->pubexp, CRYPT_AsnEncodeInt, 0 },
3001 };
3002
3003 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
3004 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
3005 pcbEncoded);
3006 }
3007 }
3008 __EXCEPT_PAGE_FAULT
3009 {
3010 SetLastError(STATUS_ACCESS_VIOLATION);
3011 ret = FALSE;
3012 }
3013 __ENDTRY
3014 return ret;
3015 }
3016
3017 BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
3018 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3019 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3020 {
3021 BOOL ret;
3022
3023 __TRY
3024 {
3025 const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo;
3026 DWORD bytesNeeded, lenBytes;
3027
3028 TRACE("(%d, %p), %08x, %p, %p, %d\n", blob->cbData, blob->pbData,
3029 dwFlags, pEncodePara, pbEncoded, *pcbEncoded);
3030
3031 CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes);
3032 bytesNeeded = 1 + lenBytes + blob->cbData;
3033 if (!pbEncoded)
3034 {
3035 *pcbEncoded = bytesNeeded;
3036 ret = TRUE;
3037 }
3038 else
3039 {
3040 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
3041 pcbEncoded, bytesNeeded)))
3042 {
3043 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3044 pbEncoded = *(BYTE **)pbEncoded;
3045 *pbEncoded++ = ASN_OCTETSTRING;
3046 CRYPT_EncodeLen(blob->cbData, pbEncoded, &lenBytes);
3047 pbEncoded += lenBytes;
3048 if (blob->cbData)
3049 memcpy(pbEncoded, blob->pbData, blob->cbData);
3050 }
3051 }
3052 }
3053 __EXCEPT_PAGE_FAULT
3054 {
3055 SetLastError(STATUS_ACCESS_VIOLATION);
3056 ret = FALSE;
3057 }
3058 __ENDTRY
3059 TRACE("returning %d (%08x)\n", ret, GetLastError());
3060 return ret;
3061 }
3062
3063 static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType,
3064 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3065 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3066 {
3067 BOOL ret;
3068
3069 __TRY
3070 {
3071 const CRYPT_BIT_BLOB *blob = (const CRYPT_BIT_BLOB *)pvStructInfo;
3072 DWORD bytesNeeded, lenBytes, dataBytes;
3073 BYTE unusedBits;
3074
3075 /* yep, MS allows cUnusedBits to be >= 8 */
3076 if (!blob->cUnusedBits)
3077 {
3078 dataBytes = blob->cbData;
3079 unusedBits = 0;
3080 }
3081 else if (blob->cbData * 8 > blob->cUnusedBits)
3082 {
3083 dataBytes = (blob->cbData * 8 - blob->cUnusedBits) / 8 + 1;
3084 unusedBits = blob->cUnusedBits >= 8 ? blob->cUnusedBits / 8 :
3085 blob->cUnusedBits;
3086 }
3087 else
3088 {
3089 dataBytes = 0;
3090 unusedBits = 0;
3091 }
3092 CRYPT_EncodeLen(dataBytes + 1, NULL, &lenBytes);
3093 bytesNeeded = 1 + lenBytes + dataBytes + 1;
3094 if (!pbEncoded)
3095 {
3096 *pcbEncoded = bytesNeeded;
3097 ret = TRUE;
3098 }
3099 else
3100 {
3101 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
3102 pcbEncoded, bytesNeeded)))
3103 {
3104 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3105 pbEncoded = *(BYTE **)pbEncoded;
3106 *pbEncoded++ = ASN_BITSTRING;
3107 CRYPT_EncodeLen(dataBytes + 1, pbEncoded, &lenBytes);
3108 pbEncoded += lenBytes;
3109 *pbEncoded++ = unusedBits;
3110 if (dataBytes)
3111 {
3112 BYTE mask = 0xff << unusedBits;
3113
3114 if (dataBytes > 1)
3115 {
3116 memcpy(pbEncoded, blob->pbData, dataBytes - 1);
3117 pbEncoded += dataBytes - 1;
3118 }
3119 *pbEncoded = *(blob->pbData + dataBytes - 1) & mask;
3120 }
3121 }
3122 }
3123 }
3124 __EXCEPT_PAGE_FAULT
3125 {
3126 SetLastError(STATUS_ACCESS_VIOLATION);
3127 ret = FALSE;
3128 }
3129 __ENDTRY
3130 return ret;
3131 }
3132
3133 static BOOL WINAPI CRYPT_AsnEncodeBitsSwapBytes(DWORD dwCertEncodingType,
3134 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3135 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3136 {
3137 BOOL ret;
3138
3139 __TRY
3140 {
3141 const CRYPT_BIT_BLOB *blob = (const CRYPT_BIT_BLOB *)pvStructInfo;
3142 CRYPT_BIT_BLOB newBlob = { blob->cbData, NULL, blob->cUnusedBits };
3143
3144 ret = TRUE;
3145 if (newBlob.cbData)
3146 {
3147 newBlob.pbData = CryptMemAlloc(newBlob.cbData);
3148 if (newBlob.pbData)
3149 {
3150 DWORD i;
3151
3152 for (i = 0; i < newBlob.cbData; i++)
3153 newBlob.pbData[newBlob.cbData - i - 1] = blob->pbData[i];
3154 }
3155 else
3156 ret = FALSE;
3157 }
3158 if (ret)
3159 ret = CRYPT_AsnEncodeBits(dwCertEncodingType, lpszStructType,
3160 &newBlob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3161 CryptMemFree(newBlob.pbData);
3162 }
3163 __EXCEPT_PAGE_FAULT
3164 {
3165 SetLastError(STATUS_ACCESS_VIOLATION);
3166 ret = FALSE;
3167 }
3168 __ENDTRY
3169 return ret;
3170 }
3171
3172 static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType,
3173 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3174 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3175 {
3176 CRYPT_INTEGER_BLOB blob = { sizeof(INT), (BYTE *)pvStructInfo };
3177
3178 return CRYPT_AsnEncodeInteger(dwCertEncodingType, X509_MULTI_BYTE_INTEGER,
3179 &blob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3180 }
3181
3182 static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType,
3183 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3184 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3185 {
3186 BOOL ret;
3187
3188 __TRY
3189 {
3190 DWORD significantBytes, lenBytes, bytesNeeded;
3191 BYTE padByte = 0;
3192 BOOL pad = FALSE;
3193 const CRYPT_INTEGER_BLOB *blob =
3194 (const CRYPT_INTEGER_BLOB *)pvStructInfo;
3195
3196 significantBytes = blob->cbData;
3197 if (significantBytes)
3198 {
3199 if (blob->pbData[significantBytes - 1] & 0x80)
3200 {
3201 /* negative, lop off leading (little-endian) 0xffs */
3202 for (; significantBytes > 0 &&
3203 blob->pbData[significantBytes - 1] == 0xff; significantBytes--)
3204 ;
3205 if (blob->pbData[significantBytes - 1] < 0x80)
3206 {
3207 padByte = 0xff;
3208 pad = TRUE;
3209 }
3210 }
3211 else
3212 {
3213 /* positive, lop off leading (little-endian) zeroes */
3214 for (; significantBytes > 0 &&
3215 !blob->pbData[significantBytes - 1]; significantBytes--)
3216 ;
3217 if (significantBytes == 0)
3218 significantBytes = 1;
3219 if (blob->pbData[significantBytes - 1] > 0x7f)
3220 {
3221 padByte = 0;
3222 pad = TRUE;
3223 }
3224 }
3225 }
3226 if (pad)
3227 CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes);
3228 else
3229 CRYPT_EncodeLen(significantBytes, NULL, &lenBytes);
3230 bytesNeeded = 1 + lenBytes + significantBytes;
3231 if (pad)
3232 bytesNeeded++;
3233 if (!pbEncoded)
3234 {
3235 *pcbEncoded = bytesNeeded;
3236 ret = TRUE;
3237 }
3238 else
3239 {
3240 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
3241 pcbEncoded, bytesNeeded)))
3242 {
3243 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3244 pbEncoded = *(BYTE **)pbEncoded;
3245 *pbEncoded++ = ASN_INTEGER;
3246 if (pad)
3247 {
3248 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
3249 pbEncoded += lenBytes;
3250 *pbEncoded++ = padByte;
3251 }
3252 else
3253 {
3254 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
3255 pbEncoded += lenBytes;
3256 }
3257 for (; significantBytes > 0; significantBytes--)
3258 *(pbEncoded++) = blob->pbData[significantBytes - 1];
3259 }
3260 }
3261 }
3262 __EXCEPT_PAGE_FAULT
3263 {
3264 SetLastError(STATUS_ACCESS_VIOLATION);
3265 ret = FALSE;
3266 }
3267 __ENDTRY
3268 return ret;
3269 }
3270
3271 static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType,
3272 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3273 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3274 {
3275 BOOL ret;
3276
3277 __TRY
3278 {
3279 DWORD significantBytes, lenBytes, bytesNeeded;
3280 BOOL pad = FALSE;
3281 const CRYPT_INTEGER_BLOB *blob =
3282 (const CRYPT_INTEGER_BLOB *)pvStructInfo;
3283
3284 significantBytes = blob->cbData;
3285 if (significantBytes)
3286 {
3287 /* positive, lop off leading (little-endian) zeroes */
3288 for (; significantBytes > 0 && !blob->pbData[significantBytes - 1];
3289 significantBytes--)
3290 ;
3291 if (significantBytes == 0)
3292 significantBytes = 1;
3293 if (blob->pbData[significantBytes - 1] > 0x7f)
3294 pad = TRUE;
3295 }
3296 if (pad)
3297 CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes);
3298 else
3299 CRYPT_EncodeLen(significantBytes, NULL, &lenBytes);
3300 bytesNeeded = 1 + lenBytes + significantBytes;
3301 if (pad)
3302 bytesNeeded++;
3303 if (!pbEncoded)
3304 {
3305 *pcbEncoded = bytesNeeded;
3306 ret = TRUE;
3307 }
3308 else
3309 {
3310 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
3311 pcbEncoded, bytesNeeded)))
3312 {
3313 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3314 pbEncoded = *(BYTE **)pbEncoded;
3315 *pbEncoded++ = ASN_INTEGER;
3316 if (pad)
3317 {
3318 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
3319 pbEncoded += lenBytes;
3320 *pbEncoded++ = 0;
3321 }
3322 else
3323 {
3324 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
3325 pbEncoded += lenBytes;
3326 }
3327 for (; significantBytes > 0; significantBytes--)
3328 *(pbEncoded++) = blob->pbData[significantBytes - 1];
3329 }
3330 }
3331 }
3332 __EXCEPT_PAGE_FAULT
3333 {
3334 SetLastError(STATUS_ACCESS_VIOLATION);
3335 ret = FALSE;
3336 }
3337 __ENDTRY
3338 return ret;
3339 }
3340
3341 static BOOL WINAPI CRYPT_AsnEncodeEnumerated(DWORD dwCertEncodingType,
3342 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3343 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3344 {
3345 CRYPT_INTEGER_BLOB blob;
3346 BOOL ret;
3347
3348 /* Encode as an unsigned integer, then change the tag to enumerated */
3349 blob.cbData = sizeof(DWORD);
3350 blob.pbData = (BYTE *)pvStructInfo;
3351 ret = CRYPT_AsnEncodeUnsignedInteger(dwCertEncodingType,
3352 X509_MULTI_BYTE_UINT, &blob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3353 if (ret && pbEncoded)
3354 {
3355 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3356 pbEncoded = *(BYTE **)pbEncoded;
3357 pbEncoded[0] = ASN_ENUMERATED;
3358 }
3359 return ret;
3360 }
3361
3362 static BOOL WINAPI CRYPT_AsnEncodeUtcTime(DWORD dwCertEncodingType,
3363 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3364 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3365 {
3366 BOOL ret;
3367
3368 __TRY
3369 {
3370 SYSTEMTIME sysTime;
3371 /* sorry, magic number: enough for tag, len, YYMMDDHHMMSSZ\0. I use a
3372 * temporary buffer because the output buffer is not NULL-terminated.
3373 */
3374 char buf[16];
3375 static const DWORD bytesNeeded = sizeof(buf) - 1;
3376
3377 if (!pbEncoded)
3378 {
3379 *pcbEncoded = bytesNeeded;
3380 ret = TRUE;
3381 }
3382 else
3383 {
3384 /* Sanity check the year, this is a two-digit year format */
3385 ret = FileTimeToSystemTime((const FILETIME *)pvStructInfo,
3386 &sysTime);
3387 if (ret && (sysTime.wYear < 1950 || sysTime.wYear > 2050))
3388 {
3389 SetLastError(CRYPT_E_BAD_ENCODE);
3390 ret = FALSE;
3391 }
3392 if (ret)
3393 {
3394 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
3395 pbEncoded, pcbEncoded, bytesNeeded)))
3396 {
3397 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3398 pbEncoded = *(BYTE **)pbEncoded;
3399 buf[0] = ASN_UTCTIME;
3400 buf[1] = bytesNeeded - 2;
3401 snprintf(buf + 2, sizeof(buf) - 2,
3402 "%02d%02d%02d%02d%02d%02dZ", sysTime.wYear >= 2000 ?
3403 sysTime.wYear - 2000 : sysTime.wYear - 1900,
3404 sysTime.wMonth, sysTime.wDay, sysTime.wHour,
3405 sysTime.wMinute, sysTime.wSecond);
3406 memcpy(pbEncoded, buf, bytesNeeded);
3407 }
3408 }
3409 }
3410 }
3411 __EXCEPT_PAGE_FAULT
3412 {
3413 SetLastError(STATUS_ACCESS_VIOLATION);
3414 ret = FALSE;
3415 }
3416 __ENDTRY
3417 return ret;
3418 }
3419
3420 static BOOL CRYPT_AsnEncodeGeneralizedTime(DWORD dwCertEncodingType,
3421 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3422 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3423 {
3424 BOOL ret;
3425
3426 __TRY
3427 {
3428 SYSTEMTIME sysTime;
3429 /* sorry, magic number: enough for tag, len, YYYYMMDDHHMMSSZ\0. I use a
3430 * temporary buffer because the output buffer is not NULL-terminated.
3431 */
3432 char buf[18];
3433 static const DWORD bytesNeeded = sizeof(buf) - 1;
3434
3435 if (!pbEncoded)
3436 {
3437 *pcbEncoded = bytesNeeded;
3438 ret = TRUE;
3439 }
3440 else
3441 {
3442 ret = FileTimeToSystemTime((const FILETIME *)pvStructInfo,
3443 &sysTime);
3444 if (ret)
3445 ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
3446 pcbEncoded, bytesNeeded);
3447 if (ret)
3448 {
3449 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3450 pbEncoded = *(BYTE **)pbEncoded;
3451 buf[0] = ASN_GENERALTIME;
3452 buf[1] = bytesNeeded - 2;
3453 snprintf(buf + 2, sizeof(buf) - 2, "%04d%02d%02d%02d%02d%02dZ",
3454 sysTime.wYear, sysTime.wMonth, sysTime.wDay, sysTime.wHour,
3455 sysTime.wMinute, sysTime.wSecond);
3456 memcpy(pbEncoded, buf, bytesNeeded);
3457 }
3458 }
3459 }
3460 __EXCEPT_PAGE_FAULT
3461 {
3462 SetLastError(STATUS_ACCESS_VIOLATION);
3463 ret = FALSE;
3464 }
3465 __ENDTRY
3466 return ret;
3467 }
3468
3469 static BOOL WINAPI CRYPT_AsnEncodeChoiceOfTime(DWORD dwCertEncodingType,
3470 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3471 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3472 {
3473 BOOL ret;
3474
3475 __TRY
3476 {
3477 SYSTEMTIME sysTime;
3478
3479 /* Check the year, if it's in the UTCTime range call that encode func */
3480 if (!FileTimeToSystemTime((const FILETIME *)pvStructInfo, &sysTime))
3481 return FALSE;
3482 if (sysTime.wYear >= 1950 && sysTime.wYear <= 2050)
3483 ret = CRYPT_AsnEncodeUtcTime(dwCertEncodingType, lpszStructType,
3484 pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3485 else
3486 ret = CRYPT_AsnEncodeGeneralizedTime(dwCertEncodingType,
3487 lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded,
3488 pcbEncoded);
3489 }
3490 __EXCEPT_PAGE_FAULT
3491 {
3492 SetLastError(STATUS_ACCESS_VIOLATION);
3493 ret = FALSE;
3494 }
3495 __ENDTRY
3496 return ret;
3497 }
3498
3499 static BOOL WINAPI CRYPT_AsnEncodeSequenceOfAny(DWORD dwCertEncodingType,
3500 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3501 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3502 {
3503 BOOL ret;
3504
3505 __TRY
3506 {
3507 DWORD bytesNeeded, dataLen, lenBytes, i;
3508 const CRYPT_SEQUENCE_OF_ANY *seq =
3509 (const CRYPT_SEQUENCE_OF_ANY *)pvStructInfo;
3510
3511 for (i = 0, dataLen = 0; i < seq->cValue; i++)
3512 dataLen += seq->rgValue[i].cbData;
3513 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
3514 bytesNeeded = 1 + lenBytes + dataLen;
3515 if (!pbEncoded)
3516 {
3517 *pcbEncoded = bytesNeeded;
3518 ret = TRUE;
3519 }
3520 else
3521 {
3522 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
3523 pcbEncoded, bytesNeeded)))
3524 {
3525 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3526 pbEncoded = *(BYTE **)pbEncoded;
3527 *pbEncoded++ = ASN_SEQUENCEOF;
3528 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
3529 pbEncoded += lenBytes;
3530 for (i = 0; i < seq->cValue; i++)
3531 {
3532 memcpy(pbEncoded, seq->rgValue[i].pbData,
3533 seq->rgValue[i].cbData);
3534 pbEncoded += seq->rgValue[i].cbData;
3535 }
3536 }
3537 }
3538 }
3539 __EXCEPT_PAGE_FAULT
3540 {
3541 SetLastError(STATUS_ACCESS_VIOLATION);
3542 ret = FALSE;
3543 }
3544 __ENDTRY
3545 return ret;
3546 }
3547
3548 static BOOL CRYPT_AsnEncodeDistPoint(const CRL_DIST_POINT *distPoint,
3549 BYTE *pbEncoded, DWORD *pcbEncoded)
3550 {
3551 BOOL ret = TRUE;
3552 struct AsnEncodeSequenceItem items[3] = { { 0 } };
3553 struct AsnConstructedItem constructed = { 0 };
3554 struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
3555 DWORD cItem = 0, cSwapped = 0;
3556
3557 switch (distPoint->DistPointName.dwDistPointNameChoice)
3558 {
3559 case CRL_DIST_POINT_NO_NAME:
3560 /* do nothing */
3561 break;
3562 case CRL_DIST_POINT_FULL_NAME:
3563 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
3564 swapped[cSwapped].pvStructInfo = &distPoint->DistPointName.u.FullName;
3565 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
3566 constructed.tag = 0;
3567 constructed.pvStructInfo = &swapped[cSwapped];
3568 constructed.encodeFunc = CRYPT_AsnEncodeSwapTag;
3569 items[cItem].pvStructInfo = &constructed;
3570 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
3571 cSwapped++;
3572 cItem++;
3573 break;
3574 case CRL_DIST_POINT_ISSUER_RDN_NAME:
3575 FIXME("unimplemented for CRL_DIST_POINT_ISSUER_RDN_NAME\n");
3576 ret = FALSE;
3577 break;
3578 default:
3579 ret = FALSE;
3580 }
3581 if (ret && distPoint->ReasonFlags.cbData)
3582 {
3583 swapped[cSwapped].tag = ASN_CONTEXT | 1;
3584 swapped[cSwapped].pvStructInfo = &distPoint->ReasonFlags;
3585 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBits;
3586 items[cItem].pvStructInfo = &swapped[cSwapped];
3587 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3588 cSwapped++;
3589 cItem++;
3590 }
3591 if (ret && distPoint->CRLIssuer.cAltEntry)
3592 {
3593 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 2;
3594 swapped[cSwapped].pvStructInfo = &distPoint->CRLIssuer;
3595 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
3596 items[cItem].pvStructInfo = &swapped[cSwapped];
3597 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3598 cSwapped++;
3599 cItem++;
3600 }
3601 if (ret)
3602 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
3603 pbEncoded, pcbEncoded);
3604 return ret;
3605 }
3606
3607 static BOOL WINAPI CRYPT_AsnEncodeCRLDistPoints(DWORD dwCertEncodingType,
3608 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3609 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3610 {
3611 BOOL ret;
3612
3613 __TRY
3614 {
3615 const CRL_DIST_POINTS_INFO *info =
3616 (const CRL_DIST_POINTS_INFO *)pvStructInfo;
3617
3618 if (!info->cDistPoint)
3619 {
3620 SetLastError(E_INVALIDARG);
3621 ret = FALSE;
3622 }
3623 else
3624 {
3625 DWORD bytesNeeded, dataLen, lenBytes, i;
3626
3627 ret = TRUE;
3628 for (i = 0, dataLen = 0; ret && i < info->cDistPoint; i++)
3629 {
3630 DWORD len;
3631
3632 ret = CRYPT_AsnEncodeDistPoint(&info->rgDistPoint[i], NULL,
3633 &len);
3634 if (ret)
3635 dataLen += len;
3636 else if (GetLastError() == CRYPT_E_INVALID_IA5_STRING)
3637 {
3638 /* Have to propagate index of failing character */
3639 *pcbEncoded = len;
3640 }
3641 }
3642 if (ret)
3643 {
3644 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
3645 bytesNeeded = 1 + lenBytes + dataLen;
3646 if (!pbEncoded)
3647 {
3648 *pcbEncoded = bytesNeeded;
3649 ret = TRUE;
3650 }
3651 else
3652 {
3653 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
3654 pbEncoded, pcbEncoded, bytesNeeded)))
3655 {
3656 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3657 pbEncoded = *(BYTE **)pbEncoded;
3658 *pbEncoded++ = ASN_SEQUENCEOF;
3659 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
3660 pbEncoded += lenBytes;
3661 for (i = 0; ret && i < info->cDistPoint; i++)
3662 {
3663 DWORD len = dataLen;
3664
3665 ret = CRYPT_AsnEncodeDistPoint(
3666 &info->rgDistPoint[i], pbEncoded, &len);
3667 if (ret)
3668 {
3669 pbEncoded += len;
3670 dataLen -= len;
3671 }
3672 }
3673 }
3674 }
3675 }
3676 }
3677 }
3678 __EXCEPT_PAGE_FAULT
3679 {
3680 SetLastError(STATUS_ACCESS_VIOLATION);
3681 ret = FALSE;
3682 }
3683 __ENDTRY
3684 return ret;
3685 }
3686
3687 static BOOL WINAPI CRYPT_AsnEncodeEnhancedKeyUsage(DWORD dwCertEncodingType,
3688 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3689 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3690 {
3691 BOOL ret;
3692
3693 __TRY
3694 {
3695 const CERT_ENHKEY_USAGE *usage =
3696 (const CERT_ENHKEY_USAGE *)pvStructInfo;
3697 DWORD bytesNeeded = 0, lenBytes, size, i;
3698
3699 ret = TRUE;
3700 for (i = 0; ret && i < usage->cUsageIdentifier; i++)
3701 {
3702 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
3703 usage->rgpszUsageIdentifier[i],
3704 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &size);
3705 if (ret)
3706 bytesNeeded += size;
3707 }
3708 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
3709 bytesNeeded += 1 + lenBytes;
3710 if (ret)
3711 {
3712 if (!pbEncoded)
3713 *pcbEncoded = bytesNeeded;
3714 else
3715 {
3716 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
3717 pbEncoded, pcbEncoded, bytesNeeded)))
3718 {
3719 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3720 pbEncoded = *(BYTE **)pbEncoded;
3721 *pbEncoded++ = ASN_SEQUENCEOF;
3722 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
3723 &lenBytes);
3724 pbEncoded += lenBytes;
3725 for (i = 0; ret && i < usage->cUsageIdentifier; i++)
3726 {
3727 size = bytesNeeded;
3728 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
3729 usage->rgpszUsageIdentifier[i],
3730 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, pbEncoded,
3731 &size);
3732 if (ret)
3733 {
3734 pbEncoded += size;
3735 bytesNeeded -= size;
3736 }
3737 }
3738 }
3739 }
3740 }
3741 }
3742 __EXCEPT_PAGE_FAULT
3743 {
3744 SetLastError(STATUS_ACCESS_VIOLATION);
3745 ret = FALSE;
3746 }
3747 __ENDTRY
3748 return ret;
3749 }
3750
3751 static BOOL WINAPI CRYPT_AsnEncodeIssuingDistPoint(DWORD dwCertEncodingType,
3752 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3753 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3754 {
3755 BOOL ret;
3756
3757 __TRY
3758 {
3759 const CRL_ISSUING_DIST_POINT *point =
3760 (const CRL_ISSUING_DIST_POINT *)pvStructInfo;
3761 struct AsnEncodeSequenceItem items[6] = { { 0 } };
3762 struct AsnConstructedItem constructed = { 0 };
3763 struct AsnEncodeTagSwappedItem swapped[5] = { { 0 } };
3764 DWORD cItem = 0, cSwapped = 0;
3765
3766 ret = TRUE;
3767 switch (point->DistPointName.dwDistPointNameChoice)
3768 {
3769 case CRL_DIST_POINT_NO_NAME:
3770 /* do nothing */
3771 break;
3772 case CRL_DIST_POINT_FULL_NAME:
3773 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
3774 swapped[cSwapped].pvStructInfo = &point->DistPointName.u.FullName;
3775 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
3776 constructed.tag = 0;
3777 constructed.pvStructInfo = &swapped[cSwapped];
3778 constructed.encodeFunc = CRYPT_AsnEncodeSwapTag;
3779 items[cItem].pvStructInfo = &constructed;
3780 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
3781 cSwapped++;
3782 cItem++;
3783 break;
3784 default:
3785 SetLastError(E_INVALIDARG);
3786 ret = FALSE;
3787 }
3788 if (ret && point->fOnlyContainsUserCerts)
3789 {
3790 swapped[cSwapped].tag = ASN_CONTEXT | 1;
3791 swapped[cSwapped].pvStructInfo = &point->fOnlyContainsUserCerts;
3792 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool;
3793 items[cItem].pvStructInfo = &swapped[cSwapped];
3794 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3795 cSwapped++;
3796 cItem++;
3797 }
3798 if (ret && point->fOnlyContainsCACerts)
3799 {
3800 swapped[cSwapped].tag = ASN_CONTEXT | 2;
3801 swapped[cSwapped].pvStructInfo = &point->fOnlyContainsCACerts;
3802 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool;
3803 items[cItem].pvStructInfo = &swapped[cSwapped];
3804 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3805 cSwapped++;
3806 cItem++;
3807 }
3808 if (ret && point->OnlySomeReasonFlags.cbData)
3809 {
3810 swapped[cSwapped].tag = ASN_CONTEXT | 3;
3811 swapped[cSwapped].pvStructInfo = &point->OnlySomeReasonFlags;
3812 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBits;
3813 items[cItem].pvStructInfo = &swapped[cSwapped];
3814 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3815 cSwapped++;
3816 cItem++;
3817 }
3818 if (ret && point->fIndirectCRL)
3819 {
3820 swapped[cSwapped].tag = ASN_CONTEXT | 4;
3821 swapped[cSwapped].pvStructInfo = &point->fIndirectCRL;
3822 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool;
3823 items[cItem].pvStructInfo = &swapped[cSwapped];
3824 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3825 cSwapped++;
3826 cItem++;
3827 }
3828 if (ret)
3829 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
3830 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3831 }
3832 __EXCEPT_PAGE_FAULT
3833 {
3834 SetLastError(STATUS_ACCESS_VIOLATION);
3835 ret = FALSE;
3836 }
3837 __ENDTRY
3838 return ret;
3839 }
3840
3841 static BOOL CRYPT_AsnEncodeGeneralSubtree(DWORD dwCertEncodingType,
3842 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3843 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3844 {
3845 BOOL ret;
3846 const CERT_GENERAL_SUBTREE *subtree =
3847 (const CERT_GENERAL_SUBTREE *)pvStructInfo;
3848 struct AsnEncodeSequenceItem items[3] = {
3849 { &subtree->Base, CRYPT_AsnEncodeAltNameEntry, 0 },
3850 { 0 }
3851 };
3852 struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
3853 DWORD cItem = 1, cSwapped = 0;
3854
3855 if (subtree->dwMinimum)
3856 {
3857 swapped[cSwapped].tag = ASN_CONTEXT | 0;
3858 swapped[cSwapped].pvStructInfo = &subtree->dwMinimum;
3859 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInt;
3860 items[cItem].pvStructInfo = &swapped[cSwapped];
3861 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3862 cSwapped++;
3863 cItem++;
3864 }
3865 if (subtree->fMaximum)
3866 {
3867 swapped[cSwapped].tag = ASN_CONTEXT | 1;
3868 swapped[cSwapped].pvStructInfo = &subtree->dwMaximum;
3869 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInt;
3870 items[cItem].pvStructInfo = &swapped[cSwapped];
3871 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3872 cSwapped++;
3873 cItem++;
3874 }
3875 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags,
3876 pEncodePara, pbEncoded, pcbEncoded);
3877 return ret;
3878 }
3879
3880 static BOOL WINAPI CRYPT_AsnEncodeNameConstraints(DWORD dwCertEncodingType,
3881 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3882 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3883 {
3884 BOOL ret = FALSE;
3885 CRYPT_BLOB_ARRAY permitted = { 0, NULL }, excluded = { 0, NULL };
3886
3887 TRACE("%p\n", pvStructInfo);
3888
3889 __TRY
3890 {
3891 const CERT_NAME_CONSTRAINTS_INFO *constraints =
3892 (const CERT_NAME_CONSTRAINTS_INFO *)pvStructInfo;
3893 struct AsnEncodeSequenceItem items[2] = { { 0 } };
3894 struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
3895 DWORD i, cItem = 0, cSwapped = 0;
3896
3897 ret = TRUE;
3898 if (constraints->cPermittedSubtree)
3899 {
3900 permitted.rgBlob = CryptMemAlloc(
3901 constraints->cPermittedSubtree * sizeof(CRYPT_DER_BLOB));
3902 if (permitted.rgBlob)
3903 {
3904 permitted.cBlob = constraints->cPermittedSubtree;
3905 memset(permitted.rgBlob, 0,
3906 permitted.cBlob * sizeof(CRYPT_DER_BLOB));
3907 for (i = 0; ret && i < permitted.cBlob; i++)
3908 ret = CRYPT_AsnEncodeGeneralSubtree(dwCertEncodingType,
3909 NULL, &constraints->rgPermittedSubtree[i],
3910 CRYPT_ENCODE_ALLOC_FLAG, NULL,
3911 (BYTE *)&permitted.rgBlob[i].pbData,
3912 &permitted.rgBlob[i].cbData);
3913 if (ret)
3914 {
3915 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
3916 swapped[cSwapped].pvStructInfo = &permitted;
3917 swapped[cSwapped].encodeFunc = CRYPT_DEREncodeSet;
3918 items[cItem].pvStructInfo = &swapped[cSwapped];
3919 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3920 cSwapped++;
3921 cItem++;
3922 }
3923 }
3924 else
3925 ret = FALSE;
3926 }
3927 if (constraints->cExcludedSubtree)
3928 {
3929 excluded.rgBlob = CryptMemAlloc(
3930 constraints->cExcludedSubtree * sizeof(CRYPT_DER_BLOB));
3931 if (excluded.rgBlob)
3932 {
3933 excluded.cBlob = constraints->cExcludedSubtree;
3934 memset(excluded.rgBlob, 0,
3935 excluded.cBlob * sizeof(CRYPT_DER_BLOB));
3936 for (i = 0; ret && i < excluded.cBlob; i++)
3937 ret = CRYPT_AsnEncodeGeneralSubtree(dwCertEncodingType,
3938 NULL, &constraints->rgExcludedSubtree[i],
3939 CRYPT_ENCODE_ALLOC_FLAG, NULL,
3940 (BYTE *)&excluded.rgBlob[i].pbData,
3941 &excluded.rgBlob[i].cbData);
3942 if (ret)
3943 {
3944 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1;
3945 swapped[cSwapped].pvStructInfo = &excluded;
3946 swapped[cSwapped].encodeFunc = CRYPT_DEREncodeSet;
3947 items[cItem].pvStructInfo = &swapped[cSwapped];
3948 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3949 cSwapped++;
3950 cItem++;
3951 }
3952 }
3953 else
3954 ret = FALSE;
3955 }
3956 if (ret)
3957 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
3958 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3959 for (i = 0; i < permitted.cBlob; i++)
3960 LocalFree(permitted.rgBlob[i].pbData);
3961 for (i = 0; i < excluded.cBlob; i++)
3962 LocalFree(excluded.rgBlob[i].pbData);
3963 }
3964 __EXCEPT_PAGE_FAULT
3965 {
3966 SetLastError(STATUS_ACCESS_VIOLATION);
3967 }
3968 __ENDTRY
3969 CryptMemFree(permitted.rgBlob);
3970 CryptMemFree(excluded.rgBlob);
3971 TRACE("returning %d\n", ret);
3972 return ret;
3973 }
3974
3975 static BOOL WINAPI CRYPT_AsnEncodeIssuerSerialNumber(
3976 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
3977 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
3978 DWORD *pcbEncoded)
3979 {
3980 BOOL ret;
3981 const CERT_ISSUER_SERIAL_NUMBER *issuerSerial =
3982 (const CERT_ISSUER_SERIAL_NUMBER *)pvStructInfo;
3983 struct AsnEncodeSequenceItem items[] = {
3984 { &issuerSerial->Issuer, CRYPT_CopyEncodedBlob, 0 },
3985 { &issuerSerial->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
3986 };
3987
3988 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
3989 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
3990 pcbEncoded);
3991 return ret;
3992 }
3993
3994 static BOOL WINAPI CRYPT_AsnEncodePKCSSignerInfo(DWORD dwCertEncodingType,
3995 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3996 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3997 {
3998 BOOL ret = FALSE;
3999
4000 if (!(dwCertEncodingType & PKCS_7_ASN_ENCODING))
4001 {
4002 SetLastError(E_INVALIDARG);
4003 return FALSE;
4004 }
4005
4006 __TRY
4007 {
4008 const CMSG_SIGNER_INFO *info = (const CMSG_SIGNER_INFO *)pvStructInfo;
4009
4010 if (!info->Issuer.cbData)
4011 SetLastError(E_INVALIDARG);
4012 else
4013 {
4014 struct AsnEncodeSequenceItem items[7] = {
4015 { &info->dwVersion, CRYPT_AsnEncodeInt, 0 },
4016 { &info->Issuer, CRYPT_AsnEncodeIssuerSerialNumber, 0 },
4017 { &info->HashAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams,
4018 0 },
4019 };
4020 struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
4021 DWORD cItem = 3, cSwapped = 0;
4022
4023 if (info->AuthAttrs.cAttr)
4024 {
4025 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
4026 swapped[cSwapped].pvStructInfo = &info->AuthAttrs;
4027 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes;
4028 items[cItem].pvStructInfo = &swapped[cSwapped];
4029 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
4030 cSwapped++;
4031 cItem++;
4032 }
4033 items[cItem].pvStructInfo = &info->HashEncryptionAlgorithm;
4034 items[cItem].encodeFunc = CRYPT_AsnEncodeAlgorithmIdWithNullParams;
4035 cItem++;
4036 items[cItem].pvStructInfo = &info->EncryptedHash;
4037 items[cItem].encodeFunc = CRYPT_AsnEncodeOctets;
4038 cItem++;
4039 if (info->UnauthAttrs.cAttr)
4040 {
4041 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1;
4042 swapped[cSwapped].pvStructInfo = &info->UnauthAttrs;
4043 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes;
4044 items[cItem].pvStructInfo = &swapped[cSwapped];
4045 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
4046 cSwapped++;
4047 cItem++;
4048 }
4049 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
4050 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
4051 }
4052 }
4053 __EXCEPT_PAGE_FAULT
4054 {
4055 SetLastError(STATUS_ACCESS_VIOLATION);
4056 }
4057 __ENDTRY
4058 return ret;
4059 }
4060
4061 static BOOL WINAPI CRYPT_AsnEncodeCMSSignerInfo(DWORD dwCertEncodingType,
4062 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
4063 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
4064 {
4065 BOOL ret = FALSE;
4066
4067 if (!(dwCertEncodingType & PKCS_7_ASN_ENCODING))
4068 {
4069 SetLastError(E_INVALIDARG);
4070 return FALSE;
4071 }
4072
4073 __TRY
4074 {
4075 const CMSG_CMS_SIGNER_INFO *info = (const CMSG_CMS_SIGNER_INFO *)pvStructInfo;
4076
4077 if (info->SignerId.dwIdChoice != CERT_ID_ISSUER_SERIAL_NUMBER &&
4078 info->SignerId.dwIdChoice != CERT_ID_KEY_IDENTIFIER)
4079 SetLastError(E_INVALIDARG);
4080 else if (info->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER &&
4081 !info->SignerId.u.IssuerSerialNumber.Issuer.cbData)
4082 SetLastError(E_INVALIDARG);
4083 else
4084 {
4085 struct AsnEncodeSequenceItem items[7] = {
4086 { &info->dwVersion, CRYPT_AsnEncodeInt, 0 },
4087 };
4088 struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
4089 DWORD cItem = 1, cSwapped = 0;
4090
4091 if (info->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
4092 {
4093 items[cItem].pvStructInfo =
4094 &info->SignerId.u.IssuerSerialNumber.Issuer;
4095 items[cItem].encodeFunc =
4096 CRYPT_AsnEncodeIssuerSerialNumber;
4097 cItem++;
4098 }
4099 else
4100 {
4101 swapped[cSwapped].tag = ASN_CONTEXT | 0;
4102 swapped[cSwapped].pvStructInfo = &info->SignerId.u.KeyId;
4103 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeOctets;
4104 items[cItem].pvStructInfo = &swapped[cSwapped];
4105 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
4106 cSwapped++;
4107 cItem++;
4108 }
4109 items[cItem].pvStructInfo = &info->HashAlgorithm;
4110 items[cItem].encodeFunc = CRYPT_AsnEncodeAlgorithmIdWithNullParams;
4111 cItem++;
4112 if (info->AuthAttrs.cAttr)
4113 {
4114 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
4115 swapped[cSwapped].pvStructInfo = &info->AuthAttrs;
4116 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes;
4117 items[cItem].pvStructInfo = &swapped[cSwapped];
4118 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
4119 cSwapped++;
4120 cItem++;
4121 }
4122 items[cItem].pvStructInfo = &info->HashEncryptionAlgorithm;
4123 items[cItem].encodeFunc = CRYPT_AsnEncodeAlgorithmIdWithNullParams;
4124 cItem++;
4125 items[cItem].pvStructInfo = &info->EncryptedHash;
4126 items[cItem].encodeFunc = CRYPT_AsnEncodeOctets;
4127 cItem++;
4128 if (info->UnauthAttrs.cAttr)
4129 {
4130 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1;
4131 swapped[cSwapped].pvStructInfo = &info->UnauthAttrs;
4132 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes;
4133 items[cItem].pvStructInfo = &swapped[cSwapped];
4134 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
4135 cSwapped++;
4136 cItem++;
4137 }
4138 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
4139 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
4140 }
4141 }
4142 __EXCEPT_PAGE_FAULT
4143 {
4144 SetLastError(STATUS_ACCESS_VIOLATION);
4145 }
4146 __ENDTRY
4147 return ret;
4148 }
4149
4150 BOOL CRYPT_AsnEncodeCMSSignedInfo(CRYPT_SIGNED_INFO *signedInfo, void *pvData,
4151 DWORD *pcbData)
4152 {
4153 struct AsnEncodeSequenceItem items[7] = {
4154 { &signedInfo->version, CRYPT_AsnEncodeInt, 0 },
4155 };
4156 struct DERSetDescriptor digestAlgorithmsSet = { 0 }, certSet = { 0 };
4157 struct DERSetDescriptor crlSet = { 0 }, signerSet = { 0 };
4158 struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
4159 DWORD cItem = 1, cSwapped = 0;
4160 BOOL ret = TRUE;
4161
4162 if (signedInfo->cSignerInfo)
4163 {
4164 digestAlgorithmsSet.cItems = signedInfo->cSignerInfo;
4165 digestAlgorithmsSet.items = signedInfo->rgSignerInfo;
4166 digestAlgorithmsSet.itemSize = sizeof(CMSG_CMS_SIGNER_INFO);
4167 digestAlgorithmsSet.itemOffset =
4168 offsetof(CMSG_CMS_SIGNER_INFO, HashAlgorithm);
4169 digestAlgorithmsSet.encode = CRYPT_AsnEncodeAlgorithmIdWithNullParams;
4170 items[cItem].pvStructInfo = &digestAlgorithmsSet;
4171 items[cItem].encodeFunc = CRYPT_DEREncodeItemsAsSet;
4172 cItem++;
4173 }
4174 items[cItem].pvStructInfo = &signedInfo->content;
4175 items[cItem].encodeFunc = CRYPT_AsnEncodePKCSContentInfoInternal;
4176 cItem++;
4177 if (signedInfo->cCertEncoded)
4178 {
4179 certSet.cItems = signedInfo->cCertEncoded;
4180 certSet.items = signedInfo->rgCertEncoded;
4181 certSet.itemSize = sizeof(CERT_BLOB);
4182 certSet.itemOffset = 0;
4183 certSet.encode = CRYPT_CopyEncodedBlob;
4184 swapped[cSwapped].tag = ASN_CONSTRUCTOR | ASN_CONTEXT | 0;
4185 swapped[cSwapped].pvStructInfo = &certSet;
4186 swapped[cSwapped].encodeFunc = CRYPT_DEREncodeItemsAsSet;
4187 items[cItem].pvStructInfo = &swapped[cSwapped];
4188 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
4189 cSwapped++;
4190 cItem++;
4191 }
4192 if (signedInfo->cCrlEncoded)
4193 {
4194 crlSet.cItems = signedInfo->cCrlEncoded;
4195 crlSet.items = signedInfo->rgCrlEncoded;
4196 crlSet.itemSize = sizeof(CRL_BLOB);
4197 crlSet.itemOffset = 0;
4198 crlSet.encode = CRYPT_CopyEncodedBlob;
4199 swapped[cSwapped].tag = ASN_CONSTRUCTOR | ASN_CONTEXT | 1;
4200 swapped[cSwapped].pvStructInfo = &crlSet;
4201 swapped[cSwapped].encodeFunc = CRYPT_DEREncodeItemsAsSet;
4202 items[cItem].pvStructInfo = &swapped[cSwapped];
4203 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
4204 cSwapped++;
4205 cItem++;
4206 }
4207 if (ret && signedInfo->cSignerInfo)
4208 {
4209 signerSet.cItems = signedInfo->cSignerInfo;
4210 signerSet.items = signedInfo->rgSignerInfo;
4211 signerSet.itemSize = sizeof(CMSG_CMS_SIGNER_INFO);
4212 signerSet.itemOffset = 0;
4213 signerSet.encode = CRYPT_AsnEncodeCMSSignerInfo;
4214 items[cItem].pvStructInfo = &signerSet;
4215 items[cItem].encodeFunc = CRYPT_DEREncodeItemsAsSet;
4216 cItem++;
4217 }
4218 if (ret)
4219 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
4220 items, cItem, 0, NULL, pvData, pcbData);
4221
4222 return ret;
4223 }
4224
4225 static CryptEncodeObjectExFunc CRYPT_GetBuiltinEncoder(DWORD dwCertEncodingType,
4226 LPCSTR lpszStructType)
4227 {
4228 CryptEncodeObjectExFunc encodeFunc = NULL;
4229
4230 if ((dwCertEncodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING
4231 && (dwCertEncodingType & CMSG_ENCODING_TYPE_MASK) != PKCS_7_ASN_ENCODING)
4232 {
4233 SetLastError(ERROR_FILE_NOT_FOUND);
4234 return NULL;
4235 }
4236
4237 if (!HIWORD(lpszStructType))
4238 {
4239 switch (LOWORD(lpszStructType))
4240 {
4241 case LOWORD(X509_CERT):
4242 encodeFunc = CRYPT_AsnEncodeCert;
4243 break;
4244 case LOWORD(X509_CERT_TO_BE_SIGNED):
4245 encodeFunc = CRYPT_AsnEncodeCertInfo;
4246 break;
4247 case LOWORD(X509_CERT_CRL_TO_BE_SIGNED):
4248 encodeFunc = CRYPT_AsnEncodeCRLInfo;
4249 break;
4250 case LOWORD(X509_EXTENSIONS):
4251 encodeFunc = CRYPT_AsnEncodeExtensions;
4252 break;
4253 case LOWORD(X509_NAME_VALUE):
4254 encodeFunc = CRYPT_AsnEncodeNameValue;
4255 break;
4256 case LOWORD(X509_NAME):
4257 encodeFunc = CRYPT_AsnEncodeName;
4258 break;
4259 case LOWORD(X509_PUBLIC_KEY_INFO):
4260 encodeFunc = CRYPT_AsnEncodePubKeyInfo;
4261 break;
4262 case LOWORD(X509_AUTHORITY_KEY_ID):
4263 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId;
4264 break;
4265 case LOWORD(X509_ALTERNATE_NAME):
4266 encodeFunc = CRYPT_AsnEncodeAltName;
4267 break;
4268 case LOWORD(X509_BASIC_CONSTRAINTS):
4269 encodeFunc = CRYPT_AsnEncodeBasicConstraints;
4270 break;
4271 case LOWORD(X509_BASIC_CONSTRAINTS2):
4272 encodeFunc = CRYPT_AsnEncodeBasicConstraints2;
4273 break;
4274 case LOWORD(X509_CERT_POLICIES):
4275 encodeFunc = CRYPT_AsnEncodeCertPolicies;
4276 break;
4277 case LOWORD(RSA_CSP_PUBLICKEYBLOB):
4278 encodeFunc = CRYPT_AsnEncodeRsaPubKey;
4279 break;
4280 case LOWORD(X509_UNICODE_NAME):
4281 encodeFunc = CRYPT_AsnEncodeUnicodeName;
4282 break;
4283 case LOWORD(PKCS_CONTENT_INFO):
4284 encodeFunc = CRYPT_AsnEncodePKCSContentInfo;
4285 break;
4286 case LOWORD(PKCS_ATTRIBUTE):
4287 encodeFunc = CRYPT_AsnEncodePKCSAttribute;
4288 break;
4289 case LOWORD(X509_UNICODE_NAME_VALUE):
4290 encodeFunc = CRYPT_AsnEncodeUnicodeNameValue;
4291 break;
4292 case LOWORD(X509_OCTET_STRING):
4293 encodeFunc = CRYPT_AsnEncodeOctets;
4294 break;
4295 case LOWORD(X509_BITS):
4296 case LOWORD(X509_KEY_USAGE):
4297 encodeFunc = CRYPT_AsnEncodeBits;
4298 break;
4299 case LOWORD(X509_INTEGER):
4300 encodeFunc = CRYPT_AsnEncodeInt;
4301 break;
4302 case LOWORD(X509_MULTI_BYTE_INTEGER):
4303 encodeFunc = CRYPT_AsnEncodeInteger;
4304 break;
4305 case LOWORD(X509_MULTI_BYTE_UINT):
4306 encodeFunc = CRYPT_AsnEncodeUnsignedInteger;
4307 break;
4308 case LOWORD(X509_ENUMERATED):
4309 encodeFunc = CRYPT_AsnEncodeEnumerated;
4310 break;
4311 case LOWORD(X509_CHOICE_OF_TIME):
4312 encodeFunc = CRYPT_AsnEncodeChoiceOfTime;
4313 break;
4314 case LOWORD(X509_AUTHORITY_KEY_ID2):
4315 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId2;
4316 break;
4317 case LOWORD(X509_AUTHORITY_INFO_ACCESS):
4318 encodeFunc = CRYPT_AsnEncodeAuthorityInfoAccess;
4319 break;
4320 case LOWORD(X509_SEQUENCE_OF_ANY):
4321 encodeFunc = CRYPT_AsnEncodeSequenceOfAny;
4322 break;
4323 case LOWORD(PKCS_UTC_TIME):
4324 encodeFunc = CRYPT_AsnEncodeUtcTime;
4325 break;
4326 case LOWORD(X509_CRL_DIST_POINTS):
4327 encodeFunc = CRYPT_AsnEncodeCRLDistPoints;
4328 break;
4329 case LOWORD(X509_ENHANCED_KEY_USAGE):
4330 encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage;
4331 break;
4332 case LOWORD(PKCS_CTL):
4333 encodeFunc = CRYPT_AsnEncodeCTL;
4334 break;
4335 case LOWORD(PKCS_SMIME_CAPABILITIES):
4336 encodeFunc = CRYPT_AsnEncodeSMIMECapabilities;
4337 break;
4338 case LOWORD(X509_PKIX_POLICY_QUALIFIER_USERNOTICE):
4339 encodeFunc = CRYPT_AsnEncodePolicyQualifierUserNotice;
4340 break;
4341 case LOWORD(PKCS_ATTRIBUTES):
4342 encodeFunc = CRYPT_AsnEncodePKCSAttributes;
4343 break;
4344 case LOWORD(X509_ISSUING_DIST_POINT):
4345 encodeFunc = CRYPT_AsnEncodeIssuingDistPoint;
4346 break;
4347 case LOWORD(X509_NAME_CONSTRAINTS):
4348 encodeFunc = CRYPT_AsnEncodeNameConstraints;
4349 break;
4350 case LOWORD(PKCS7_SIGNER_INFO):
4351 encodeFunc = CRYPT_AsnEncodePKCSSignerInfo;
4352 break;
4353 case LOWORD(CMS_SIGNER_INFO):
4354 encodeFunc = CRYPT_AsnEncodeCMSSignerInfo;
4355 break;
4356 }
4357 }
4358 else if (!strcmp(lpszStructType, szOID_CERT_EXTENSIONS))
4359 encodeFunc = CRYPT_AsnEncodeExtensions;
4360 else if (!strcmp(lpszStructType, szOID_RSA_signingTime))
4361 encodeFunc = CRYPT_AsnEncodeUtcTime;
4362 else if (!strcmp(lpszStructType, szOID_RSA_SMIMECapabilities))
4363 encodeFunc = CRYPT_AsnEncodeUtcTime;
4364 else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER))
4365 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId;
4366 else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER2))
4367 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId2;
4368 else if (!strcmp(lpszStructType, szOID_CRL_REASON_CODE))
4369 encodeFunc = CRYPT_AsnEncodeEnumerated;
4370 else if (!strcmp(lpszStructType, szOID_KEY_USAGE))
4371 encodeFunc = CRYPT_AsnEncodeBits;
4372 else if (!strcmp(lpszStructType, szOID_SUBJECT_KEY_IDENTIFIER))
4373 encodeFunc = CRYPT_AsnEncodeOctets;
4374 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS))
4375 encodeFunc = CRYPT_AsnEncodeBasicConstraints;
4376 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS2))
4377 encodeFunc = CRYPT_AsnEncodeBasicConstraints2;
4378 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME))
4379 encodeFunc = CRYPT_AsnEncodeAltName;
4380 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME2))
4381 encodeFunc = CRYPT_AsnEncodeAltName;
4382 else if (!strcmp(lpszStructType, szOID_NEXT_UPDATE_LOCATION))
4383 encodeFunc = CRYPT_AsnEncodeAltName;
4384 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME))
4385 encodeFunc = CRYPT_AsnEncodeAltName;
4386 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME2))
4387 encodeFunc = CRYPT_AsnEncodeAltName;
4388 else if (!strcmp(lpszStructType, szOID_CRL_DIST_POINTS))
4389 encodeFunc = CRYPT_AsnEncodeCRLDistPoints;
4390 else if (!strcmp(lpszStructType, szOID_CERT_POLICIES))
4391 encodeFunc = CRYPT_AsnEncodeCertPolicies;
4392 else if (!strcmp(lpszStructType, szOID_ENHANCED_KEY_USAGE))
4393 encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage;
4394 else if (!strcmp(lpszStructType, szOID_ISSUING_DIST_POINT))
4395 encodeFunc = CRYPT_AsnEncodeIssuingDistPoint;
4396 else if (!strcmp(lpszStructType, szOID_NAME_CONSTRAINTS))
4397 encodeFunc = CRYPT_AsnEncodeNameConstraints;
4398 else if (!strcmp(lpszStructType, szOID_AUTHORITY_INFO_ACCESS))
4399 encodeFunc = CRYPT_AsnEncodeAuthorityInfoAccess;
4400 else if (!strcmp(lpszStructType, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE))
4401 encodeFunc = CRYPT_AsnEncodePolicyQualifierUserNotice;
4402 else if (!strcmp(lpszStructType, szOID_CTL))
4403 encodeFunc = CRYPT_AsnEncodeCTL;
4404 return encodeFunc;
4405 }
4406
4407 static CryptEncodeObjectFunc CRYPT_LoadEncoderFunc(DWORD dwCertEncodingType,
4408 LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
4409 {
4410 static HCRYPTOIDFUNCSET set = NULL;
4411 CryptEncodeObjectFunc encodeFunc = NULL;
4412
4413 if (!set)
4414 set = CryptInitOIDFunctionSet(CRYPT_OID_ENCODE_OBJECT_FUNC, 0);
4415 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
4416 (void **)&encodeFunc, hFunc);
4417 return encodeFunc;
4418 }
4419
4420 static CryptEncodeObjectExFunc CRYPT_LoadEncoderExFunc(DWORD dwCertEncodingType,
4421 LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
4422 {
4423 static HCRYPTOIDFUNCSET set = NULL;
4424 CryptEncodeObjectExFunc encodeFunc = NULL;
4425
4426 if (!set)
4427 set = CryptInitOIDFunctionSet(CRYPT_OID_ENCODE_OBJECT_EX_FUNC, 0);
4428 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
4429 (void **)&encodeFunc, hFunc);
4430 return encodeFunc;
4431 }
4432
4433 BOOL WINAPI CryptEncodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType,
4434 const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
4435 {
4436 BOOL ret = FALSE;
4437 HCRYPTOIDFUNCADDR hFunc = NULL;
4438 CryptEncodeObjectFunc pCryptEncodeObject = NULL;
4439 CryptEncodeObjectExFunc pCryptEncodeObjectEx = NULL;
4440
4441 TRACE_(crypt)("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
4442 debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
4443 pcbEncoded);
4444
4445 if (!pbEncoded && !pcbEncoded)
4446 {
4447 SetLastError(ERROR_INVALID_PARAMETER);
4448 return FALSE;
4449 }
4450
4451 if (!(pCryptEncodeObjectEx = CRYPT_GetBuiltinEncoder(dwCertEncodingType,
4452 lpszStructType)))
4453 {
4454 TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n",
4455 debugstr_a(lpszStructType));
4456 pCryptEncodeObject = CRYPT_LoadEncoderFunc(dwCertEncodingType,
4457 lpszStructType, &hFunc);
4458 if (!pCryptEncodeObject)
4459 pCryptEncodeObjectEx = CRYPT_LoadEncoderExFunc(dwCertEncodingType,
4460 lpszStructType, &hFunc);
4461 }
4462 if (pCryptEncodeObject)
4463 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
4464 pvStructInfo, pbEncoded, pcbEncoded);
4465 else if (pCryptEncodeObjectEx)
4466 ret = pCryptEncodeObjectEx(dwCertEncodingType, lpszStructType,
4467 pvStructInfo, 0, NULL, pbEncoded, pcbEncoded);
4468 if (hFunc)
4469 CryptFreeOIDFunctionAddress(hFunc, 0);
4470 TRACE_(crypt)("returning %d\n", ret);
4471 return ret;
4472 }
4473
4474 BOOL WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType,
4475 const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara,
4476 void *pvEncoded, DWORD *pcbEncoded)
4477 {
4478 BOOL ret = FALSE;
4479 HCRYPTOIDFUNCADDR hFunc = NULL;
4480 CryptEncodeObjectExFunc encodeFunc = NULL;
4481
4482 TRACE_(crypt)("(0x%08x, %s, %p, 0x%08x, %p, %p, %p)\n", dwCertEncodingType,
4483 debugstr_a(lpszStructType), pvStructInfo, dwFlags, pEncodePara,
4484 pvEncoded, pcbEncoded);
4485
4486 if (!pvEncoded && !pcbEncoded)
4487 {
4488 SetLastError(ERROR_INVALID_PARAMETER);
4489 return FALSE;
4490 }
4491
4492 SetLastError(NOERROR);
4493 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG && pvEncoded)
4494 *(BYTE **)pvEncoded = NULL;
4495 encodeFunc = CRYPT_GetBuiltinEncoder(dwCertEncodingType, lpszStructType);
4496 if (!encodeFunc)
4497 {
4498 TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n",
4499 debugstr_a(lpszStructType));
4500 encodeFunc = CRYPT_LoadEncoderExFunc(dwCertEncodingType, lpszStructType,
4501 &hFunc);
4502 }
4503 if (encodeFunc)
4504 ret = encodeFunc(dwCertEncodingType, lpszStructType, pvStructInfo,
4505 dwFlags, pEncodePara, pvEncoded, pcbEncoded);
4506 else
4507 {
4508 CryptEncodeObjectFunc pCryptEncodeObject =
4509 CRYPT_LoadEncoderFunc(dwCertEncodingType, lpszStructType, &hFunc);
4510
4511 if (pCryptEncodeObject)
4512 {
4513 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
4514 {
4515 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
4516 pvStructInfo, NULL, pcbEncoded);
4517 if (ret && (ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
4518 pvEncoded, pcbEncoded, *pcbEncoded)))
4519 ret = pCryptEncodeObject(dwCertEncodingType,
4520 lpszStructType, pvStructInfo, *(BYTE **)pvEncoded,
4521 pcbEncoded);
4522 }
4523 else
4524 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
4525 pvStructInfo, pvEncoded, pcbEncoded);
4526 }
4527 }
4528 if (hFunc)
4529 CryptFreeOIDFunctionAddress(hFunc, 0);
4530 TRACE_(crypt)("returning %d\n", ret);
4531 return ret;
4532 }
4533
4534 BOOL WINAPI CryptExportPublicKeyInfo(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec,
4535 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
4536 {
4537 return CryptExportPublicKeyInfoEx(hCryptProv, dwKeySpec, dwCertEncodingType,
4538 NULL, 0, NULL, pInfo, pcbInfo);
4539 }
4540
4541 static BOOL WINAPI CRYPT_ExportRsaPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv,
4542 DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId,
4543 DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
4544 {
4545 BOOL ret;
4546 HCRYPTKEY key;
4547 static CHAR oid[] = szOID_RSA_RSA;
4548
4549 TRACE_(crypt)("(%08lx, %d, %08x, %s, %08x, %p, %p, %d)\n", hCryptProv,
4550 dwKeySpec, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags,
4551 pvAuxInfo, pInfo, pInfo ? *pcbInfo : 0);
4552
4553 if (!pszPublicKeyObjId)
4554 pszPublicKeyObjId = oid;
4555 if ((ret = CryptGetUserKey(hCryptProv, dwKeySpec, &key)))
4556 {
4557 DWORD keySize = 0;
4558
4559 ret = CryptExportKey(key, 0, PUBLICKEYBLOB, 0, NULL, &keySize);
4560 if (ret)
4561 {
4562 LPBYTE pubKey = CryptMemAlloc(keySize);
4563
4564 if (pubKey)
4565 {
4566 ret = CryptExportKey(key, 0, PUBLICKEYBLOB, 0, pubKey,
4567 &keySize);
4568 if (ret)
4569 {
4570 DWORD encodedLen = 0;
4571
4572 ret = CryptEncodeObject(dwCertEncodingType,
4573 RSA_CSP_PUBLICKEYBLOB, pubKey, NULL, &encodedLen);
4574 if (ret)
4575 {
4576 DWORD sizeNeeded = sizeof(CERT_PUBLIC_KEY_INFO) +
4577 strlen(pszPublicKeyObjId) + 1 + encodedLen;
4578
4579 if (!pInfo)
4580 *pcbInfo = sizeNeeded;
4581 else if (*pcbInfo < sizeNeeded)
4582 {
4583 SetLastError(ERROR_MORE_DATA);
4584 *pcbInfo = sizeNeeded;
4585 ret = FALSE;
4586 }
4587 else
4588 {
4589 pInfo->Algorithm.pszObjId = (char *)pInfo +
4590 sizeof(CERT_PUBLIC_KEY_INFO);
4591 lstrcpyA(pInfo->Algorithm.pszObjId,
4592 pszPublicKeyObjId);
4593 pInfo->Algorithm.Parameters.cbData = 0;
4594 pInfo->Algorithm.Parameters.pbData = NULL;
4595 pInfo->PublicKey.pbData =
4596 (BYTE *)pInfo->Algorithm.pszObjId
4597 + lstrlenA(pInfo->Algorithm.pszObjId) + 1;
4598 pInfo->PublicKey.cbData = encodedLen;
4599 pInfo->PublicKey.cUnusedBits = 0;
4600 ret = CryptEncodeObject(dwCertEncodingType,
4601 RSA_CSP_PUBLICKEYBLOB, pubKey,
4602 pInfo->PublicKey.pbData, &pInfo->PublicKey.cbData);
4603 }
4604 }
4605 }
4606 CryptMemFree(pubKey);
4607 }
4608 else
4609 ret = FALSE;
4610 }
4611 CryptDestroyKey(key);
4612 }
4613 return ret;
4614 }
4615
4616 typedef BOOL (WINAPI *ExportPublicKeyInfoExFunc)(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv,
4617 DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId,
4618 DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo);
4619
4620 BOOL WINAPI CryptExportPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec,
4621 DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags,
4622 void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
4623 {
4624 static HCRYPTOIDFUNCSET set = NULL;
4625 BOOL ret;
4626 ExportPublicKeyInfoExFunc exportFunc = NULL;
4627 HCRYPTOIDFUNCADDR hFunc = NULL;
4628
4629 TRACE_(crypt)("(%08lx, %d, %08x, %s, %08x, %p, %p, %d)\n", hCryptProv,
4630 dwKeySpec, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags,
4631 pvAuxInfo, pInfo, pInfo ? *pcbInfo : 0);
4632
4633 if (!hCryptProv)
4634 {
4635 SetLastError(ERROR_INVALID_PARAMETER);
4636 return FALSE;
4637 }
4638
4639 if (pszPublicKeyObjId)
4640 {
4641 if (!set)
4642 set = CryptInitOIDFunctionSet(CRYPT_OID_EXPORT_PUBLIC_KEY_INFO_FUNC,
4643 0);
4644 CryptGetOIDFunctionAddress(set, dwCertEncodingType, pszPublicKeyObjId,
4645 0, (void **)&exportFunc, &hFunc);
4646 }
4647 if (!exportFunc)
4648 exportFunc = CRYPT_ExportRsaPublicKeyInfoEx;
4649 ret = exportFunc(hCryptProv, dwKeySpec, dwCertEncodingType,
4650 pszPublicKeyObjId, dwFlags, pvAuxInfo, pInfo, pcbInfo);
4651 if (hFunc)
4652 CryptFreeOIDFunctionAddress(hFunc, 0);
4653 return ret;
4654 }
4655
4656 BOOL WINAPI CryptImportPublicKeyInfo(HCRYPTPROV hCryptProv,
4657 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, HCRYPTKEY *phKey)
4658 {
4659 return CryptImportPublicKeyInfoEx(hCryptProv, dwCertEncodingType, pInfo,
4660 0, 0, NULL, phKey);
4661 }
4662
4663 static BOOL WINAPI CRYPT_ImportRsaPublicKeyInfoEx(HCRYPTPROV hCryptProv,
4664 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
4665 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey)
4666 {
4667 BOOL ret;
4668 DWORD pubKeySize = 0;
4669
4670 TRACE_(crypt)("(%08lx, %08x, %p, %08x, %08x, %p, %p)\n", hCryptProv,
4671 dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
4672
4673 ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB,
4674 pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, NULL, &pubKeySize);
4675 if (ret)
4676 {
4677 LPBYTE pubKey = CryptMemAlloc(pubKeySize);
4678
4679 if (pubKey)
4680 {
4681 ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB,
4682 pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, pubKey,
4683 &pubKeySize);
4684 if (ret)
4685 {
4686 if(aiKeyAlg)
4687 ((BLOBHEADER*)pubKey)->aiKeyAlg = aiKeyAlg;
4688 ret = CryptImportKey(hCryptProv, pubKey, pubKeySize, 0, 0,
4689 phKey);
4690 }
4691 CryptMemFree(pubKey);
4692 }
4693 else
4694 ret = FALSE;
4695 }
4696 return ret;
4697 }
4698
4699 typedef BOOL (WINAPI *ImportPublicKeyInfoExFunc)(HCRYPTPROV hCryptProv,
4700 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
4701 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey);
4702
4703 BOOL WINAPI CryptImportPublicKeyInfoEx(HCRYPTPROV hCryptProv,
4704 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
4705 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey)
4706 {
4707 static HCRYPTOIDFUNCSET set = NULL;
4708 BOOL ret;
4709 ImportPublicKeyInfoExFunc importFunc = NULL;
4710 HCRYPTOIDFUNCADDR hFunc = NULL;
4711
4712 TRACE_(crypt)("(%08lx, %08x, %p, %08x, %08x, %p, %p)\n", hCryptProv,
4713 dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
4714
4715 if (!set)
4716 set = CryptInitOIDFunctionSet(CRYPT_OID_IMPORT_PUBLIC_KEY_INFO_FUNC, 0);
4717 CryptGetOIDFunctionAddress(set, dwCertEncodingType,
4718 pInfo->Algorithm.pszObjId, 0, (void **)&importFunc, &hFunc);
4719 if (!importFunc)
4720 importFunc = CRYPT_ImportRsaPublicKeyInfoEx;
4721 ret = importFunc(hCryptProv, dwCertEncodingType, pInfo, aiKeyAlg, dwFlags,
4722 pvAuxInfo, phKey);
4723 if (hFunc)
4724 CryptFreeOIDFunctionAddress(hFunc, 0);
4725 return ret;
4726 }