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