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