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