?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: New implementation of fcvt.
[wine/multimedia.git] / dlls / crypt32 / encode.c
blob1963eb7ae9306af53b2050f330007cf0da227459
1 /*
2 * Copyright 2005-2007 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 "wine/unicode.h"
47 #include "crypt32_private.h"
48
49 WINE_DEFAULT_DEBUG_CHANNEL(cryptasn);
50 WINE_DECLARE_DEBUG_CHANNEL(crypt);
51
52 typedef BOOL (WINAPI *CryptEncodeObjectFunc)(DWORD, LPCSTR, const void *,
53 BYTE *, DWORD *);
54
55 /* Prototypes for built-in encoders. They follow the Ex style prototypes.
56 * The dwCertEncodingType and lpszStructType are ignored by the built-in
57 * functions, but the parameters are retained to simplify CryptEncodeObjectEx,
58 * since it must call functions in external DLLs that follow these signatures.
59 */
60 BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
61 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
62 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
63 static BOOL WINAPI CRYPT_AsnEncodeExtensions(DWORD dwCertEncodingType,
64 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
65 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
66 static BOOL WINAPI CRYPT_AsnEncodeSequenceOfAny(DWORD dwCertEncodingType,
67 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
68 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
69 static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
70 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
71 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
72 static BOOL WINAPI CRYPT_AsnEncodePubKeyInfo(DWORD dwCertEncodingType,
73 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
74 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
75 static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType,
76 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
77 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
78 static BOOL WINAPI CRYPT_AsnEncodeBitsSwapBytes(DWORD dwCertEncodingType,
79 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
80 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
81 static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType,
82 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
83 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
84 static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType,
85 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
86 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
87 static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType,
88 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
89 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
90 static BOOL WINAPI CRYPT_AsnEncodeChoiceOfTime(DWORD dwCertEncodingType,
91 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
92 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
93
94 BOOL CRYPT_EncodeEnsureSpace(DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara,
95 BYTE *pbEncoded, DWORD *pcbEncoded, DWORD bytesNeeded)
96 {
97 BOOL ret = TRUE;
98
99 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
100 {
101 if (pEncodePara && pEncodePara->pfnAlloc)
102 *(BYTE **)pbEncoded = pEncodePara->pfnAlloc(bytesNeeded);
103 else
104 *(BYTE **)pbEncoded = LocalAlloc(0, bytesNeeded);
105 if (!*(BYTE **)pbEncoded)
106 ret = FALSE;
107 else
108 *pcbEncoded = bytesNeeded;
109 }
110 else if (bytesNeeded > *pcbEncoded)
111 {
112 *pcbEncoded = bytesNeeded;
113 SetLastError(ERROR_MORE_DATA);
114 ret = FALSE;
115 }
116 else
117 *pcbEncoded = bytesNeeded;
118 return ret;
119 }
120
121 BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded)
122 {
123 DWORD bytesNeeded, significantBytes = 0;
124
125 if (len <= 0x7f)
126 bytesNeeded = 1;
127 else
128 {
129 DWORD temp;
130
131 for (temp = len, significantBytes = sizeof(temp); !(temp & 0xff000000);
132 temp <<= 8, significantBytes--)
133 ;
134 bytesNeeded = significantBytes + 1;
135 }
136 if (!pbEncoded)
137 {
138 *pcbEncoded = bytesNeeded;
139 return TRUE;
140 }
141 if (*pcbEncoded < bytesNeeded)
142 {
143 SetLastError(ERROR_MORE_DATA);
144 return FALSE;
145 }
146 if (len <= 0x7f)
147 *pbEncoded = (BYTE)len;
148 else
149 {
150 DWORD i;
151
152 *pbEncoded++ = significantBytes | 0x80;
153 for (i = 0; i < significantBytes; i++)
154 {
155 *(pbEncoded + significantBytes - i - 1) = (BYTE)(len & 0xff);
156 len >>= 8;
157 }
158 }
159 *pcbEncoded = bytesNeeded;
160 return TRUE;
161 }
162
163 BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
164 struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags,
165 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
166 {
167 BOOL ret;
168 DWORD i, dataLen = 0;
169
170 TRACE("%p, %d, %08x, %p, %p, %d\n", items, cItem, dwFlags, pEncodePara,
171 pbEncoded, *pcbEncoded);
172 for (i = 0, ret = TRUE; ret && i < cItem; i++)
173 {
174 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
175 items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL,
176 NULL, &items[i].size);
177 /* Some functions propagate their errors through the size */
178 if (!ret)
179 *pcbEncoded = items[i].size;
180 dataLen += items[i].size;
181 }
182 if (ret)
183 {
184 DWORD lenBytes, bytesNeeded;
185
186 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
187 bytesNeeded = 1 + lenBytes + dataLen;
188 if (!pbEncoded)
189 *pcbEncoded = bytesNeeded;
190 else
191 {
192 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
193 pcbEncoded, bytesNeeded)))
194 {
195 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
196 pbEncoded = *(BYTE **)pbEncoded;
197 *pbEncoded++ = ASN_SEQUENCE;
198 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
199 pbEncoded += lenBytes;
200 for (i = 0; ret && i < cItem; i++)
201 {
202 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
203 items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG,
204 NULL, pbEncoded, &items[i].size);
205 /* Some functions propagate their errors through the size */
206 if (!ret)
207 *pcbEncoded = items[i].size;
208 pbEncoded += items[i].size;
209 }
210 }
211 }
212 }
213 TRACE("returning %d (%08x)\n", ret, GetLastError());
214 return ret;
215 }
216
217 BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType,
218 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
219 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
220 {
221 BOOL ret;
222 const struct AsnConstructedItem *item =
223 (const struct AsnConstructedItem *)pvStructInfo;
224 DWORD len;
225
226 if ((ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
227 item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &len)))
228 {
229 DWORD dataLen, bytesNeeded;
230
231 CRYPT_EncodeLen(len, NULL, &dataLen);
232 bytesNeeded = 1 + dataLen + len;
233 if (!pbEncoded)
234 *pcbEncoded = bytesNeeded;
235 else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
236 pbEncoded, pcbEncoded, bytesNeeded)))
237 {
238 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
239 pbEncoded = *(BYTE **)pbEncoded;
240 *pbEncoded++ = ASN_CONTEXT | ASN_CONSTRUCTOR | item->tag;
241 CRYPT_EncodeLen(len, pbEncoded, &dataLen);
242 pbEncoded += dataLen;
243 ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
244 item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL,
245 pbEncoded, &len);
246 if (!ret)
247 {
248 /* Some functions propagate their errors through the size */
249 *pcbEncoded = len;
250 }
251 }
252 }
253 else
254 {
255 /* Some functions propagate their errors through the size */
256 *pcbEncoded = len;
257 }
258 return ret;
259 }
260
261 struct AsnEncodeTagSwappedItem
262 {
263 BYTE tag;
264 const void *pvStructInfo;
265 CryptEncodeObjectExFunc encodeFunc;
266 };
267
268 /* Sort of a wacky hack, it encodes something using the struct
269 * AsnEncodeTagSwappedItem's encodeFunc, then replaces the tag byte with the tag
270 * given in the struct AsnEncodeTagSwappedItem.
271 */
272 static BOOL WINAPI CRYPT_AsnEncodeSwapTag(DWORD dwCertEncodingType,
273 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
274 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
275 {
276 BOOL ret;
277 const struct AsnEncodeTagSwappedItem *item =
278 (const struct AsnEncodeTagSwappedItem *)pvStructInfo;
279
280 ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
281 item->pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
282 if (ret && pbEncoded)
283 *pbEncoded = item->tag;
284 return ret;
285 }
286
287 static BOOL WINAPI CRYPT_AsnEncodeCertVersion(DWORD dwCertEncodingType,
288 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
289 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
290 {
291 const DWORD *ver = (const DWORD *)pvStructInfo;
292 BOOL ret;
293
294 /* CERT_V1 is not encoded */
295 if (*ver == CERT_V1)
296 {
297 *pcbEncoded = 0;
298 ret = TRUE;
299 }
300 else
301 {
302 struct AsnConstructedItem item = { 0, ver, CRYPT_AsnEncodeInt };
303
304 ret = CRYPT_AsnEncodeConstructed(dwCertEncodingType, X509_INTEGER,
305 &item, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
306 }
307 return ret;
308 }
309
310 static BOOL WINAPI CRYPT_CopyEncodedBlob(DWORD dwCertEncodingType,
311 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
312 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
313 {
314 const CRYPT_DER_BLOB *blob = (const CRYPT_DER_BLOB *)pvStructInfo;
315 BOOL ret;
316
317 if (!pbEncoded)
318 {
319 *pcbEncoded = blob->cbData;
320 ret = TRUE;
321 }
322 else
323 {
324 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
325 pcbEncoded, blob->cbData)))
326 {
327 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
328 pbEncoded = *(BYTE **)pbEncoded;
329 if (blob->cbData)
330 memcpy(pbEncoded, blob->pbData, blob->cbData);
331 *pcbEncoded = blob->cbData;
332 ret = TRUE;
333 }
334 }
335 return ret;
336 }
337
338 static BOOL WINAPI CRYPT_AsnEncodeValidity(DWORD dwCertEncodingType,
339 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
340 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
341 {
342 BOOL ret;
343 /* This has two filetimes in a row, a NotBefore and a NotAfter */
344 const FILETIME *timePtr = (const FILETIME *)pvStructInfo;
345 struct AsnEncodeSequenceItem items[] = {
346 { timePtr++, CRYPT_AsnEncodeChoiceOfTime, 0 },
347 { timePtr, CRYPT_AsnEncodeChoiceOfTime, 0 },
348 };
349
350 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
351 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
352 pcbEncoded);
353 return ret;
354 }
355
356 /* Like CRYPT_AsnEncodeAlgorithmId, but encodes parameters as an asn.1 NULL
357 * if they are empty.
358 */
359 static BOOL WINAPI CRYPT_AsnEncodeAlgorithmIdWithNullParams(
360 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
361 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
362 DWORD *pcbEncoded)
363 {
364 const CRYPT_ALGORITHM_IDENTIFIER *algo =
365 (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
366 static const BYTE asn1Null[] = { ASN_NULL, 0 };
367 static const CRYPT_DATA_BLOB nullBlob = { sizeof(asn1Null),
368 (LPBYTE)asn1Null };
369 BOOL ret;
370 struct AsnEncodeSequenceItem items[2] = {
371 { algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
372 { NULL, CRYPT_CopyEncodedBlob, 0 },
373 };
374
375 if (algo->Parameters.cbData)
376 items[1].pvStructInfo = &algo->Parameters;
377 else
378 items[1].pvStructInfo = &nullBlob;
379 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
380 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
381 pcbEncoded);
382 return ret;
383 }
384
385 static BOOL WINAPI CRYPT_AsnEncodeAlgorithmId(DWORD dwCertEncodingType,
386 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
387 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
388 {
389 const CRYPT_ALGORITHM_IDENTIFIER *algo =
390 (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
391 BOOL ret;
392 struct AsnEncodeSequenceItem items[] = {
393 { algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
394 { &algo->Parameters, CRYPT_CopyEncodedBlob, 0 },
395 };
396
397 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
398 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
399 pcbEncoded);
400 return ret;
401 }
402
403 static BOOL WINAPI CRYPT_AsnEncodePubKeyInfo(DWORD dwCertEncodingType,
404 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
405 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
406 {
407 BOOL ret;
408
409 __TRY
410 {
411 const CERT_PUBLIC_KEY_INFO *info =
412 (const CERT_PUBLIC_KEY_INFO *)pvStructInfo;
413 struct AsnEncodeSequenceItem items[] = {
414 { &info->Algorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
415 { &info->PublicKey, CRYPT_AsnEncodeBits, 0 },
416 };
417
418 TRACE("Encoding public key with OID %s\n",
419 debugstr_a(info->Algorithm.pszObjId));
420 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
421 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
422 pcbEncoded);
423 }
424 __EXCEPT_PAGE_FAULT
425 {
426 SetLastError(STATUS_ACCESS_VIOLATION);
427 ret = FALSE;
428 }
429 __ENDTRY
430 return ret;
431 }
432
433 static BOOL WINAPI CRYPT_AsnEncodeCert(DWORD dwCertEncodingType,
434 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
435 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
436 {
437 BOOL ret;
438
439 __TRY
440 {
441 const CERT_SIGNED_CONTENT_INFO *info =
442 (const CERT_SIGNED_CONTENT_INFO *)pvStructInfo;
443 struct AsnEncodeSequenceItem items[] = {
444 { &info->ToBeSigned, CRYPT_CopyEncodedBlob, 0 },
445 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
446 { &info->Signature, CRYPT_AsnEncodeBitsSwapBytes, 0 },
447 };
448
449 if (dwFlags & CRYPT_ENCODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG)
450 items[2].encodeFunc = CRYPT_AsnEncodeBits;
451 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
452 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
453 pcbEncoded);
454 }
455 __EXCEPT_PAGE_FAULT
456 {
457 SetLastError(STATUS_ACCESS_VIOLATION);
458 ret = FALSE;
459 }
460 __ENDTRY
461 return ret;
462 }
463
464 /* Like in Windows, this blithely ignores the validity of the passed-in
465 * CERT_INFO, and just encodes it as-is. The resulting encoded data may not
466 * decode properly, see CRYPT_AsnDecodeCertInfo.
467 */
468 static BOOL WINAPI CRYPT_AsnEncodeCertInfo(DWORD dwCertEncodingType,
469 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
470 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
471 {
472 BOOL ret;
473
474 __TRY
475 {
476 const CERT_INFO *info = (const CERT_INFO *)pvStructInfo;
477 struct AsnEncodeSequenceItem items[10] = {
478 { &info->dwVersion, CRYPT_AsnEncodeCertVersion, 0 },
479 { &info->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
480 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
481 { &info->Issuer, CRYPT_CopyEncodedBlob, 0 },
482 { &info->NotBefore, CRYPT_AsnEncodeValidity, 0 },
483 { &info->Subject, CRYPT_CopyEncodedBlob, 0 },
484 { &info->SubjectPublicKeyInfo, CRYPT_AsnEncodePubKeyInfo, 0 },
485 { 0 }
486 };
487 struct AsnConstructedItem constructed[3] = { { 0 } };
488 DWORD cItem = 7, cConstructed = 0;
489
490 if (info->IssuerUniqueId.cbData)
491 {
492 constructed[cConstructed].tag = 1;
493 constructed[cConstructed].pvStructInfo = &info->IssuerUniqueId;
494 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeBits;
495 items[cItem].pvStructInfo = &constructed[cConstructed];
496 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
497 cConstructed++;
498 cItem++;
499 }
500 if (info->SubjectUniqueId.cbData)
501 {
502 constructed[cConstructed].tag = 2;
503 constructed[cConstructed].pvStructInfo = &info->SubjectUniqueId;
504 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeBits;
505 items[cItem].pvStructInfo = &constructed[cConstructed];
506 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
507 cConstructed++;
508 cItem++;
509 }
510 if (info->cExtension)
511 {
512 constructed[cConstructed].tag = 3;
513 constructed[cConstructed].pvStructInfo = &info->cExtension;
514 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeExtensions;
515 items[cItem].pvStructInfo = &constructed[cConstructed];
516 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
517 cConstructed++;
518 cItem++;
519 }
520
521 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
522 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
523 }
524 __EXCEPT_PAGE_FAULT
525 {
526 SetLastError(STATUS_ACCESS_VIOLATION);
527 ret = FALSE;
528 }
529 __ENDTRY
530 return ret;
531 }
532
533 static BOOL WINAPI CRYPT_AsnEncodeCRLEntry(const CRL_ENTRY *entry,
534 BYTE *pbEncoded, DWORD *pcbEncoded)
535 {
536 struct AsnEncodeSequenceItem items[3] = {
537 { &entry->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
538 { &entry->RevocationDate, CRYPT_AsnEncodeChoiceOfTime, 0 },
539 { 0 }
540 };
541 DWORD cItem = 2;
542 BOOL ret;
543
544 TRACE("%p, %p, %p\n", entry, pbEncoded, pcbEncoded);
545
546 if (entry->cExtension)
547 {
548 items[cItem].pvStructInfo = &entry->cExtension;
549 items[cItem].encodeFunc = CRYPT_AsnEncodeExtensions;
550 cItem++;
551 }
552
553 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
554 pbEncoded, pcbEncoded);
555
556 TRACE("returning %d (%08x)\n", ret, GetLastError());
557 return ret;
558 }
559
560 static BOOL WINAPI CRYPT_AsnEncodeCRLEntries(DWORD dwCertEncodingType,
561 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
562 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
563 {
564 DWORD cCRLEntry = *(const DWORD *)pvStructInfo;
565 DWORD bytesNeeded, dataLen, lenBytes, i;
566 const CRL_ENTRY *rgCRLEntry = *(const CRL_ENTRY *const *)
567 ((const BYTE *)pvStructInfo + sizeof(DWORD));
568 BOOL ret = TRUE;
569
570 for (i = 0, dataLen = 0; ret && i < cCRLEntry; i++)
571 {
572 DWORD size;
573
574 ret = CRYPT_AsnEncodeCRLEntry(&rgCRLEntry[i], NULL, &size);
575 if (ret)
576 dataLen += size;
577 }
578 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
579 bytesNeeded = 1 + lenBytes + dataLen;
580 if (!pbEncoded)
581 *pcbEncoded = bytesNeeded;
582 else
583 {
584 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
585 pcbEncoded, bytesNeeded)))
586 {
587 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
588 pbEncoded = *(BYTE **)pbEncoded;
589 *pbEncoded++ = ASN_SEQUENCEOF;
590 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
591 pbEncoded += lenBytes;
592 for (i = 0; i < cCRLEntry; i++)
593 {
594 DWORD size = dataLen;
595
596 ret = CRYPT_AsnEncodeCRLEntry(&rgCRLEntry[i], pbEncoded, &size);
597 pbEncoded += size;
598 dataLen -= size;
599 }
600 }
601 }
602 return ret;
603 }
604
605 static BOOL WINAPI CRYPT_AsnEncodeCRLVersion(DWORD dwCertEncodingType,
606 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
607 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
608 {
609 const DWORD *ver = (const DWORD *)pvStructInfo;
610 BOOL ret;
611
612 /* CRL_V1 is not encoded */
613 if (*ver == CRL_V1)
614 {
615 *pcbEncoded = 0;
616 ret = TRUE;
617 }
618 else
619 ret = CRYPT_AsnEncodeInt(dwCertEncodingType, X509_INTEGER, ver,
620 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
621 return ret;
622 }
623
624 /* Like in Windows, this blithely ignores the validity of the passed-in
625 * CRL_INFO, and just encodes it as-is. The resulting encoded data may not
626 * decode properly, see CRYPT_AsnDecodeCRLInfo.
627 */
628 static BOOL WINAPI CRYPT_AsnEncodeCRLInfo(DWORD dwCertEncodingType,
629 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
630 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
631 {
632 BOOL ret;
633
634 __TRY
635 {
636 const CRL_INFO *info = (const CRL_INFO *)pvStructInfo;
637 struct AsnEncodeSequenceItem items[7] = {
638 { &info->dwVersion, CRYPT_AsnEncodeCRLVersion, 0 },
639 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
640 { &info->Issuer, CRYPT_CopyEncodedBlob, 0 },
641 { &info->ThisUpdate, CRYPT_AsnEncodeChoiceOfTime, 0 },
642 { 0 }
643 };
644 struct AsnConstructedItem constructed[1] = { { 0 } };
645 DWORD cItem = 4, cConstructed = 0;
646
647 if (info->NextUpdate.dwLowDateTime || info->NextUpdate.dwHighDateTime)
648 {
649 items[cItem].pvStructInfo = &info->NextUpdate;
650 items[cItem].encodeFunc = CRYPT_AsnEncodeChoiceOfTime;
651 cItem++;
652 }
653 if (info->cCRLEntry)
654 {
655 items[cItem].pvStructInfo = &info->cCRLEntry;
656 items[cItem].encodeFunc = CRYPT_AsnEncodeCRLEntries;
657 cItem++;
658 }
659 if (info->cExtension)
660 {
661 constructed[cConstructed].tag = 0;
662 constructed[cConstructed].pvStructInfo = &info->cExtension;
663 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeExtensions;
664 items[cItem].pvStructInfo = &constructed[cConstructed];
665 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
666 cConstructed++;
667 cItem++;
668 }
669
670 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
671 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
672 }
673 __EXCEPT_PAGE_FAULT
674 {
675 SetLastError(STATUS_ACCESS_VIOLATION);
676 ret = FALSE;
677 }
678 __ENDTRY
679 return ret;
680 }
681
682 static BOOL CRYPT_AsnEncodeExtension(CERT_EXTENSION *ext, BYTE *pbEncoded,
683 DWORD *pcbEncoded)
684 {
685 BOOL ret;
686 struct AsnEncodeSequenceItem items[3] = {
687 { ext->pszObjId, CRYPT_AsnEncodeOid, 0 },
688 { NULL, NULL, 0 },
689 { NULL, NULL, 0 },
690 };
691 DWORD cItem = 1;
692
693 TRACE("%p, %p, %d\n", ext, pbEncoded, *pcbEncoded);
694
695 if (ext->fCritical)
696 {
697 items[cItem].pvStructInfo = &ext->fCritical;
698 items[cItem].encodeFunc = CRYPT_AsnEncodeBool;
699 cItem++;
700 }
701 items[cItem].pvStructInfo = &ext->Value;
702 items[cItem].encodeFunc = CRYPT_AsnEncodeOctets;
703 cItem++;
704
705 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
706 pbEncoded, pcbEncoded);
707 TRACE("returning %d (%08x)\n", ret, GetLastError());
708 return ret;
709 }
710
711 static BOOL WINAPI CRYPT_AsnEncodeExtensions(DWORD dwCertEncodingType,
712 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
713 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
714 {
715 BOOL ret;
716
717 __TRY
718 {
719 DWORD bytesNeeded, dataLen, lenBytes, i;
720 const CERT_EXTENSIONS *exts = (const CERT_EXTENSIONS *)pvStructInfo;
721
722 ret = TRUE;
723 for (i = 0, dataLen = 0; ret && i < exts->cExtension; i++)
724 {
725 DWORD size;
726
727 ret = CRYPT_AsnEncodeExtension(&exts->rgExtension[i], NULL, &size);
728 if (ret)
729 dataLen += size;
730 }
731 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
732 bytesNeeded = 1 + lenBytes + dataLen;
733 if (!pbEncoded)
734 *pcbEncoded = bytesNeeded;
735 else
736 {
737 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
738 pcbEncoded, bytesNeeded)))
739 {
740 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
741 pbEncoded = *(BYTE **)pbEncoded;
742 *pbEncoded++ = ASN_SEQUENCEOF;
743 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
744 pbEncoded += lenBytes;
745 for (i = 0; i < exts->cExtension; i++)
746 {
747 DWORD size = dataLen;
748
749 ret = CRYPT_AsnEncodeExtension(&exts->rgExtension[i],
750 pbEncoded, &size);
751 pbEncoded += size;
752 dataLen -= size;
753 }
754 }
755 }
756 }
757 __EXCEPT_PAGE_FAULT
758 {
759 SetLastError(STATUS_ACCESS_VIOLATION);
760 ret = FALSE;
761 }
762 __ENDTRY
763 return ret;
764 }
765
766 BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
767 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
768 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
769 {
770 LPCSTR pszObjId = (LPCSTR)pvStructInfo;
771 DWORD bytesNeeded = 0, lenBytes;
772 BOOL ret = TRUE;
773 int firstPos = 0;
774 BYTE firstByte = 0;
775
776 TRACE("%s\n", debugstr_a(pszObjId));
777
778 if (pszObjId)
779 {
780 const char *ptr;
781 int val1, val2;
782
783 if (sscanf(pszObjId, "%d.%d.%n", &val1, &val2, &firstPos) != 2)
784 {
785 SetLastError(CRYPT_E_ASN1_ERROR);
786 return FALSE;
787 }
788 bytesNeeded++;
789 firstByte = val1 * 40 + val2;
790 ptr = pszObjId + firstPos;
791 while (ret && *ptr)
792 {
793 int pos;
794
795 /* note I assume each component is at most 32-bits long in base 2 */
796 if (sscanf(ptr, "%d%n", &val1, &pos) == 1)
797 {
798 if (val1 >= 0x10000000)
799 bytesNeeded += 5;
800 else if (val1 >= 0x200000)
801 bytesNeeded += 4;
802 else if (val1 >= 0x4000)
803 bytesNeeded += 3;
804 else if (val1 >= 0x80)
805 bytesNeeded += 2;
806 else
807 bytesNeeded += 1;
808 ptr += pos;
809 if (*ptr == '.')
810 ptr++;
811 }
812 else
813 {
814 SetLastError(CRYPT_E_ASN1_ERROR);
815 return FALSE;
816 }
817 }
818 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
819 }
820 else
821 lenBytes = 1;
822 bytesNeeded += 1 + lenBytes;
823 if (pbEncoded)
824 {
825 if (*pcbEncoded < bytesNeeded)
826 {
827 SetLastError(ERROR_MORE_DATA);
828 ret = FALSE;
829 }
830 else
831 {
832 *pbEncoded++ = ASN_OBJECTIDENTIFIER;
833 CRYPT_EncodeLen(bytesNeeded - 1 - lenBytes, pbEncoded, &lenBytes);
834 pbEncoded += lenBytes;
835 if (pszObjId)
836 {
837 const char *ptr;
838 int val, pos;
839
840 *pbEncoded++ = firstByte;
841 ptr = pszObjId + firstPos;
842 while (ret && *ptr)
843 {
844 sscanf(ptr, "%d%n", &val, &pos);
845 {
846 unsigned char outBytes[5];
847 int numBytes, i;
848
849 if (val >= 0x10000000)
850 numBytes = 5;
851 else if (val >= 0x200000)
852 numBytes = 4;
853 else if (val >= 0x4000)
854 numBytes = 3;
855 else if (val >= 0x80)
856 numBytes = 2;
857 else
858 numBytes = 1;
859 for (i = numBytes; i > 0; i--)
860 {
861 outBytes[i - 1] = val & 0x7f;
862 val >>= 7;
863 }
864 for (i = 0; i < numBytes - 1; i++)
865 *pbEncoded++ = outBytes[i] | 0x80;
866 *pbEncoded++ = outBytes[i];
867 ptr += pos;
868 if (*ptr == '.')
869 ptr++;
870 }
871 }
872 }
873 }
874 }
875 *pcbEncoded = bytesNeeded;
876 return ret;
877 }
878
879 static BOOL CRYPT_AsnEncodeStringCoerce(const CERT_NAME_VALUE *value,
880 BYTE tag, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
881 DWORD *pcbEncoded)
882 {
883 BOOL ret = TRUE;
884 LPCSTR str = (LPCSTR)value->Value.pbData;
885 DWORD bytesNeeded, lenBytes, encodedLen;
886
887 encodedLen = value->Value.cbData ? value->Value.cbData : lstrlenA(str);
888 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
889 bytesNeeded = 1 + lenBytes + encodedLen;
890 if (!pbEncoded)
891 *pcbEncoded = bytesNeeded;
892 else
893 {
894 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
895 pbEncoded, pcbEncoded, bytesNeeded)))
896 {
897 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
898 pbEncoded = *(BYTE **)pbEncoded;
899 *pbEncoded++ = tag;
900 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
901 pbEncoded += lenBytes;
902 memcpy(pbEncoded, str, encodedLen);
903 }
904 }
905 return ret;
906 }
907
908 static BOOL CRYPT_AsnEncodeBMPString(const CERT_NAME_VALUE *value,
909 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
910 DWORD *pcbEncoded)
911 {
912 BOOL ret = TRUE;
913 LPCWSTR str = (LPCWSTR)value->Value.pbData;
914 DWORD bytesNeeded, lenBytes, strLen;
915
916 strLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
917 lstrlenW(str);
918 CRYPT_EncodeLen(strLen * 2, NULL, &lenBytes);
919 bytesNeeded = 1 + lenBytes + strLen * 2;
920 if (!pbEncoded)
921 *pcbEncoded = bytesNeeded;
922 else
923 {
924 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
925 pbEncoded, pcbEncoded, bytesNeeded)))
926 {
927 DWORD i;
928
929 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
930 pbEncoded = *(BYTE **)pbEncoded;
931 *pbEncoded++ = ASN_BMPSTRING;
932 CRYPT_EncodeLen(strLen * 2, pbEncoded, &lenBytes);
933 pbEncoded += lenBytes;
934 for (i = 0; i < strLen; i++)
935 {
936 *pbEncoded++ = (str[i] & 0xff00) >> 8;
937 *pbEncoded++ = str[i] & 0x00ff;
938 }
939 }
940 }
941 return ret;
942 }
943
944 static BOOL CRYPT_AsnEncodeUTF8String(const CERT_NAME_VALUE *value,
945 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
946 DWORD *pcbEncoded)
947 {
948 BOOL ret = TRUE;
949 LPCWSTR str = (LPCWSTR)value->Value.pbData;
950 DWORD bytesNeeded, lenBytes, encodedLen, strLen;
951
952 strLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
953 lstrlenW(str);
954 encodedLen = WideCharToMultiByte(CP_UTF8, 0, str, strLen, NULL, 0, NULL,
955 NULL);
956 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
957 bytesNeeded = 1 + lenBytes + encodedLen;
958 if (!pbEncoded)
959 *pcbEncoded = bytesNeeded;
960 else
961 {
962 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
963 pbEncoded, pcbEncoded, bytesNeeded)))
964 {
965 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
966 pbEncoded = *(BYTE **)pbEncoded;
967 *pbEncoded++ = ASN_UTF8STRING;
968 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
969 pbEncoded += lenBytes;
970 WideCharToMultiByte(CP_UTF8, 0, str, strLen, (LPSTR)pbEncoded,
971 bytesNeeded - lenBytes - 1, NULL, NULL);
972 }
973 }
974 return ret;
975 }
976
977 static BOOL WINAPI CRYPT_AsnEncodeNameValue(DWORD dwCertEncodingType,
978 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
979 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
980 {
981 BOOL ret = TRUE;
982
983 __TRY
984 {
985 const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
986
987 switch (value->dwValueType)
988 {
989 case CERT_RDN_ANY_TYPE:
990 /* explicitly disallowed */
991 SetLastError(E_INVALIDARG);
992 ret = FALSE;
993 break;
994 case CERT_RDN_ENCODED_BLOB:
995 ret = CRYPT_CopyEncodedBlob(dwCertEncodingType, NULL,
996 &value->Value, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
997 break;
998 case CERT_RDN_OCTET_STRING:
999 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_OCTETSTRING,
1000 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1001 break;
1002 case CERT_RDN_NUMERIC_STRING:
1003 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_NUMERICSTRING,
1004 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1005 break;
1006 case CERT_RDN_PRINTABLE_STRING:
1007 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_PRINTABLESTRING,
1008 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1009 break;
1010 case CERT_RDN_TELETEX_STRING:
1011 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_T61STRING,
1012 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1013 break;
1014 case CERT_RDN_VIDEOTEX_STRING:
1015 ret = CRYPT_AsnEncodeStringCoerce(value,
1016 ASN_VIDEOTEXSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1017 break;
1018 case CERT_RDN_IA5_STRING:
1019 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_IA5STRING,
1020 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1021 break;
1022 case CERT_RDN_GRAPHIC_STRING:
1023 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_GRAPHICSTRING,
1024 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1025 break;
1026 case CERT_RDN_VISIBLE_STRING:
1027 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_VISIBLESTRING,
1028 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1029 break;
1030 case CERT_RDN_GENERAL_STRING:
1031 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_GENERALSTRING,
1032 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1033 break;
1034 case CERT_RDN_UNIVERSAL_STRING:
1035 FIXME("CERT_RDN_UNIVERSAL_STRING: unimplemented\n");
1036 SetLastError(CRYPT_E_ASN1_CHOICE);
1037 ret = FALSE;
1038 break;
1039 case CERT_RDN_BMP_STRING:
1040 ret = CRYPT_AsnEncodeBMPString(value, dwFlags, pEncodePara,
1041 pbEncoded, pcbEncoded);
1042 break;
1043 case CERT_RDN_UTF8_STRING:
1044 ret = CRYPT_AsnEncodeUTF8String(value, dwFlags, pEncodePara,
1045 pbEncoded, pcbEncoded);
1046 break;
1047 default:
1048 SetLastError(CRYPT_E_ASN1_CHOICE);
1049 ret = FALSE;
1050 }
1051 }
1052 __EXCEPT_PAGE_FAULT
1053 {
1054 SetLastError(STATUS_ACCESS_VIOLATION);
1055 ret = FALSE;
1056 }
1057 __ENDTRY
1058 return ret;
1059 }
1060
1061 static BOOL WINAPI CRYPT_AsnEncodeRdnAttr(DWORD dwCertEncodingType,
1062 CERT_RDN_ATTR *attr, CryptEncodeObjectExFunc nameValueEncodeFunc,
1063 BYTE *pbEncoded, DWORD *pcbEncoded)
1064 {
1065 DWORD bytesNeeded = 0, lenBytes, size;
1066 BOOL ret;
1067
1068 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL, attr->pszObjId,
1069 0, NULL, NULL, &size);
1070 if (ret)
1071 {
1072 bytesNeeded += size;
1073 /* hack: a CERT_RDN_ATTR is identical to a CERT_NAME_VALUE beginning
1074 * with dwValueType, so "cast" it to get its encoded size
1075 */
1076 ret = nameValueEncodeFunc(dwCertEncodingType, NULL,
1077 (CERT_NAME_VALUE *)&attr->dwValueType, 0, NULL, NULL, &size);
1078 if (ret)
1079 {
1080 bytesNeeded += size;
1081 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1082 bytesNeeded += 1 + lenBytes;
1083 if (pbEncoded)
1084 {
1085 if (*pcbEncoded < bytesNeeded)
1086 {
1087 SetLastError(ERROR_MORE_DATA);
1088 ret = FALSE;
1089 }
1090 else
1091 {
1092 *pbEncoded++ = ASN_SEQUENCE;
1093 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
1094 &lenBytes);
1095 pbEncoded += lenBytes;
1096 size = bytesNeeded - 1 - lenBytes;
1097 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
1098 attr->pszObjId, 0, NULL, pbEncoded, &size);
1099 if (ret)
1100 {
1101 pbEncoded += size;
1102 size = bytesNeeded - 1 - lenBytes - size;
1103 ret = nameValueEncodeFunc(dwCertEncodingType,
1104 NULL, (CERT_NAME_VALUE *)&attr->dwValueType,
1105 0, NULL, pbEncoded, &size);
1106 if (!ret)
1107 *pcbEncoded = size;
1108 }
1109 }
1110 }
1111 if (ret)
1112 *pcbEncoded = bytesNeeded;
1113 }
1114 else
1115 {
1116 /* Have to propagate index of failing character */
1117 *pcbEncoded = size;
1118 }
1119 }
1120 return ret;
1121 }
1122
1123 static int BLOBComp(const void *l, const void *r)
1124 {
1125 const CRYPT_DER_BLOB *a = (const CRYPT_DER_BLOB *)l, *b = (const CRYPT_DER_BLOB *)r;
1126 int ret;
1127
1128 if (!(ret = memcmp(a->pbData, b->pbData, min(a->cbData, b->cbData))))
1129 ret = a->cbData - b->cbData;
1130 return ret;
1131 }
1132
1133 typedef struct _CRYPT_SET_OF {
1134 DWORD cValue;
1135 PCRYPT_DER_BLOB rgValue;
1136 } CRYPT_SET_OF;
1137
1138 /* This encodes a SET OF, which in DER must be lexicographically sorted.
1139 */
1140 static BOOL WINAPI CRYPT_DEREncodeSet(DWORD dwCertEncodingType,
1141 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1142 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1143 {
1144 const CRYPT_SET_OF *set = (const CRYPT_SET_OF *)pvStructInfo;
1145 DWORD bytesNeeded = 0, lenBytes, i;
1146 BOOL ret;
1147
1148 for (i = 0; i < set->cValue; i++)
1149 bytesNeeded += set->rgValue[i].cbData;
1150 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1151 bytesNeeded += 1 + lenBytes;
1152 if (!pbEncoded)
1153 {
1154 *pcbEncoded = bytesNeeded;
1155 ret = TRUE;
1156 }
1157 else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1158 pbEncoded, pcbEncoded, bytesNeeded)))
1159 {
1160 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1161 pbEncoded = *(BYTE **)pbEncoded;
1162 qsort(set->rgValue, set->cValue, sizeof(CRYPT_DER_BLOB), BLOBComp);
1163 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_SETOF;
1164 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded, &lenBytes);
1165 pbEncoded += lenBytes;
1166 for (i = 0; ret && i < set->cValue; i++)
1167 {
1168 memcpy(pbEncoded, set->rgValue[i].pbData, set->rgValue[i].cbData);
1169 pbEncoded += set->rgValue[i].cbData;
1170 }
1171 }
1172 return ret;
1173 }
1174
1175 struct DERSetDescriptor
1176 {
1177 DWORD cItems;
1178 const void *items;
1179 size_t itemSize;
1180 size_t itemOffset;
1181 CryptEncodeObjectExFunc encode;
1182 };
1183
1184 static BOOL WINAPI CRYPT_DEREncodeItemsAsSet(DWORD dwCertEncodingType,
1185 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1186 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1187 {
1188 const struct DERSetDescriptor *desc =
1189 (const struct DERSetDescriptor *)pvStructInfo;
1190 CRYPT_SET_OF setOf = { 0, NULL };
1191 BOOL ret = TRUE;
1192 DWORD i;
1193
1194 if (desc->cItems)
1195 {
1196 setOf.rgValue = CryptMemAlloc(desc->cItems * sizeof(CRYPT_DER_BLOB));
1197 if (!setOf.rgValue)
1198 ret = FALSE;
1199 else
1200 {
1201 setOf.cValue = desc->cItems;
1202 memset(setOf.rgValue, 0, setOf.cValue * sizeof(CRYPT_DER_BLOB));
1203 }
1204 }
1205 for (i = 0; ret && i < setOf.cValue; i++)
1206 {
1207 ret = desc->encode(dwCertEncodingType, lpszStructType,
1208 (const BYTE *)desc->items + i * desc->itemSize + desc->itemOffset,
1209 0, NULL, NULL, &setOf.rgValue[i].cbData);
1210 if (ret)
1211 {
1212 setOf.rgValue[i].pbData = CryptMemAlloc(setOf.rgValue[i].cbData);
1213 if (!setOf.rgValue[i].pbData)
1214 ret = FALSE;
1215 else
1216 ret = desc->encode(dwCertEncodingType, lpszStructType,
1217 (const BYTE *)desc->items + i * desc->itemSize +
1218 desc->itemOffset, 0, NULL, setOf.rgValue[i].pbData,
1219 &setOf.rgValue[i].cbData);
1220 }
1221 /* Some functions propagate their errors through the size */
1222 if (!ret)
1223 *pcbEncoded = setOf.rgValue[i].cbData;
1224 }
1225 if (ret)
1226 {
1227 DWORD bytesNeeded = 0, lenBytes;
1228 BOOL ret;
1229
1230 for (i = 0; i < setOf.cValue; i++)
1231 bytesNeeded += setOf.rgValue[i].cbData;
1232 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1233 bytesNeeded += 1 + lenBytes;
1234 if (!pbEncoded)
1235 *pcbEncoded = bytesNeeded;
1236 else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1237 pbEncoded, pcbEncoded, bytesNeeded)))
1238 {
1239 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1240 pbEncoded = *(BYTE **)pbEncoded;
1241 qsort(setOf.rgValue, setOf.cValue, sizeof(CRYPT_DER_BLOB),
1242 BLOBComp);
1243 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_SETOF;
1244 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded, &lenBytes);
1245 pbEncoded += lenBytes;
1246 for (i = 0; i < setOf.cValue; i++)
1247 {
1248 memcpy(pbEncoded, setOf.rgValue[i].pbData,
1249 setOf.rgValue[i].cbData);
1250 pbEncoded += setOf.rgValue[i].cbData;
1251 }
1252 }
1253 }
1254 for (i = 0; i < setOf.cValue; i++)
1255 CryptMemFree(setOf.rgValue[i].pbData);
1256 CryptMemFree(setOf.rgValue);
1257 return ret;
1258 }
1259
1260 static BOOL WINAPI CRYPT_AsnEncodeRdn(DWORD dwCertEncodingType, CERT_RDN *rdn,
1261 CryptEncodeObjectExFunc nameValueEncodeFunc, BYTE *pbEncoded,
1262 DWORD *pcbEncoded)
1263 {
1264 BOOL ret;
1265 CRYPT_SET_OF setOf = { 0, NULL };
1266
1267 __TRY
1268 {
1269 DWORD i;
1270
1271 ret = TRUE;
1272 if (rdn->cRDNAttr)
1273 {
1274 setOf.cValue = rdn->cRDNAttr;
1275 setOf.rgValue = CryptMemAlloc(rdn->cRDNAttr *
1276 sizeof(CRYPT_DER_BLOB));
1277 if (!setOf.rgValue)
1278 ret = FALSE;
1279 else
1280 memset(setOf.rgValue, 0, setOf.cValue * sizeof(CRYPT_DER_BLOB));
1281 }
1282 for (i = 0; ret && i < rdn->cRDNAttr; i++)
1283 {
1284 setOf.rgValue[i].cbData = 0;
1285 ret = CRYPT_AsnEncodeRdnAttr(dwCertEncodingType, &rdn->rgRDNAttr[i],
1286 nameValueEncodeFunc, NULL, &setOf.rgValue[i].cbData);
1287 if (ret)
1288 {
1289 setOf.rgValue[i].pbData =
1290 CryptMemAlloc(setOf.rgValue[i].cbData);
1291 if (!setOf.rgValue[i].pbData)
1292 ret = FALSE;
1293 else
1294 ret = CRYPT_AsnEncodeRdnAttr(dwCertEncodingType,
1295 &rdn->rgRDNAttr[i], nameValueEncodeFunc,
1296 setOf.rgValue[i].pbData, &setOf.rgValue[i].cbData);
1297 }
1298 if (!ret)
1299 {
1300 /* Have to propagate index of failing character */
1301 *pcbEncoded = setOf.rgValue[i].cbData;
1302 }
1303 }
1304 if (ret)
1305 ret = CRYPT_DEREncodeSet(X509_ASN_ENCODING, NULL, &setOf, 0, NULL,
1306 pbEncoded, pcbEncoded);
1307 for (i = 0; i < setOf.cValue; i++)
1308 CryptMemFree(setOf.rgValue[i].pbData);
1309 }
1310 __EXCEPT_PAGE_FAULT
1311 {
1312 SetLastError(STATUS_ACCESS_VIOLATION);
1313 ret = FALSE;
1314 }
1315 __ENDTRY
1316 CryptMemFree(setOf.rgValue);
1317 return ret;
1318 }
1319
1320 static BOOL WINAPI CRYPT_AsnEncodeUnicodeNameValue(DWORD dwCertEncodingType,
1321 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1322 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
1323
1324 static BOOL WINAPI CRYPT_AsnEncodeOrCopyUnicodeNameValue(
1325 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
1326 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1327 DWORD *pcbEncoded)
1328 {
1329 const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
1330 BOOL ret;
1331
1332 if (value->dwValueType == CERT_RDN_ENCODED_BLOB)
1333 ret = CRYPT_CopyEncodedBlob(dwCertEncodingType, NULL, &value->Value,
1334 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1335 else
1336 ret = CRYPT_AsnEncodeUnicodeNameValue(dwCertEncodingType, NULL, value,
1337 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1338 return ret;
1339 }
1340
1341 static BOOL WINAPI CRYPT_AsnEncodeUnicodeName(DWORD dwCertEncodingType,
1342 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1343 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1344 {
1345 BOOL ret = TRUE;
1346
1347 __TRY
1348 {
1349 const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo;
1350 DWORD bytesNeeded = 0, lenBytes, size, i;
1351
1352 TRACE("encoding name with %d RDNs\n", info->cRDN);
1353 ret = TRUE;
1354 for (i = 0; ret && i < info->cRDN; i++)
1355 {
1356 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType, &info->rgRDN[i],
1357 CRYPT_AsnEncodeOrCopyUnicodeNameValue, NULL, &size);
1358 if (ret)
1359 bytesNeeded += size;
1360 else
1361 *pcbEncoded = size;
1362 }
1363 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1364 bytesNeeded += 1 + lenBytes;
1365 if (ret)
1366 {
1367 if (!pbEncoded)
1368 *pcbEncoded = bytesNeeded;
1369 else
1370 {
1371 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1372 pbEncoded, pcbEncoded, bytesNeeded)))
1373 {
1374 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1375 pbEncoded = *(BYTE **)pbEncoded;
1376 *pbEncoded++ = ASN_SEQUENCEOF;
1377 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
1378 &lenBytes);
1379 pbEncoded += lenBytes;
1380 for (i = 0; ret && i < info->cRDN; i++)
1381 {
1382 size = bytesNeeded;
1383 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType,
1384 &info->rgRDN[i], CRYPT_AsnEncodeOrCopyUnicodeNameValue,
1385 pbEncoded, &size);
1386 if (ret)
1387 {
1388 pbEncoded += size;
1389 bytesNeeded -= size;
1390 }
1391 else
1392 *pcbEncoded = size;
1393 }
1394 }
1395 }
1396 }
1397 }
1398 __EXCEPT_PAGE_FAULT
1399 {
1400 SetLastError(STATUS_ACCESS_VIOLATION);
1401 ret = FALSE;
1402 }
1403 __ENDTRY
1404 return ret;
1405 }
1406
1407 static BOOL WINAPI CRYPT_AsnEncodePKCSAttribute(DWORD dwCertEncodingType,
1408 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1409 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1410 {
1411 BOOL ret = FALSE;
1412
1413 __TRY
1414 {
1415 const CRYPT_ATTRIBUTE *attr = (const CRYPT_ATTRIBUTE *)pvStructInfo;
1416
1417 if (!attr->pszObjId)
1418 SetLastError(E_INVALIDARG);
1419 else
1420 {
1421 struct AsnEncodeSequenceItem items[2] = {
1422 { attr->pszObjId, CRYPT_AsnEncodeOid, 0 },
1423 { &attr->cValue, CRYPT_DEREncodeSet, 0 },
1424 };
1425
1426 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
1427 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
1428 pcbEncoded);
1429 }
1430 }
1431 __EXCEPT_PAGE_FAULT
1432 {
1433 SetLastError(STATUS_ACCESS_VIOLATION);
1434 }
1435 __ENDTRY
1436 return ret;
1437 }
1438
1439 static BOOL WINAPI CRYPT_AsnEncodePKCSAttributes(DWORD dwCertEncodingType,
1440 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1441 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1442 {
1443 BOOL ret = FALSE;
1444
1445 __TRY
1446 {
1447 const CRYPT_ATTRIBUTES *attributes =
1448 (const CRYPT_ATTRIBUTES *)pvStructInfo;
1449 struct DERSetDescriptor desc = { attributes->cAttr, attributes->rgAttr,
1450 sizeof(CRYPT_ATTRIBUTE), 0, CRYPT_AsnEncodePKCSAttribute };
1451
1452 ret = CRYPT_DEREncodeItemsAsSet(X509_ASN_ENCODING, lpszStructType,
1453 &desc, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1454 }
1455 __EXCEPT_PAGE_FAULT
1456 {
1457 SetLastError(STATUS_ACCESS_VIOLATION);
1458 }
1459 __ENDTRY
1460 return ret;
1461 }
1462
1463 /* Like CRYPT_AsnEncodePKCSContentInfo, but allows the OID to be NULL */
1464 static BOOL WINAPI CRYPT_AsnEncodePKCSContentInfoInternal(
1465 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
1466 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1467 DWORD *pcbEncoded)
1468 {
1469 const CRYPT_CONTENT_INFO *info = (const CRYPT_CONTENT_INFO *)pvStructInfo;
1470 struct AsnEncodeSequenceItem items[2] = {
1471 { info->pszObjId, CRYPT_AsnEncodeOid, 0 },
1472 { NULL, NULL, 0 },
1473 };
1474 struct AsnConstructedItem constructed = { 0 };
1475 DWORD cItem = 1;
1476
1477 if (info->Content.cbData)
1478 {
1479 constructed.tag = 0;
1480 constructed.pvStructInfo = &info->Content;
1481 constructed.encodeFunc = CRYPT_CopyEncodedBlob;
1482 items[cItem].pvStructInfo = &constructed;
1483 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
1484 cItem++;
1485 }
1486 return CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
1487 cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1488 }
1489
1490 BOOL CRYPT_AsnEncodePKCSDigestedData(CRYPT_DIGESTED_DATA *digestedData,
1491 void *pvData, DWORD *pcbData)
1492 {
1493 struct AsnEncodeSequenceItem items[] = {
1494 { &digestedData->version, CRYPT_AsnEncodeInt, 0 },
1495 { &digestedData->DigestAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams,
1496 0 },
1497 { &digestedData->ContentInfo, CRYPT_AsnEncodePKCSContentInfoInternal, 0 },
1498 { &digestedData->hash, CRYPT_AsnEncodeOctets, 0 },
1499 };
1500
1501 return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items,
1502 sizeof(items) / sizeof(items[0]), 0, NULL, pvData, pcbData);
1503 }
1504
1505 static BOOL WINAPI CRYPT_AsnEncodePKCSContentInfo(DWORD dwCertEncodingType,
1506 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1507 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1508 {
1509 BOOL ret = FALSE;
1510
1511 __TRY
1512 {
1513 const CRYPT_CONTENT_INFO *info =
1514 (const CRYPT_CONTENT_INFO *)pvStructInfo;
1515
1516 if (!info->pszObjId)
1517 SetLastError(E_INVALIDARG);
1518 else
1519 ret = CRYPT_AsnEncodePKCSContentInfoInternal(dwCertEncodingType,
1520 lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded,
1521 pcbEncoded);
1522 }
1523 __EXCEPT_PAGE_FAULT
1524 {
1525 SetLastError(STATUS_ACCESS_VIOLATION);
1526 }
1527 __ENDTRY
1528 return ret;
1529 }
1530
1531 static BOOL CRYPT_AsnEncodeUnicodeStringCoerce(const CERT_NAME_VALUE *value,
1532 BYTE tag, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1533 DWORD *pcbEncoded)
1534 {
1535 BOOL ret = TRUE;
1536 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1537 DWORD bytesNeeded, lenBytes, encodedLen;
1538
1539 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1540 lstrlenW(str);
1541 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
1542 bytesNeeded = 1 + lenBytes + encodedLen;
1543 if (!pbEncoded)
1544 *pcbEncoded = bytesNeeded;
1545 else
1546 {
1547 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1548 pbEncoded, pcbEncoded, bytesNeeded)))
1549 {
1550 DWORD i;
1551
1552 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1553 pbEncoded = *(BYTE **)pbEncoded;
1554 *pbEncoded++ = tag;
1555 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
1556 pbEncoded += lenBytes;
1557 for (i = 0; i < encodedLen; i++)
1558 *pbEncoded++ = (BYTE)str[i];
1559 }
1560 }
1561 return ret;
1562 }
1563
1564 static BOOL CRYPT_AsnEncodeNumericString(const CERT_NAME_VALUE *value,
1565 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1566 DWORD *pcbEncoded)
1567 {
1568 BOOL ret = TRUE;
1569 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1570 DWORD bytesNeeded, lenBytes, encodedLen;
1571
1572 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1573 lstrlenW(str);
1574 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
1575 bytesNeeded = 1 + lenBytes + encodedLen;
1576 if (!pbEncoded)
1577 *pcbEncoded = bytesNeeded;
1578 else
1579 {
1580 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1581 pbEncoded, pcbEncoded, bytesNeeded)))
1582 {
1583 DWORD i;
1584
1585 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1586 pbEncoded = *(BYTE **)pbEncoded;
1587 *pbEncoded++ = ASN_NUMERICSTRING;
1588 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
1589 pbEncoded += lenBytes;
1590 for (i = 0; ret && i < encodedLen; i++)
1591 {
1592 if (isdigitW(str[i]))
1593 *pbEncoded++ = (BYTE)str[i];
1594 else
1595 {
1596 *pcbEncoded = i;
1597 SetLastError(CRYPT_E_INVALID_NUMERIC_STRING);
1598 ret = FALSE;
1599 }
1600 }
1601 }
1602 }
1603 return ret;
1604 }
1605
1606 static inline int isprintableW(WCHAR wc)
1607 {
1608 return isalnumW(wc) || isspaceW(wc) || wc == '\'' || wc == '(' ||
1609 wc == ')' || wc == '+' || wc == ',' || wc == '-' || wc == '.' ||
1610 wc == '/' || wc == ':' || wc == '=' || wc == '?';
1611 }
1612
1613 static BOOL CRYPT_AsnEncodePrintableString(const CERT_NAME_VALUE *value,
1614 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1615 DWORD *pcbEncoded)
1616 {
1617 BOOL ret = TRUE;
1618 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1619 DWORD bytesNeeded, lenBytes, encodedLen;
1620
1621 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1622 lstrlenW(str);
1623 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
1624 bytesNeeded = 1 + lenBytes + encodedLen;
1625 if (!pbEncoded)
1626 *pcbEncoded = bytesNeeded;
1627 else
1628 {
1629 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1630 pbEncoded, pcbEncoded, bytesNeeded)))
1631 {
1632 DWORD i;
1633
1634 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1635 pbEncoded = *(BYTE **)pbEncoded;
1636 *pbEncoded++ = ASN_PRINTABLESTRING;
1637 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
1638 pbEncoded += lenBytes;
1639 for (i = 0; ret && i < encodedLen; i++)
1640 {
1641 if (isprintableW(str[i]))
1642 *pbEncoded++ = (BYTE)str[i];
1643 else
1644 {
1645 *pcbEncoded = i;
1646 SetLastError(CRYPT_E_INVALID_PRINTABLE_STRING);
1647 ret = FALSE;
1648 }
1649 }
1650 }
1651 }
1652 return ret;
1653 }
1654
1655 static BOOL CRYPT_AsnEncodeIA5String(const CERT_NAME_VALUE *value,
1656 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1657 DWORD *pcbEncoded)
1658 {
1659 BOOL ret = TRUE;
1660 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1661 DWORD bytesNeeded, lenBytes, encodedLen;
1662
1663 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1664 lstrlenW(str);
1665 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
1666 bytesNeeded = 1 + lenBytes + encodedLen;
1667 if (!pbEncoded)
1668 *pcbEncoded = bytesNeeded;
1669 else
1670 {
1671 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1672 pbEncoded, pcbEncoded, bytesNeeded)))
1673 {
1674 DWORD i;
1675
1676 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1677 pbEncoded = *(BYTE **)pbEncoded;
1678 *pbEncoded++ = ASN_IA5STRING;
1679 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
1680 pbEncoded += lenBytes;
1681 for (i = 0; ret && i < encodedLen; i++)
1682 {
1683 if (str[i] <= 0x7f)
1684 *pbEncoded++ = (BYTE)str[i];
1685 else
1686 {
1687 *pcbEncoded = i;
1688 SetLastError(CRYPT_E_INVALID_IA5_STRING);
1689 ret = FALSE;
1690 }
1691 }
1692 }
1693 }
1694 return ret;
1695 }
1696
1697 static BOOL CRYPT_AsnEncodeUniversalString(const CERT_NAME_VALUE *value,
1698 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1699 DWORD *pcbEncoded)
1700 {
1701 BOOL ret = TRUE;
1702 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1703 DWORD bytesNeeded, lenBytes, strLen;
1704
1705 /* FIXME: doesn't handle composite characters */
1706 strLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1707 lstrlenW(str);
1708 CRYPT_EncodeLen(strLen * 4, NULL, &lenBytes);
1709 bytesNeeded = 1 + lenBytes + strLen * 4;
1710 if (!pbEncoded)
1711 *pcbEncoded = bytesNeeded;
1712 else
1713 {
1714 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1715 pbEncoded, pcbEncoded, bytesNeeded)))
1716 {
1717 DWORD i;
1718
1719 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1720 pbEncoded = *(BYTE **)pbEncoded;
1721 *pbEncoded++ = ASN_UNIVERSALSTRING;
1722 CRYPT_EncodeLen(strLen * 4, pbEncoded, &lenBytes);
1723 pbEncoded += lenBytes;
1724 for (i = 0; i < strLen; i++)
1725 {
1726 *pbEncoded++ = 0;
1727 *pbEncoded++ = 0;
1728 *pbEncoded++ = (BYTE)((str[i] & 0xff00) >> 8);
1729 *pbEncoded++ = (BYTE)(str[i] & 0x00ff);
1730 }
1731 }
1732 }
1733 return ret;
1734 }
1735
1736 static BOOL WINAPI CRYPT_AsnEncodeUnicodeNameValue(DWORD dwCertEncodingType,
1737 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1738 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1739 {
1740 BOOL ret = FALSE;
1741
1742 __TRY
1743 {
1744 const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
1745
1746 switch (value->dwValueType)
1747 {
1748 case CERT_RDN_ANY_TYPE:
1749 case CERT_RDN_ENCODED_BLOB:
1750 case CERT_RDN_OCTET_STRING:
1751 SetLastError(CRYPT_E_NOT_CHAR_STRING);
1752 break;
1753 case CERT_RDN_NUMERIC_STRING:
1754 ret = CRYPT_AsnEncodeNumericString(value, dwFlags, pEncodePara,
1755 pbEncoded, pcbEncoded);
1756 break;
1757 case CERT_RDN_PRINTABLE_STRING:
1758 ret = CRYPT_AsnEncodePrintableString(value, dwFlags, pEncodePara,
1759 pbEncoded, pcbEncoded);
1760 break;
1761 case CERT_RDN_TELETEX_STRING:
1762 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_T61STRING,
1763 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1764 break;
1765 case CERT_RDN_VIDEOTEX_STRING:
1766 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value,
1767 ASN_VIDEOTEXSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1768 break;
1769 case CERT_RDN_IA5_STRING:
1770 ret = CRYPT_AsnEncodeIA5String(value, dwFlags, pEncodePara,
1771 pbEncoded, pcbEncoded);
1772 break;
1773 case CERT_RDN_GRAPHIC_STRING:
1774 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_GRAPHICSTRING,
1775 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1776 break;
1777 case CERT_RDN_VISIBLE_STRING:
1778 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_VISIBLESTRING,
1779 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1780 break;
1781 case CERT_RDN_GENERAL_STRING:
1782 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_GENERALSTRING,
1783 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1784 break;
1785 case CERT_RDN_UNIVERSAL_STRING:
1786 ret = CRYPT_AsnEncodeUniversalString(value, dwFlags, pEncodePara,
1787 pbEncoded, pcbEncoded);
1788 break;
1789 case CERT_RDN_BMP_STRING:
1790 ret = CRYPT_AsnEncodeBMPString(value, dwFlags, pEncodePara,
1791 pbEncoded, pcbEncoded);
1792 break;
1793 case CERT_RDN_UTF8_STRING:
1794 ret = CRYPT_AsnEncodeUTF8String(value, dwFlags, pEncodePara,
1795 pbEncoded, pcbEncoded);
1796 break;
1797 default:
1798 SetLastError(CRYPT_E_ASN1_CHOICE);
1799 }
1800 }
1801 __EXCEPT_PAGE_FAULT
1802 {
1803 SetLastError(STATUS_ACCESS_VIOLATION);
1804 }
1805 __ENDTRY
1806 return ret;
1807 }
1808
1809 static BOOL WINAPI CRYPT_AsnEncodeName(DWORD dwCertEncodingType,
1810 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1811 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1812 {
1813 BOOL ret;
1814
1815 __TRY
1816 {
1817 const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo;
1818 DWORD bytesNeeded = 0, lenBytes, size, i;
1819
1820 TRACE("encoding name with %d RDNs\n", info->cRDN);
1821 ret = TRUE;
1822 for (i = 0; ret && i < info->cRDN; i++)
1823 {
1824 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType, &info->rgRDN[i],
1825 CRYPT_AsnEncodeNameValue, NULL, &size);
1826 if (ret)
1827 bytesNeeded += size;
1828 }
1829 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1830 bytesNeeded += 1 + lenBytes;
1831 if (ret)
1832 {
1833 if (!pbEncoded)
1834 *pcbEncoded = bytesNeeded;
1835 else
1836 {
1837 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1838 pbEncoded, pcbEncoded, bytesNeeded)))
1839 {
1840 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1841 pbEncoded = *(BYTE **)pbEncoded;
1842 *pbEncoded++ = ASN_SEQUENCEOF;
1843 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
1844 &lenBytes);
1845 pbEncoded += lenBytes;
1846 for (i = 0; ret && i < info->cRDN; i++)
1847 {
1848 size = bytesNeeded;
1849 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType,
1850 &info->rgRDN[i], CRYPT_AsnEncodeNameValue, pbEncoded,
1851 &size);
1852 if (ret)
1853 {
1854 pbEncoded += size;
1855 bytesNeeded -= size;
1856 }
1857 }
1858 }
1859 }
1860 }
1861 }
1862 __EXCEPT_PAGE_FAULT
1863 {
1864 SetLastError(STATUS_ACCESS_VIOLATION);
1865 ret = FALSE;
1866 }
1867 __ENDTRY
1868 return ret;
1869 }
1870
1871 static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
1872 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1873 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1874 {
1875 BOOL val = *(const BOOL *)pvStructInfo, ret;
1876
1877 TRACE("%d\n", val);
1878
1879 if (!pbEncoded)
1880 {
1881 *pcbEncoded = 3;
1882 ret = TRUE;
1883 }
1884 else if (*pcbEncoded < 3)
1885 {
1886 *pcbEncoded = 3;
1887 SetLastError(ERROR_MORE_DATA);
1888 ret = FALSE;
1889 }
1890 else
1891 {
1892 *pcbEncoded = 3;
1893 *pbEncoded++ = ASN_BOOL;
1894 *pbEncoded++ = 1;
1895 *pbEncoded++ = val ? 0xff : 0;
1896 ret = TRUE;
1897 }
1898 TRACE("returning %d (%08x)\n", ret, GetLastError());
1899 return ret;
1900 }
1901
1902 static BOOL CRYPT_AsnEncodeAltNameEntry(const CERT_ALT_NAME_ENTRY *entry,
1903 BYTE *pbEncoded, DWORD *pcbEncoded)
1904 {
1905 BOOL ret;
1906 DWORD dataLen;
1907 BYTE tag;
1908
1909 ret = TRUE;
1910 switch (entry->dwAltNameChoice)
1911 {
1912 case CERT_ALT_NAME_RFC822_NAME:
1913 case CERT_ALT_NAME_DNS_NAME:
1914 case CERT_ALT_NAME_URL:
1915 tag = ASN_CONTEXT | (entry->dwAltNameChoice - 1);
1916 if (entry->u.pwszURL)
1917 {
1918 DWORD i;
1919
1920 /* Not + 1: don't encode the NULL-terminator */
1921 dataLen = lstrlenW(entry->u.pwszURL);
1922 for (i = 0; ret && i < dataLen; i++)
1923 {
1924 if (entry->u.pwszURL[i] > 0x7f)
1925 {
1926 SetLastError(CRYPT_E_INVALID_IA5_STRING);
1927 ret = FALSE;
1928 *pcbEncoded = i;
1929 }
1930 }
1931 }
1932 else
1933 dataLen = 0;
1934 break;
1935 case CERT_ALT_NAME_DIRECTORY_NAME:
1936 tag = ASN_CONTEXT | ASN_CONSTRUCTOR | (entry->dwAltNameChoice - 1);
1937 dataLen = entry->u.DirectoryName.cbData;
1938 break;
1939 case CERT_ALT_NAME_IP_ADDRESS:
1940 tag = ASN_CONTEXT | (entry->dwAltNameChoice - 1);
1941 dataLen = entry->u.IPAddress.cbData;
1942 break;
1943 case CERT_ALT_NAME_REGISTERED_ID:
1944 {
1945 struct AsnEncodeTagSwappedItem swapped =
1946 { ASN_CONTEXT | (entry->dwAltNameChoice - 1), entry->u.pszRegisteredID,
1947 CRYPT_AsnEncodeOid };
1948
1949 return CRYPT_AsnEncodeSwapTag(0, NULL, &swapped, 0, NULL, pbEncoded,
1950 pcbEncoded);
1951 }
1952 case CERT_ALT_NAME_OTHER_NAME:
1953 FIXME("name type %d unimplemented\n", entry->dwAltNameChoice);
1954 return FALSE;
1955 default:
1956 SetLastError(E_INVALIDARG);
1957 return FALSE;
1958 }
1959 if (ret)
1960 {
1961 DWORD bytesNeeded, lenBytes;
1962
1963 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
1964 bytesNeeded = 1 + dataLen + lenBytes;
1965 if (!pbEncoded)
1966 *pcbEncoded = bytesNeeded;
1967 else if (*pcbEncoded < bytesNeeded)
1968 {
1969 SetLastError(ERROR_MORE_DATA);
1970 *pcbEncoded = bytesNeeded;
1971 ret = FALSE;
1972 }
1973 else
1974 {
1975 *pbEncoded++ = tag;
1976 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
1977 pbEncoded += lenBytes;
1978 switch (entry->dwAltNameChoice)
1979 {
1980 case CERT_ALT_NAME_RFC822_NAME:
1981 case CERT_ALT_NAME_DNS_NAME:
1982 case CERT_ALT_NAME_URL:
1983 {
1984 DWORD i;
1985
1986 for (i = 0; i < dataLen; i++)
1987 *pbEncoded++ = (BYTE)entry->u.pwszURL[i];
1988 break;
1989 }
1990 case CERT_ALT_NAME_DIRECTORY_NAME:
1991 memcpy(pbEncoded, entry->u.DirectoryName.pbData, dataLen);
1992 break;
1993 case CERT_ALT_NAME_IP_ADDRESS:
1994 memcpy(pbEncoded, entry->u.IPAddress.pbData, dataLen);
1995 break;
1996 }
1997 if (ret)
1998 *pcbEncoded = bytesNeeded;
1999 }
2000 }
2001 TRACE("returning %d (%08x)\n", ret, GetLastError());
2002 return ret;
2003 }
2004
2005 static BOOL WINAPI CRYPT_AsnEncodeIntegerSwapBytes(DWORD dwCertEncodingType,
2006 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2007 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2008 {
2009 BOOL ret;
2010
2011 __TRY
2012 {
2013 const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo;
2014 CRYPT_DATA_BLOB newBlob = { blob->cbData, NULL };
2015
2016 ret = TRUE;
2017 if (newBlob.cbData)
2018 {
2019 newBlob.pbData = CryptMemAlloc(newBlob.cbData);
2020 if (newBlob.pbData)
2021 {
2022 DWORD i;
2023
2024 for (i = 0; i < newBlob.cbData; i++)
2025 newBlob.pbData[newBlob.cbData - i - 1] = blob->pbData[i];
2026 }
2027 else
2028 ret = FALSE;
2029 }
2030 if (ret)
2031 ret = CRYPT_AsnEncodeInteger(dwCertEncodingType, lpszStructType,
2032 &newBlob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2033 CryptMemFree(newBlob.pbData);
2034 }
2035 __EXCEPT_PAGE_FAULT
2036 {
2037 SetLastError(STATUS_ACCESS_VIOLATION);
2038 ret = FALSE;
2039 }
2040 __ENDTRY
2041 return ret;
2042 }
2043
2044 static BOOL WINAPI CRYPT_AsnEncodeAuthorityKeyId(DWORD dwCertEncodingType,
2045 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2046 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2047 {
2048 BOOL ret;
2049
2050 __TRY
2051 {
2052 const CERT_AUTHORITY_KEY_ID_INFO *info =
2053 (const CERT_AUTHORITY_KEY_ID_INFO *)pvStructInfo;
2054 struct AsnEncodeSequenceItem items[3] = { { 0 } };
2055 struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
2056 struct AsnConstructedItem constructed = { 0 };
2057 DWORD cItem = 0, cSwapped = 0;
2058
2059 if (info->KeyId.cbData)
2060 {
2061 swapped[cSwapped].tag = ASN_CONTEXT | 0;
2062 swapped[cSwapped].pvStructInfo = &info->KeyId;
2063 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeIntegerSwapBytes;
2064 items[cItem].pvStructInfo = &swapped[cSwapped];
2065 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2066 cSwapped++;
2067 cItem++;
2068 }
2069 if (info->CertIssuer.cbData)
2070 {
2071 constructed.tag = 1;
2072 constructed.pvStructInfo = &info->CertIssuer;
2073 constructed.encodeFunc = CRYPT_CopyEncodedBlob;
2074 items[cItem].pvStructInfo = &constructed;
2075 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
2076 cItem++;
2077 }
2078 if (info->CertSerialNumber.cbData)
2079 {
2080 swapped[cSwapped].tag = ASN_CONTEXT | 2;
2081 swapped[cSwapped].pvStructInfo = &info->CertSerialNumber;
2082 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInteger;
2083 items[cItem].pvStructInfo = &swapped[cSwapped];
2084 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2085 cSwapped++;
2086 cItem++;
2087 }
2088 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, dwFlags,
2089 pEncodePara, pbEncoded, pcbEncoded);
2090 }
2091 __EXCEPT_PAGE_FAULT
2092 {
2093 SetLastError(STATUS_ACCESS_VIOLATION);
2094 ret = FALSE;
2095 }
2096 __ENDTRY
2097 return ret;
2098 }
2099
2100 static BOOL WINAPI CRYPT_AsnEncodeAltName(DWORD dwCertEncodingType,
2101 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2102 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2103 {
2104 BOOL ret;
2105
2106 __TRY
2107 {
2108 const CERT_ALT_NAME_INFO *info =
2109 (const CERT_ALT_NAME_INFO *)pvStructInfo;
2110 DWORD bytesNeeded, dataLen, lenBytes, i;
2111
2112 ret = TRUE;
2113 /* FIXME: should check that cAltEntry is not bigger than 0xff, since we
2114 * can't encode an erroneous entry index if it's bigger than this.
2115 */
2116 for (i = 0, dataLen = 0; ret && i < info->cAltEntry; i++)
2117 {
2118 DWORD len;
2119
2120 ret = CRYPT_AsnEncodeAltNameEntry(&info->rgAltEntry[i], NULL,
2121 &len);
2122 if (ret)
2123 dataLen += len;
2124 else if (GetLastError() == CRYPT_E_INVALID_IA5_STRING)
2125 {
2126 /* CRYPT_AsnEncodeAltNameEntry encoded the index of
2127 * the bad character, now set the index of the bad
2128 * entry
2129 */
2130 *pcbEncoded = (BYTE)i <<
2131 CERT_ALT_NAME_ENTRY_ERR_INDEX_SHIFT | len;
2132 }
2133 }
2134 if (ret)
2135 {
2136 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
2137 bytesNeeded = 1 + lenBytes + dataLen;
2138 if (!pbEncoded)
2139 {
2140 *pcbEncoded = bytesNeeded;
2141 ret = TRUE;
2142 }
2143 else
2144 {
2145 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2146 pbEncoded, pcbEncoded, bytesNeeded)))
2147 {
2148 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2149 pbEncoded = *(BYTE **)pbEncoded;
2150 *pbEncoded++ = ASN_SEQUENCEOF;
2151 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
2152 pbEncoded += lenBytes;
2153 for (i = 0; ret && i < info->cAltEntry; i++)
2154 {
2155 DWORD len = dataLen;
2156
2157 ret = CRYPT_AsnEncodeAltNameEntry(&info->rgAltEntry[i],
2158 pbEncoded, &len);
2159 if (ret)
2160 {
2161 pbEncoded += len;
2162 dataLen -= len;
2163 }
2164 }
2165 }
2166 }
2167 }
2168 }
2169 __EXCEPT_PAGE_FAULT
2170 {
2171 SetLastError(STATUS_ACCESS_VIOLATION);
2172 ret = FALSE;
2173 }
2174 __ENDTRY
2175 return ret;
2176 }
2177
2178 static BOOL WINAPI CRYPT_AsnEncodeAuthorityKeyId2(DWORD dwCertEncodingType,
2179 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2180 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2181 {
2182 BOOL ret;
2183
2184 __TRY
2185 {
2186 const CERT_AUTHORITY_KEY_ID2_INFO *info =
2187 (const CERT_AUTHORITY_KEY_ID2_INFO *)pvStructInfo;
2188 struct AsnEncodeSequenceItem items[3] = { { 0 } };
2189 struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
2190 DWORD cItem = 0, cSwapped = 0;
2191
2192 if (info->KeyId.cbData)
2193 {
2194 swapped[cSwapped].tag = ASN_CONTEXT | 0;
2195 swapped[cSwapped].pvStructInfo = &info->KeyId;
2196 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeIntegerSwapBytes;
2197 items[cItem].pvStructInfo = &swapped[cSwapped];
2198 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2199 cSwapped++;
2200 cItem++;
2201 }
2202 if (info->AuthorityCertIssuer.cAltEntry)
2203 {
2204 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1;
2205 swapped[cSwapped].pvStructInfo = &info->AuthorityCertIssuer;
2206 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
2207 items[cItem].pvStructInfo = &swapped[cSwapped];
2208 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2209 cSwapped++;
2210 cItem++;
2211 }
2212 if (info->AuthorityCertSerialNumber.cbData)
2213 {
2214 swapped[cSwapped].tag = ASN_CONTEXT | 2;
2215 swapped[cSwapped].pvStructInfo = &info->AuthorityCertSerialNumber;
2216 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInteger;
2217 items[cItem].pvStructInfo = &swapped[cSwapped];
2218 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2219 cSwapped++;
2220 cItem++;
2221 }
2222 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, dwFlags,
2223 pEncodePara, pbEncoded, pcbEncoded);
2224 }
2225 __EXCEPT_PAGE_FAULT
2226 {
2227 SetLastError(STATUS_ACCESS_VIOLATION);
2228 ret = FALSE;
2229 }
2230 __ENDTRY
2231 return ret;
2232 }
2233
2234 static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints(DWORD dwCertEncodingType,
2235 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2236 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2237 {
2238 BOOL ret;
2239
2240 __TRY
2241 {
2242 const CERT_BASIC_CONSTRAINTS_INFO *info =
2243 (const CERT_BASIC_CONSTRAINTS_INFO *)pvStructInfo;
2244 struct AsnEncodeSequenceItem items[3] = {
2245 { &info->SubjectType, CRYPT_AsnEncodeBits, 0 },
2246 { 0 }
2247 };
2248 DWORD cItem = 1;
2249
2250 if (info->fPathLenConstraint)
2251 {
2252 items[cItem].pvStructInfo = &info->dwPathLenConstraint;
2253 items[cItem].encodeFunc = CRYPT_AsnEncodeInt;
2254 cItem++;
2255 }
2256 if (info->cSubtreesConstraint)
2257 {
2258 items[cItem].pvStructInfo = &info->cSubtreesConstraint;
2259 items[cItem].encodeFunc = CRYPT_AsnEncodeSequenceOfAny;
2260 cItem++;
2261 }
2262 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
2263 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2264 }
2265 __EXCEPT_PAGE_FAULT
2266 {
2267 SetLastError(STATUS_ACCESS_VIOLATION);
2268 ret = FALSE;
2269 }
2270 __ENDTRY
2271 return ret;
2272 }
2273
2274 static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints2(DWORD dwCertEncodingType,
2275 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2276 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2277 {
2278 BOOL ret;
2279
2280 __TRY
2281 {
2282 const CERT_BASIC_CONSTRAINTS2_INFO *info =
2283 (const CERT_BASIC_CONSTRAINTS2_INFO *)pvStructInfo;
2284 struct AsnEncodeSequenceItem items[2] = { { 0 } };
2285 DWORD cItem = 0;
2286
2287 if (info->fCA)
2288 {
2289 items[cItem].pvStructInfo = &info->fCA;
2290 items[cItem].encodeFunc = CRYPT_AsnEncodeBool;
2291 cItem++;
2292 }
2293 if (info->fPathLenConstraint)
2294 {
2295 items[cItem].pvStructInfo = &info->dwPathLenConstraint;
2296 items[cItem].encodeFunc = CRYPT_AsnEncodeInt;
2297 cItem++;
2298 }
2299 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
2300 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2301 }
2302 __EXCEPT_PAGE_FAULT
2303 {
2304 SetLastError(STATUS_ACCESS_VIOLATION);
2305 ret = FALSE;
2306 }
2307 __ENDTRY
2308 return ret;
2309 }
2310
2311 static BOOL WINAPI CRYPT_AsnEncodeRsaPubKey(DWORD dwCertEncodingType,
2312 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2313 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2314 {
2315 BOOL ret;
2316
2317 __TRY
2318 {
2319 const BLOBHEADER *hdr =
2320 (const BLOBHEADER *)pvStructInfo;
2321
2322 if (hdr->bType != PUBLICKEYBLOB)
2323 {
2324 SetLastError(E_INVALIDARG);
2325 ret = FALSE;
2326 }
2327 else
2328 {
2329 const RSAPUBKEY *rsaPubKey = (const RSAPUBKEY *)
2330 ((const BYTE *)pvStructInfo + sizeof(BLOBHEADER));
2331 CRYPT_INTEGER_BLOB blob = { rsaPubKey->bitlen / 8,
2332 (BYTE *)pvStructInfo + sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) };
2333 struct AsnEncodeSequenceItem items[] = {
2334 { &blob, CRYPT_AsnEncodeUnsignedInteger, 0 },
2335 { &rsaPubKey->pubexp, CRYPT_AsnEncodeInt, 0 },
2336 };
2337
2338 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
2339 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
2340 pcbEncoded);
2341 }
2342 }
2343 __EXCEPT_PAGE_FAULT
2344 {
2345 SetLastError(STATUS_ACCESS_VIOLATION);
2346 ret = FALSE;
2347 }
2348 __ENDTRY
2349 return ret;
2350 }
2351
2352 BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
2353 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2354 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2355 {
2356 BOOL ret;
2357
2358 __TRY
2359 {
2360 const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo;
2361 DWORD bytesNeeded, lenBytes;
2362
2363 TRACE("(%d, %p), %08x, %p, %p, %d\n", blob->cbData, blob->pbData,
2364 dwFlags, pEncodePara, pbEncoded, *pcbEncoded);
2365
2366 CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes);
2367 bytesNeeded = 1 + lenBytes + blob->cbData;
2368 if (!pbEncoded)
2369 {
2370 *pcbEncoded = bytesNeeded;
2371 ret = TRUE;
2372 }
2373 else
2374 {
2375 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2376 pcbEncoded, bytesNeeded)))
2377 {
2378 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2379 pbEncoded = *(BYTE **)pbEncoded;
2380 *pbEncoded++ = ASN_OCTETSTRING;
2381 CRYPT_EncodeLen(blob->cbData, pbEncoded, &lenBytes);
2382 pbEncoded += lenBytes;
2383 if (blob->cbData)
2384 memcpy(pbEncoded, blob->pbData, blob->cbData);
2385 }
2386 }
2387 }
2388 __EXCEPT_PAGE_FAULT
2389 {
2390 SetLastError(STATUS_ACCESS_VIOLATION);
2391 ret = FALSE;
2392 }
2393 __ENDTRY
2394 TRACE("returning %d (%08x)\n", ret, GetLastError());
2395 return ret;
2396 }
2397
2398 static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType,
2399 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2400 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2401 {
2402 BOOL ret;
2403
2404 __TRY
2405 {
2406 const CRYPT_BIT_BLOB *blob = (const CRYPT_BIT_BLOB *)pvStructInfo;
2407 DWORD bytesNeeded, lenBytes, dataBytes;
2408 BYTE unusedBits;
2409
2410 /* yep, MS allows cUnusedBits to be >= 8 */
2411 if (!blob->cUnusedBits)
2412 {
2413 dataBytes = blob->cbData;
2414 unusedBits = 0;
2415 }
2416 else if (blob->cbData * 8 > blob->cUnusedBits)
2417 {
2418 dataBytes = (blob->cbData * 8 - blob->cUnusedBits) / 8 + 1;
2419 unusedBits = blob->cUnusedBits >= 8 ? blob->cUnusedBits / 8 :
2420 blob->cUnusedBits;
2421 }
2422 else
2423 {
2424 dataBytes = 0;
2425 unusedBits = 0;
2426 }
2427 CRYPT_EncodeLen(dataBytes + 1, NULL, &lenBytes);
2428 bytesNeeded = 1 + lenBytes + dataBytes + 1;
2429 if (!pbEncoded)
2430 {
2431 *pcbEncoded = bytesNeeded;
2432 ret = TRUE;
2433 }
2434 else
2435 {
2436 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2437 pcbEncoded, bytesNeeded)))
2438 {
2439 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2440 pbEncoded = *(BYTE **)pbEncoded;
2441 *pbEncoded++ = ASN_BITSTRING;
2442 CRYPT_EncodeLen(dataBytes + 1, pbEncoded, &lenBytes);
2443 pbEncoded += lenBytes;
2444 *pbEncoded++ = unusedBits;
2445 if (dataBytes)
2446 {
2447 BYTE mask = 0xff << unusedBits;
2448
2449 if (dataBytes > 1)
2450 {
2451 memcpy(pbEncoded, blob->pbData, dataBytes - 1);
2452 pbEncoded += dataBytes - 1;
2453 }
2454 *pbEncoded = *(blob->pbData + dataBytes - 1) & mask;
2455 }
2456 }
2457 }
2458 }
2459 __EXCEPT_PAGE_FAULT
2460 {
2461 SetLastError(STATUS_ACCESS_VIOLATION);
2462 ret = FALSE;
2463 }
2464 __ENDTRY
2465 return ret;
2466 }
2467
2468 static BOOL WINAPI CRYPT_AsnEncodeBitsSwapBytes(DWORD dwCertEncodingType,
2469 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2470 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2471 {
2472 BOOL ret;
2473
2474 __TRY
2475 {
2476 const CRYPT_BIT_BLOB *blob = (const CRYPT_BIT_BLOB *)pvStructInfo;
2477 CRYPT_BIT_BLOB newBlob = { blob->cbData, NULL, blob->cUnusedBits };
2478
2479 ret = TRUE;
2480 if (newBlob.cbData)
2481 {
2482 newBlob.pbData = CryptMemAlloc(newBlob.cbData);
2483 if (newBlob.pbData)
2484 {
2485 DWORD i;
2486
2487 for (i = 0; i < newBlob.cbData; i++)
2488 newBlob.pbData[newBlob.cbData - i - 1] = blob->pbData[i];
2489 }
2490 else
2491 ret = FALSE;
2492 }
2493 if (ret)
2494 ret = CRYPT_AsnEncodeBits(dwCertEncodingType, lpszStructType,
2495 &newBlob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2496 CryptMemFree(newBlob.pbData);
2497 }
2498 __EXCEPT_PAGE_FAULT
2499 {
2500 SetLastError(STATUS_ACCESS_VIOLATION);
2501 ret = FALSE;
2502 }
2503 __ENDTRY
2504 return ret;
2505 }
2506
2507 BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType,
2508 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2509 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2510 {
2511 CRYPT_INTEGER_BLOB blob = { sizeof(INT), (BYTE *)pvStructInfo };
2512
2513 return CRYPT_AsnEncodeInteger(dwCertEncodingType, X509_MULTI_BYTE_INTEGER,
2514 &blob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2515 }
2516
2517 static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType,
2518 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2519 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2520 {
2521 BOOL ret;
2522
2523 __TRY
2524 {
2525 DWORD significantBytes, lenBytes;
2526 BYTE padByte = 0, bytesNeeded;
2527 BOOL pad = FALSE;
2528 const CRYPT_INTEGER_BLOB *blob =
2529 (const CRYPT_INTEGER_BLOB *)pvStructInfo;
2530
2531 significantBytes = blob->cbData;
2532 if (significantBytes)
2533 {
2534 if (blob->pbData[significantBytes - 1] & 0x80)
2535 {
2536 /* negative, lop off leading (little-endian) 0xffs */
2537 for (; significantBytes > 0 &&
2538 blob->pbData[significantBytes - 1] == 0xff; significantBytes--)
2539 ;
2540 if (blob->pbData[significantBytes - 1] < 0x80)
2541 {
2542 padByte = 0xff;
2543 pad = TRUE;
2544 }
2545 }
2546 else
2547 {
2548 /* positive, lop off leading (little-endian) zeroes */
2549 for (; significantBytes > 0 &&
2550 !blob->pbData[significantBytes - 1]; significantBytes--)
2551 ;
2552 if (significantBytes == 0)
2553 significantBytes = 1;
2554 if (blob->pbData[significantBytes - 1] > 0x7f)
2555 {
2556 padByte = 0;
2557 pad = TRUE;
2558 }
2559 }
2560 }
2561 if (pad)
2562 CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes);
2563 else
2564 CRYPT_EncodeLen(significantBytes, NULL, &lenBytes);
2565 bytesNeeded = 1 + lenBytes + significantBytes;
2566 if (pad)
2567 bytesNeeded++;
2568 if (!pbEncoded)
2569 {
2570 *pcbEncoded = bytesNeeded;
2571 ret = TRUE;
2572 }
2573 else
2574 {
2575 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2576 pcbEncoded, bytesNeeded)))
2577 {
2578 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2579 pbEncoded = *(BYTE **)pbEncoded;
2580 *pbEncoded++ = ASN_INTEGER;
2581 if (pad)
2582 {
2583 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
2584 pbEncoded += lenBytes;
2585 *pbEncoded++ = padByte;
2586 }
2587 else
2588 {
2589 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
2590 pbEncoded += lenBytes;
2591 }
2592 for (; significantBytes > 0; significantBytes--)
2593 *(pbEncoded++) = blob->pbData[significantBytes - 1];
2594 }
2595 }
2596 }
2597 __EXCEPT_PAGE_FAULT
2598 {
2599 SetLastError(STATUS_ACCESS_VIOLATION);
2600 ret = FALSE;
2601 }
2602 __ENDTRY
2603 return ret;
2604 }
2605
2606 static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType,
2607 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2608 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2609 {
2610 BOOL ret;
2611
2612 __TRY
2613 {
2614 DWORD significantBytes, lenBytes;
2615 BYTE bytesNeeded;
2616 BOOL pad = FALSE;
2617 const CRYPT_INTEGER_BLOB *blob =
2618 (const CRYPT_INTEGER_BLOB *)pvStructInfo;
2619
2620 significantBytes = blob->cbData;
2621 if (significantBytes)
2622 {
2623 /* positive, lop off leading (little-endian) zeroes */
2624 for (; significantBytes > 0 && !blob->pbData[significantBytes - 1];
2625 significantBytes--)
2626 ;
2627 if (significantBytes == 0)
2628 significantBytes = 1;
2629 if (blob->pbData[significantBytes - 1] > 0x7f)
2630 pad = TRUE;
2631 }
2632 if (pad)
2633 CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes);
2634 else
2635 CRYPT_EncodeLen(significantBytes, NULL, &lenBytes);
2636 bytesNeeded = 1 + lenBytes + significantBytes;
2637 if (pad)
2638 bytesNeeded++;
2639 if (!pbEncoded)
2640 {
2641 *pcbEncoded = bytesNeeded;
2642 ret = TRUE;
2643 }
2644 else
2645 {
2646 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2647 pcbEncoded, bytesNeeded)))
2648 {
2649 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2650 pbEncoded = *(BYTE **)pbEncoded;
2651 *pbEncoded++ = ASN_INTEGER;
2652 if (pad)
2653 {
2654 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
2655 pbEncoded += lenBytes;
2656 *pbEncoded++ = 0;
2657 }
2658 else
2659 {
2660 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
2661 pbEncoded += lenBytes;
2662 }
2663 for (; significantBytes > 0; significantBytes--)
2664 *(pbEncoded++) = blob->pbData[significantBytes - 1];
2665 }
2666 }
2667 }
2668 __EXCEPT_PAGE_FAULT
2669 {
2670 SetLastError(STATUS_ACCESS_VIOLATION);
2671 ret = FALSE;
2672 }
2673 __ENDTRY
2674 return ret;
2675 }
2676
2677 static BOOL WINAPI CRYPT_AsnEncodeEnumerated(DWORD dwCertEncodingType,
2678 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2679 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2680 {
2681 CRYPT_INTEGER_BLOB blob;
2682 BOOL ret;
2683
2684 /* Encode as an unsigned integer, then change the tag to enumerated */
2685 blob.cbData = sizeof(DWORD);
2686 blob.pbData = (BYTE *)pvStructInfo;
2687 ret = CRYPT_AsnEncodeUnsignedInteger(dwCertEncodingType,
2688 X509_MULTI_BYTE_UINT, &blob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2689 if (ret && pbEncoded)
2690 {
2691 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2692 pbEncoded = *(BYTE **)pbEncoded;
2693 pbEncoded[0] = ASN_ENUMERATED;
2694 }
2695 return ret;
2696 }
2697
2698 static BOOL WINAPI CRYPT_AsnEncodeUtcTime(DWORD dwCertEncodingType,
2699 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2700 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2701 {
2702 BOOL ret;
2703
2704 __TRY
2705 {
2706 SYSTEMTIME sysTime;
2707 /* sorry, magic number: enough for tag, len, YYMMDDHHMMSSZ\0. I use a
2708 * temporary buffer because the output buffer is not NULL-terminated.
2709 */
2710 char buf[16];
2711 static const DWORD bytesNeeded = sizeof(buf) - 1;
2712
2713 if (!pbEncoded)
2714 {
2715 *pcbEncoded = bytesNeeded;
2716 ret = TRUE;
2717 }
2718 else
2719 {
2720 /* Sanity check the year, this is a two-digit year format */
2721 ret = FileTimeToSystemTime((const FILETIME *)pvStructInfo,
2722 &sysTime);
2723 if (ret && (sysTime.wYear < 1950 || sysTime.wYear > 2050))
2724 {
2725 SetLastError(CRYPT_E_BAD_ENCODE);
2726 ret = FALSE;
2727 }
2728 if (ret)
2729 {
2730 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2731 pbEncoded, pcbEncoded, bytesNeeded)))
2732 {
2733 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2734 pbEncoded = *(BYTE **)pbEncoded;
2735 buf[0] = ASN_UTCTIME;
2736 buf[1] = bytesNeeded - 2;
2737 snprintf(buf + 2, sizeof(buf) - 2,
2738 "%02d%02d%02d%02d%02d%02dZ", sysTime.wYear >= 2000 ?
2739 sysTime.wYear - 2000 : sysTime.wYear - 1900,
2740 sysTime.wMonth, sysTime.wDay, sysTime.wHour,
2741 sysTime.wMinute, sysTime.wSecond);
2742 memcpy(pbEncoded, buf, bytesNeeded);
2743 }
2744 }
2745 }
2746 }
2747 __EXCEPT_PAGE_FAULT
2748 {
2749 SetLastError(STATUS_ACCESS_VIOLATION);
2750 ret = FALSE;
2751 }
2752 __ENDTRY
2753 return ret;
2754 }
2755
2756 static BOOL WINAPI CRYPT_AsnEncodeGeneralizedTime(DWORD dwCertEncodingType,
2757 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2758 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2759 {
2760 BOOL ret;
2761
2762 __TRY
2763 {
2764 SYSTEMTIME sysTime;
2765 /* sorry, magic number: enough for tag, len, YYYYMMDDHHMMSSZ\0. I use a
2766 * temporary buffer because the output buffer is not NULL-terminated.
2767 */
2768 char buf[18];
2769 static const DWORD bytesNeeded = sizeof(buf) - 1;
2770
2771 if (!pbEncoded)
2772 {
2773 *pcbEncoded = bytesNeeded;
2774 ret = TRUE;
2775 }
2776 else
2777 {
2778 ret = FileTimeToSystemTime((const FILETIME *)pvStructInfo,
2779 &sysTime);
2780 if (ret)
2781 ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2782 pcbEncoded, bytesNeeded);
2783 if (ret)
2784 {
2785 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2786 pbEncoded = *(BYTE **)pbEncoded;
2787 buf[0] = ASN_GENERALTIME;
2788 buf[1] = bytesNeeded - 2;
2789 snprintf(buf + 2, sizeof(buf) - 2, "%04d%02d%02d%02d%02d%02dZ",
2790 sysTime.wYear, sysTime.wMonth, sysTime.wDay, sysTime.wHour,
2791 sysTime.wMinute, sysTime.wSecond);
2792 memcpy(pbEncoded, buf, bytesNeeded);
2793 }
2794 }
2795 }
2796 __EXCEPT_PAGE_FAULT
2797 {
2798 SetLastError(STATUS_ACCESS_VIOLATION);
2799 ret = FALSE;
2800 }
2801 __ENDTRY
2802 return ret;
2803 }
2804
2805 static BOOL WINAPI CRYPT_AsnEncodeChoiceOfTime(DWORD dwCertEncodingType,
2806 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2807 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2808 {
2809 BOOL ret;
2810
2811 __TRY
2812 {
2813 SYSTEMTIME sysTime;
2814
2815 /* Check the year, if it's in the UTCTime range call that encode func */
2816 if (!FileTimeToSystemTime((const FILETIME *)pvStructInfo, &sysTime))
2817 return FALSE;
2818 if (sysTime.wYear >= 1950 && sysTime.wYear <= 2050)
2819 ret = CRYPT_AsnEncodeUtcTime(dwCertEncodingType, lpszStructType,
2820 pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2821 else
2822 ret = CRYPT_AsnEncodeGeneralizedTime(dwCertEncodingType,
2823 lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded,
2824 pcbEncoded);
2825 }
2826 __EXCEPT_PAGE_FAULT
2827 {
2828 SetLastError(STATUS_ACCESS_VIOLATION);
2829 ret = FALSE;
2830 }
2831 __ENDTRY
2832 return ret;
2833 }
2834
2835 static BOOL WINAPI CRYPT_AsnEncodeSequenceOfAny(DWORD dwCertEncodingType,
2836 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2837 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2838 {
2839 BOOL ret;
2840
2841 __TRY
2842 {
2843 DWORD bytesNeeded, dataLen, lenBytes, i;
2844 const CRYPT_SEQUENCE_OF_ANY *seq =
2845 (const CRYPT_SEQUENCE_OF_ANY *)pvStructInfo;
2846
2847 for (i = 0, dataLen = 0; i < seq->cValue; i++)
2848 dataLen += seq->rgValue[i].cbData;
2849 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
2850 bytesNeeded = 1 + lenBytes + dataLen;
2851 if (!pbEncoded)
2852 {
2853 *pcbEncoded = bytesNeeded;
2854 ret = TRUE;
2855 }
2856 else
2857 {
2858 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2859 pcbEncoded, bytesNeeded)))
2860 {
2861 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2862 pbEncoded = *(BYTE **)pbEncoded;
2863 *pbEncoded++ = ASN_SEQUENCEOF;
2864 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
2865 pbEncoded += lenBytes;
2866 for (i = 0; i < seq->cValue; i++)
2867 {
2868 memcpy(pbEncoded, seq->rgValue[i].pbData,
2869 seq->rgValue[i].cbData);
2870 pbEncoded += seq->rgValue[i].cbData;
2871 }
2872 }
2873 }
2874 }
2875 __EXCEPT_PAGE_FAULT
2876 {
2877 SetLastError(STATUS_ACCESS_VIOLATION);
2878 ret = FALSE;
2879 }
2880 __ENDTRY
2881 return ret;
2882 }
2883
2884 static BOOL CRYPT_AsnEncodeDistPoint(const CRL_DIST_POINT *distPoint,
2885 BYTE *pbEncoded, DWORD *pcbEncoded)
2886 {
2887 BOOL ret = TRUE;
2888 struct AsnEncodeSequenceItem items[3] = { { 0 } };
2889 struct AsnConstructedItem constructed = { 0 };
2890 struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
2891 DWORD cItem = 0, cSwapped = 0;
2892
2893 switch (distPoint->DistPointName.dwDistPointNameChoice)
2894 {
2895 case CRL_DIST_POINT_NO_NAME:
2896 /* do nothing */
2897 break;
2898 case CRL_DIST_POINT_FULL_NAME:
2899 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
2900 swapped[cSwapped].pvStructInfo = &distPoint->DistPointName.u.FullName;
2901 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
2902 constructed.tag = 0;
2903 constructed.pvStructInfo = &swapped[cSwapped];
2904 constructed.encodeFunc = CRYPT_AsnEncodeSwapTag;
2905 items[cItem].pvStructInfo = &constructed;
2906 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
2907 cSwapped++;
2908 cItem++;
2909 break;
2910 case CRL_DIST_POINT_ISSUER_RDN_NAME:
2911 FIXME("unimplemented for CRL_DIST_POINT_ISSUER_RDN_NAME\n");
2912 ret = FALSE;
2913 break;
2914 default:
2915 ret = FALSE;
2916 }
2917 if (ret && distPoint->ReasonFlags.cbData)
2918 {
2919 swapped[cSwapped].tag = ASN_CONTEXT | 1;
2920 swapped[cSwapped].pvStructInfo = &distPoint->ReasonFlags;
2921 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBits;
2922 items[cItem].pvStructInfo = &swapped[cSwapped];
2923 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2924 cSwapped++;
2925 cItem++;
2926 }
2927 if (ret && distPoint->CRLIssuer.cAltEntry)
2928 {
2929 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 2;
2930 swapped[cSwapped].pvStructInfo = &distPoint->CRLIssuer;
2931 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
2932 items[cItem].pvStructInfo = &swapped[cSwapped];
2933 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2934 cSwapped++;
2935 cItem++;
2936 }
2937 if (ret)
2938 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
2939 pbEncoded, pcbEncoded);
2940 return ret;
2941 }
2942
2943 static BOOL WINAPI CRYPT_AsnEncodeCRLDistPoints(DWORD dwCertEncodingType,
2944 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2945 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2946 {
2947 BOOL ret;
2948
2949 __TRY
2950 {
2951 const CRL_DIST_POINTS_INFO *info =
2952 (const CRL_DIST_POINTS_INFO *)pvStructInfo;
2953
2954 if (!info->cDistPoint)
2955 {
2956 SetLastError(E_INVALIDARG);
2957 ret = FALSE;
2958 }
2959 else
2960 {
2961 DWORD bytesNeeded, dataLen, lenBytes, i;
2962
2963 ret = TRUE;
2964 for (i = 0, dataLen = 0; ret && i < info->cDistPoint; i++)
2965 {
2966 DWORD len;
2967
2968 ret = CRYPT_AsnEncodeDistPoint(&info->rgDistPoint[i], NULL,
2969 &len);
2970 if (ret)
2971 dataLen += len;
2972 else if (GetLastError() == CRYPT_E_INVALID_IA5_STRING)
2973 {
2974 /* Have to propagate index of failing character */
2975 *pcbEncoded = len;
2976 }
2977 }
2978 if (ret)
2979 {
2980 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
2981 bytesNeeded = 1 + lenBytes + dataLen;
2982 if (!pbEncoded)
2983 {
2984 *pcbEncoded = bytesNeeded;
2985 ret = TRUE;
2986 }
2987 else
2988 {
2989 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2990 pbEncoded, pcbEncoded, bytesNeeded)))
2991 {
2992 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2993 pbEncoded = *(BYTE **)pbEncoded;
2994 *pbEncoded++ = ASN_SEQUENCEOF;
2995 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
2996 pbEncoded += lenBytes;
2997 for (i = 0; ret && i < info->cDistPoint; i++)
2998 {
2999 DWORD len = dataLen;
3000
3001 ret = CRYPT_AsnEncodeDistPoint(
3002 &info->rgDistPoint[i], pbEncoded, &len);
3003 if (ret)
3004 {
3005 pbEncoded += len;
3006 dataLen -= len;
3007 }
3008 }
3009 }
3010 }
3011 }
3012 }
3013 }
3014 __EXCEPT_PAGE_FAULT
3015 {
3016 SetLastError(STATUS_ACCESS_VIOLATION);
3017 ret = FALSE;
3018 }
3019 __ENDTRY
3020 return ret;
3021 }
3022
3023 static BOOL WINAPI CRYPT_AsnEncodeEnhancedKeyUsage(DWORD dwCertEncodingType,
3024 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3025 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3026 {
3027 BOOL ret;
3028
3029 __TRY
3030 {
3031 const CERT_ENHKEY_USAGE *usage =
3032 (const CERT_ENHKEY_USAGE *)pvStructInfo;
3033 DWORD bytesNeeded = 0, lenBytes, size, i;
3034
3035 ret = TRUE;
3036 for (i = 0; ret && i < usage->cUsageIdentifier; i++)
3037 {
3038 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
3039 usage->rgpszUsageIdentifier[i],
3040 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &size);
3041 if (ret)
3042 bytesNeeded += size;
3043 }
3044 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
3045 bytesNeeded += 1 + lenBytes;
3046 if (ret)
3047 {
3048 if (!pbEncoded)
3049 *pcbEncoded = bytesNeeded;
3050 else
3051 {
3052 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
3053 pbEncoded, pcbEncoded, bytesNeeded)))
3054 {
3055 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3056 pbEncoded = *(BYTE **)pbEncoded;
3057 *pbEncoded++ = ASN_SEQUENCEOF;
3058 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
3059 &lenBytes);
3060 pbEncoded += lenBytes;
3061 for (i = 0; ret && i < usage->cUsageIdentifier; i++)
3062 {
3063 size = bytesNeeded;
3064 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
3065 usage->rgpszUsageIdentifier[i],
3066 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, pbEncoded,
3067 &size);
3068 if (ret)
3069 {
3070 pbEncoded += size;
3071 bytesNeeded -= size;
3072 }
3073 }
3074 }
3075 }
3076 }
3077 }
3078 __EXCEPT_PAGE_FAULT
3079 {
3080 SetLastError(STATUS_ACCESS_VIOLATION);
3081 ret = FALSE;
3082 }
3083 __ENDTRY
3084 return ret;
3085 }
3086
3087 static BOOL WINAPI CRYPT_AsnEncodeIssuingDistPoint(DWORD dwCertEncodingType,
3088 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3089 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3090 {
3091 BOOL ret;
3092
3093 __TRY
3094 {
3095 const CRL_ISSUING_DIST_POINT *point =
3096 (const CRL_ISSUING_DIST_POINT *)pvStructInfo;
3097 struct AsnEncodeSequenceItem items[6] = { { 0 } };
3098 struct AsnConstructedItem constructed = { 0 };
3099 struct AsnEncodeTagSwappedItem swapped[5] = { { 0 } };
3100 DWORD cItem = 0, cSwapped = 0;
3101
3102 ret = TRUE;
3103 switch (point->DistPointName.dwDistPointNameChoice)
3104 {
3105 case CRL_DIST_POINT_NO_NAME:
3106 /* do nothing */
3107 break;
3108 case CRL_DIST_POINT_FULL_NAME:
3109 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
3110 swapped[cSwapped].pvStructInfo = &point->DistPointName.u.FullName;
3111 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
3112 constructed.tag = 0;
3113 constructed.pvStructInfo = &swapped[cSwapped];
3114 constructed.encodeFunc = CRYPT_AsnEncodeSwapTag;
3115 items[cItem].pvStructInfo = &constructed;
3116 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
3117 cSwapped++;
3118 cItem++;
3119 break;
3120 default:
3121 SetLastError(E_INVALIDARG);
3122 ret = FALSE;
3123 }
3124 if (ret && point->fOnlyContainsUserCerts)
3125 {
3126 swapped[cSwapped].tag = ASN_CONTEXT | 1;
3127 swapped[cSwapped].pvStructInfo = &point->fOnlyContainsUserCerts;
3128 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool;
3129 items[cItem].pvStructInfo = &swapped[cSwapped];
3130 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3131 cSwapped++;
3132 cItem++;
3133 }
3134 if (ret && point->fOnlyContainsCACerts)
3135 {
3136 swapped[cSwapped].tag = ASN_CONTEXT | 2;
3137 swapped[cSwapped].pvStructInfo = &point->fOnlyContainsCACerts;
3138 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool;
3139 items[cItem].pvStructInfo = &swapped[cSwapped];
3140 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3141 cSwapped++;
3142 cItem++;
3143 }
3144 if (ret && point->OnlySomeReasonFlags.cbData)
3145 {
3146 swapped[cSwapped].tag = ASN_CONTEXT | 3;
3147 swapped[cSwapped].pvStructInfo = &point->OnlySomeReasonFlags;
3148 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBits;
3149 items[cItem].pvStructInfo = &swapped[cSwapped];
3150 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3151 cSwapped++;
3152 cItem++;
3153 }
3154 if (ret && point->fIndirectCRL)
3155 {
3156 swapped[cSwapped].tag = ASN_CONTEXT | 4;
3157 swapped[cSwapped].pvStructInfo = &point->fIndirectCRL;
3158 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool;
3159 items[cItem].pvStructInfo = &swapped[cSwapped];
3160 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3161 cSwapped++;
3162 cItem++;
3163 }
3164 if (ret)
3165 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
3166 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3167 }
3168 __EXCEPT_PAGE_FAULT
3169 {
3170 SetLastError(STATUS_ACCESS_VIOLATION);
3171 ret = FALSE;
3172 }
3173 __ENDTRY
3174 return ret;
3175 }
3176
3177 static BOOL WINAPI CRYPT_AsnEncodeIssuerSerialNumber(
3178 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
3179 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
3180 DWORD *pcbEncoded)
3181 {
3182 BOOL ret;
3183 const CERT_ISSUER_SERIAL_NUMBER *issuerSerial =
3184 (const CERT_ISSUER_SERIAL_NUMBER *)pvStructInfo;
3185 struct AsnEncodeSequenceItem items[] = {
3186 { &issuerSerial->Issuer, CRYPT_CopyEncodedBlob, 0 },
3187 { &issuerSerial->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
3188 };
3189
3190 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
3191 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
3192 pcbEncoded);
3193 return ret;
3194 }
3195
3196 static BOOL WINAPI CRYPT_AsnEncodePKCSSignerInfo(DWORD dwCertEncodingType,
3197 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3198 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3199 {
3200 BOOL ret = FALSE;
3201
3202 if (!(dwCertEncodingType & PKCS_7_ASN_ENCODING))
3203 {
3204 SetLastError(E_INVALIDARG);
3205 return FALSE;
3206 }
3207
3208 __TRY
3209 {
3210 const CMSG_SIGNER_INFO *info = (const CMSG_SIGNER_INFO *)pvStructInfo;
3211
3212 if (!info->Issuer.cbData)
3213 SetLastError(E_INVALIDARG);
3214 else
3215 {
3216 struct AsnEncodeSequenceItem items[7] = {
3217 { &info->dwVersion, CRYPT_AsnEncodeInt, 0 },
3218 { &info->Issuer, CRYPT_AsnEncodeIssuerSerialNumber, 0 },
3219 { &info->HashAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams,
3220 0 },
3221 };
3222 struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
3223 DWORD cItem = 3, cSwapped = 0;
3224
3225 if (info->AuthAttrs.cAttr)
3226 {
3227 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
3228 swapped[cSwapped].pvStructInfo = &info->AuthAttrs;
3229 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes;
3230 items[cItem].pvStructInfo = &swapped[cSwapped];
3231 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3232 cSwapped++;
3233 cItem++;
3234 }
3235 items[cItem].pvStructInfo = &info->HashEncryptionAlgorithm;
3236 items[cItem].encodeFunc = CRYPT_AsnEncodeAlgorithmIdWithNullParams;
3237 cItem++;
3238 items[cItem].pvStructInfo = &info->EncryptedHash;
3239 items[cItem].encodeFunc = CRYPT_AsnEncodeOctets;
3240 cItem++;
3241 if (info->UnauthAttrs.cAttr)
3242 {
3243 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1;
3244 swapped[cSwapped].pvStructInfo = &info->UnauthAttrs;
3245 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes;
3246 items[cItem].pvStructInfo = &swapped[cSwapped];
3247 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3248 cSwapped++;
3249 cItem++;
3250 }
3251 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
3252 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3253 }
3254 }
3255 __EXCEPT_PAGE_FAULT
3256 {
3257 SetLastError(STATUS_ACCESS_VIOLATION);
3258 }
3259 __ENDTRY
3260 return ret;
3261 }
3262
3263 BOOL CRYPT_AsnEncodePKCSSignedInfo(CRYPT_SIGNED_INFO *signedInfo, void *pvData,
3264 DWORD *pcbData)
3265 {
3266 struct AsnEncodeSequenceItem items[7] = {
3267 { &signedInfo->version, CRYPT_AsnEncodeInt, 0 },
3268 };
3269 struct DERSetDescriptor digestAlgorithmsSet = { 0 }, certSet = { 0 };
3270 struct DERSetDescriptor crlSet = { 0 }, signerSet = { 0 };
3271 struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
3272 DWORD cItem = 1, cSwapped = 0;
3273 BOOL ret = TRUE;
3274
3275 if (signedInfo->cSignerInfo)
3276 {
3277 digestAlgorithmsSet.cItems = signedInfo->cSignerInfo;
3278 digestAlgorithmsSet.items = signedInfo->rgSignerInfo;
3279 digestAlgorithmsSet.itemSize = sizeof(CMSG_SIGNER_INFO);
3280 digestAlgorithmsSet.itemOffset =
3281 offsetof(CMSG_SIGNER_INFO, HashAlgorithm);
3282 digestAlgorithmsSet.encode = CRYPT_AsnEncodeAlgorithmIdWithNullParams;
3283 items[cItem].pvStructInfo = &digestAlgorithmsSet;
3284 items[cItem].encodeFunc = CRYPT_DEREncodeItemsAsSet;
3285 cItem++;
3286 }
3287 items[cItem].pvStructInfo = &signedInfo->content;
3288 items[cItem].encodeFunc = CRYPT_AsnEncodePKCSContentInfoInternal;
3289 cItem++;
3290 if (signedInfo->cCertEncoded)
3291 {
3292 certSet.cItems = signedInfo->cCertEncoded;
3293 certSet.items = signedInfo->rgCertEncoded;
3294 certSet.itemSize = sizeof(CERT_BLOB);
3295 certSet.itemOffset = 0;
3296 certSet.encode = CRYPT_CopyEncodedBlob;
3297 swapped[cSwapped].tag = ASN_CONSTRUCTOR | ASN_CONTEXT | 0;
3298 swapped[cSwapped].pvStructInfo = &certSet;
3299 swapped[cSwapped].encodeFunc = CRYPT_DEREncodeItemsAsSet;
3300 items[cItem].pvStructInfo = &swapped[cSwapped];
3301 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3302 cSwapped++;
3303 cItem++;
3304 }
3305 if (signedInfo->cCrlEncoded)
3306 {
3307 crlSet.cItems = signedInfo->cCrlEncoded;
3308 crlSet.items = signedInfo->rgCrlEncoded;
3309 crlSet.itemSize = sizeof(CRL_BLOB);
3310 crlSet.itemOffset = 0;
3311 crlSet.encode = CRYPT_CopyEncodedBlob;
3312 swapped[cSwapped].tag = ASN_CONSTRUCTOR | ASN_CONTEXT | 1;
3313 swapped[cSwapped].pvStructInfo = &crlSet;
3314 swapped[cSwapped].encodeFunc = CRYPT_DEREncodeItemsAsSet;
3315 items[cItem].pvStructInfo = &swapped[cSwapped];
3316 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3317 cSwapped++;
3318 cItem++;
3319 }
3320 if (ret && signedInfo->cSignerInfo)
3321 {
3322 signerSet.cItems = signedInfo->cSignerInfo;
3323 signerSet.items = signedInfo->rgSignerInfo;
3324 signerSet.itemSize = sizeof(CMSG_SIGNER_INFO);
3325 signerSet.itemOffset = 0;
3326 signerSet.encode = CRYPT_AsnEncodePKCSSignerInfo;
3327 items[cItem].pvStructInfo = &signerSet;
3328 items[cItem].encodeFunc = CRYPT_DEREncodeItemsAsSet;
3329 cItem++;
3330 }
3331 if (ret)
3332 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
3333 items, cItem, 0, NULL, pvData, pcbData);
3334
3335 return ret;
3336 }
3337
3338 static CryptEncodeObjectExFunc CRYPT_GetBuiltinEncoder(DWORD dwCertEncodingType,
3339 LPCSTR lpszStructType)
3340 {
3341 CryptEncodeObjectExFunc encodeFunc = NULL;
3342
3343 if ((dwCertEncodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING
3344 && (dwCertEncodingType & CMSG_ENCODING_TYPE_MASK) != PKCS_7_ASN_ENCODING)
3345 {
3346 SetLastError(ERROR_FILE_NOT_FOUND);
3347 return NULL;
3348 }
3349
3350 if (!HIWORD(lpszStructType))
3351 {
3352 switch (LOWORD(lpszStructType))
3353 {
3354 case (WORD)X509_CERT:
3355 encodeFunc = CRYPT_AsnEncodeCert;
3356 break;
3357 case (WORD)X509_CERT_TO_BE_SIGNED:
3358 encodeFunc = CRYPT_AsnEncodeCertInfo;
3359 break;
3360 case (WORD)X509_CERT_CRL_TO_BE_SIGNED:
3361 encodeFunc = CRYPT_AsnEncodeCRLInfo;
3362 break;
3363 case (WORD)X509_EXTENSIONS:
3364 encodeFunc = CRYPT_AsnEncodeExtensions;
3365 break;
3366 case (WORD)X509_NAME_VALUE:
3367 encodeFunc = CRYPT_AsnEncodeNameValue;
3368 break;
3369 case (WORD)X509_NAME:
3370 encodeFunc = CRYPT_AsnEncodeName;
3371 break;
3372 case (WORD)X509_PUBLIC_KEY_INFO:
3373 encodeFunc = CRYPT_AsnEncodePubKeyInfo;
3374 break;
3375 case (WORD)X509_AUTHORITY_KEY_ID:
3376 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId;
3377 break;
3378 case (WORD)X509_ALTERNATE_NAME:
3379 encodeFunc = CRYPT_AsnEncodeAltName;
3380 break;
3381 case (WORD)X509_BASIC_CONSTRAINTS:
3382 encodeFunc = CRYPT_AsnEncodeBasicConstraints;
3383 break;
3384 case (WORD)X509_BASIC_CONSTRAINTS2:
3385 encodeFunc = CRYPT_AsnEncodeBasicConstraints2;
3386 break;
3387 case (WORD)RSA_CSP_PUBLICKEYBLOB:
3388 encodeFunc = CRYPT_AsnEncodeRsaPubKey;
3389 break;
3390 case (WORD)X509_UNICODE_NAME:
3391 encodeFunc = CRYPT_AsnEncodeUnicodeName;
3392 break;
3393 case (WORD)PKCS_CONTENT_INFO:
3394 encodeFunc = CRYPT_AsnEncodePKCSContentInfo;
3395 break;
3396 case (WORD)PKCS_ATTRIBUTE:
3397 encodeFunc = CRYPT_AsnEncodePKCSAttribute;
3398 break;
3399 case (WORD)X509_UNICODE_NAME_VALUE:
3400 encodeFunc = CRYPT_AsnEncodeUnicodeNameValue;
3401 break;
3402 case (WORD)X509_OCTET_STRING:
3403 encodeFunc = CRYPT_AsnEncodeOctets;
3404 break;
3405 case (WORD)X509_BITS:
3406 case (WORD)X509_KEY_USAGE:
3407 encodeFunc = CRYPT_AsnEncodeBits;
3408 break;
3409 case (WORD)X509_INTEGER:
3410 encodeFunc = CRYPT_AsnEncodeInt;
3411 break;
3412 case (WORD)X509_MULTI_BYTE_INTEGER:
3413 encodeFunc = CRYPT_AsnEncodeInteger;
3414 break;
3415 case (WORD)X509_MULTI_BYTE_UINT:
3416 encodeFunc = CRYPT_AsnEncodeUnsignedInteger;
3417 break;
3418 case (WORD)X509_ENUMERATED:
3419 encodeFunc = CRYPT_AsnEncodeEnumerated;
3420 break;
3421 case (WORD)X509_CHOICE_OF_TIME:
3422 encodeFunc = CRYPT_AsnEncodeChoiceOfTime;
3423 break;
3424 case (WORD)X509_AUTHORITY_KEY_ID2:
3425 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId2;
3426 break;
3427 case (WORD)X509_SEQUENCE_OF_ANY:
3428 encodeFunc = CRYPT_AsnEncodeSequenceOfAny;
3429 break;
3430 case (WORD)PKCS_UTC_TIME:
3431 encodeFunc = CRYPT_AsnEncodeUtcTime;
3432 break;
3433 case (WORD)X509_CRL_DIST_POINTS:
3434 encodeFunc = CRYPT_AsnEncodeCRLDistPoints;
3435 break;
3436 case (WORD)X509_ENHANCED_KEY_USAGE:
3437 encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage;
3438 break;
3439 case (WORD)PKCS_ATTRIBUTES:
3440 encodeFunc = CRYPT_AsnEncodePKCSAttributes;
3441 break;
3442 case (WORD)X509_ISSUING_DIST_POINT:
3443 encodeFunc = CRYPT_AsnEncodeIssuingDistPoint;
3444 break;
3445 case (WORD)PKCS7_SIGNER_INFO:
3446 encodeFunc = CRYPT_AsnEncodePKCSSignerInfo;
3447 break;
3448 }
3449 }
3450 else if (!strcmp(lpszStructType, szOID_CERT_EXTENSIONS))
3451 encodeFunc = CRYPT_AsnEncodeExtensions;
3452 else if (!strcmp(lpszStructType, szOID_RSA_signingTime))
3453 encodeFunc = CRYPT_AsnEncodeUtcTime;
3454 else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER))
3455 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId;
3456 else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER2))
3457 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId2;
3458 else if (!strcmp(lpszStructType, szOID_CRL_REASON_CODE))
3459 encodeFunc = CRYPT_AsnEncodeEnumerated;
3460 else if (!strcmp(lpszStructType, szOID_KEY_USAGE))
3461 encodeFunc = CRYPT_AsnEncodeBits;
3462 else if (!strcmp(lpszStructType, szOID_SUBJECT_KEY_IDENTIFIER))
3463 encodeFunc = CRYPT_AsnEncodeOctets;
3464 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS))
3465 encodeFunc = CRYPT_AsnEncodeBasicConstraints;
3466 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS2))
3467 encodeFunc = CRYPT_AsnEncodeBasicConstraints2;
3468 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME))
3469 encodeFunc = CRYPT_AsnEncodeAltName;
3470 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME2))
3471 encodeFunc = CRYPT_AsnEncodeAltName;
3472 else if (!strcmp(lpszStructType, szOID_NEXT_UPDATE_LOCATION))
3473 encodeFunc = CRYPT_AsnEncodeAltName;
3474 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME))
3475 encodeFunc = CRYPT_AsnEncodeAltName;
3476 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME2))
3477 encodeFunc = CRYPT_AsnEncodeAltName;
3478 else if (!strcmp(lpszStructType, szOID_CRL_DIST_POINTS))
3479 encodeFunc = CRYPT_AsnEncodeCRLDistPoints;
3480 else if (!strcmp(lpszStructType, szOID_ENHANCED_KEY_USAGE))
3481 encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage;
3482 else if (!strcmp(lpszStructType, szOID_ISSUING_DIST_POINT))
3483 encodeFunc = CRYPT_AsnEncodeIssuingDistPoint;
3484 return encodeFunc;
3485 }
3486
3487 static CryptEncodeObjectFunc CRYPT_LoadEncoderFunc(DWORD dwCertEncodingType,
3488 LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
3489 {
3490 static HCRYPTOIDFUNCSET set = NULL;
3491 CryptEncodeObjectFunc encodeFunc = NULL;
3492
3493 if (!set)
3494 set = CryptInitOIDFunctionSet(CRYPT_OID_ENCODE_OBJECT_FUNC, 0);
3495 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
3496 (void **)&encodeFunc, hFunc);
3497 return encodeFunc;
3498 }
3499
3500 static CryptEncodeObjectExFunc CRYPT_LoadEncoderExFunc(DWORD dwCertEncodingType,
3501 LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
3502 {
3503 static HCRYPTOIDFUNCSET set = NULL;
3504 CryptEncodeObjectExFunc encodeFunc = NULL;
3505
3506 if (!set)
3507 set = CryptInitOIDFunctionSet(CRYPT_OID_ENCODE_OBJECT_EX_FUNC, 0);
3508 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
3509 (void **)&encodeFunc, hFunc);
3510 return encodeFunc;
3511 }
3512
3513 BOOL WINAPI CryptEncodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType,
3514 const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
3515 {
3516 BOOL ret = FALSE;
3517 HCRYPTOIDFUNCADDR hFunc = NULL;
3518 CryptEncodeObjectFunc pCryptEncodeObject = NULL;
3519 CryptEncodeObjectExFunc pCryptEncodeObjectEx = NULL;
3520
3521 TRACE_(crypt)("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
3522 debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
3523 pcbEncoded);
3524
3525 if (!pbEncoded && !pcbEncoded)
3526 {
3527 SetLastError(ERROR_INVALID_PARAMETER);
3528 return FALSE;
3529 }
3530
3531 if (!(pCryptEncodeObjectEx = CRYPT_GetBuiltinEncoder(dwCertEncodingType,
3532 lpszStructType)))
3533 {
3534 TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n",
3535 debugstr_a(lpszStructType));
3536 pCryptEncodeObject = CRYPT_LoadEncoderFunc(dwCertEncodingType,
3537 lpszStructType, &hFunc);
3538 if (!pCryptEncodeObject)
3539 pCryptEncodeObjectEx = CRYPT_LoadEncoderExFunc(dwCertEncodingType,
3540 lpszStructType, &hFunc);
3541 }
3542 if (pCryptEncodeObject)
3543 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
3544 pvStructInfo, pbEncoded, pcbEncoded);
3545 else if (pCryptEncodeObjectEx)
3546 ret = pCryptEncodeObjectEx(dwCertEncodingType, lpszStructType,
3547 pvStructInfo, 0, NULL, pbEncoded, pcbEncoded);
3548 if (hFunc)
3549 CryptFreeOIDFunctionAddress(hFunc, 0);
3550 TRACE_(crypt)("returning %d\n", ret);
3551 return ret;
3552 }
3553
3554 BOOL WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType,
3555 const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara,
3556 void *pvEncoded, DWORD *pcbEncoded)
3557 {
3558 BOOL ret = FALSE;
3559 HCRYPTOIDFUNCADDR hFunc = NULL;
3560 CryptEncodeObjectExFunc encodeFunc = NULL;
3561
3562 TRACE_(crypt)("(0x%08x, %s, %p, 0x%08x, %p, %p, %p)\n", dwCertEncodingType,
3563 debugstr_a(lpszStructType), pvStructInfo, dwFlags, pEncodePara,
3564 pvEncoded, pcbEncoded);
3565
3566 if (!pvEncoded && !pcbEncoded)
3567 {
3568 SetLastError(ERROR_INVALID_PARAMETER);
3569 return FALSE;
3570 }
3571
3572 SetLastError(NOERROR);
3573 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG && pvEncoded)
3574 *(BYTE **)pvEncoded = NULL;
3575 encodeFunc = CRYPT_GetBuiltinEncoder(dwCertEncodingType, lpszStructType);
3576 if (!encodeFunc)
3577 {
3578 TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n",
3579 debugstr_a(lpszStructType));
3580 encodeFunc = CRYPT_LoadEncoderExFunc(dwCertEncodingType, lpszStructType,
3581 &hFunc);
3582 }
3583 if (encodeFunc)
3584 ret = encodeFunc(dwCertEncodingType, lpszStructType, pvStructInfo,
3585 dwFlags, pEncodePara, pvEncoded, pcbEncoded);
3586 else
3587 {
3588 CryptEncodeObjectFunc pCryptEncodeObject =
3589 CRYPT_LoadEncoderFunc(dwCertEncodingType, lpszStructType, &hFunc);
3590
3591 if (pCryptEncodeObject)
3592 {
3593 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3594 {
3595 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
3596 pvStructInfo, NULL, pcbEncoded);
3597 if (ret && (ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
3598 pvEncoded, pcbEncoded, *pcbEncoded)))
3599 ret = pCryptEncodeObject(dwCertEncodingType,
3600 lpszStructType, pvStructInfo, *(BYTE **)pvEncoded,
3601 pcbEncoded);
3602 }
3603 else
3604 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
3605 pvStructInfo, pvEncoded, pcbEncoded);
3606 }
3607 }
3608 if (hFunc)
3609 CryptFreeOIDFunctionAddress(hFunc, 0);
3610 TRACE_(crypt)("returning %d\n", ret);
3611 return ret;
3612 }
3613
3614 BOOL WINAPI CryptExportPublicKeyInfo(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec,
3615 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
3616 {
3617 return CryptExportPublicKeyInfoEx(hCryptProv, dwKeySpec, dwCertEncodingType,
3618 NULL, 0, NULL, pInfo, pcbInfo);
3619 }
3620
3621 static BOOL WINAPI CRYPT_ExportRsaPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv,
3622 DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId,
3623 DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
3624 {
3625 BOOL ret;
3626 HCRYPTKEY key;
3627 static CHAR oid[] = szOID_RSA_RSA;
3628
3629 TRACE_(crypt)("(%08lx, %d, %08x, %s, %08x, %p, %p, %p)\n", hCryptProv,
3630 dwKeySpec, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags,
3631 pvAuxInfo, pInfo, pcbInfo);
3632
3633 if (!pszPublicKeyObjId)
3634 pszPublicKeyObjId = oid;
3635 if ((ret = CryptGetUserKey(hCryptProv, dwKeySpec, &key)))
3636 {
3637 DWORD keySize = 0;
3638
3639 ret = CryptExportKey(key, 0, PUBLICKEYBLOB, 0, NULL, &keySize);
3640 if (ret)
3641 {
3642 LPBYTE pubKey = CryptMemAlloc(keySize);
3643
3644 if (pubKey)
3645 {
3646 ret = CryptExportKey(key, 0, PUBLICKEYBLOB, 0, pubKey,
3647 &keySize);
3648 if (ret)
3649 {
3650 DWORD encodedLen = 0;
3651
3652 ret = CryptEncodeObject(dwCertEncodingType,
3653 RSA_CSP_PUBLICKEYBLOB, pubKey, NULL, &encodedLen);
3654 if (ret)
3655 {
3656 DWORD sizeNeeded = sizeof(CERT_PUBLIC_KEY_INFO) +
3657 strlen(pszPublicKeyObjId) + 1 + encodedLen;
3658
3659 if (!pInfo)
3660 *pcbInfo = sizeNeeded;
3661 else if (*pcbInfo < sizeNeeded)
3662 {
3663 SetLastError(ERROR_MORE_DATA);
3664 *pcbInfo = sizeNeeded;
3665 ret = FALSE;
3666 }
3667 else
3668 {
3669 pInfo->Algorithm.pszObjId = (char *)pInfo +
3670 sizeof(CERT_PUBLIC_KEY_INFO);
3671 lstrcpyA(pInfo->Algorithm.pszObjId,
3672 pszPublicKeyObjId);
3673 pInfo->Algorithm.Parameters.cbData = 0;
3674 pInfo->Algorithm.Parameters.pbData = NULL;
3675 pInfo->PublicKey.pbData =
3676 (BYTE *)pInfo->Algorithm.pszObjId
3677 + lstrlenA(pInfo->Algorithm.pszObjId) + 1;
3678 pInfo->PublicKey.cbData = encodedLen;
3679 pInfo->PublicKey.cUnusedBits = 0;
3680 ret = CryptEncodeObject(dwCertEncodingType,
3681 RSA_CSP_PUBLICKEYBLOB, pubKey,
3682 pInfo->PublicKey.pbData, &pInfo->PublicKey.cbData);
3683 }
3684 }
3685 }
3686 CryptMemFree(pubKey);
3687 }
3688 else
3689 ret = FALSE;
3690 }
3691 CryptDestroyKey(key);
3692 }
3693 return ret;
3694 }
3695
3696 typedef BOOL (WINAPI *ExportPublicKeyInfoExFunc)(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv,
3697 DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId,
3698 DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo);
3699
3700 BOOL WINAPI CryptExportPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec,
3701 DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags,
3702 void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
3703 {
3704 static HCRYPTOIDFUNCSET set = NULL;
3705 BOOL ret;
3706 ExportPublicKeyInfoExFunc exportFunc = NULL;
3707 HCRYPTOIDFUNCADDR hFunc = NULL;
3708
3709 TRACE_(crypt)("(%08lx, %d, %08x, %s, %08x, %p, %p, %p)\n", hCryptProv,
3710 dwKeySpec, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags,
3711 pvAuxInfo, pInfo, pcbInfo);
3712
3713 if (!hCryptProv)
3714 {
3715 SetLastError(ERROR_INVALID_PARAMETER);
3716 return FALSE;
3717 }
3718
3719 if (pszPublicKeyObjId)
3720 {
3721 if (!set)
3722 set = CryptInitOIDFunctionSet(CRYPT_OID_EXPORT_PUBLIC_KEY_INFO_FUNC,
3723 0);
3724 CryptGetOIDFunctionAddress(set, dwCertEncodingType, pszPublicKeyObjId,
3725 0, (void **)&exportFunc, &hFunc);
3726 }
3727 if (!exportFunc)
3728 exportFunc = CRYPT_ExportRsaPublicKeyInfoEx;
3729 ret = exportFunc(hCryptProv, dwKeySpec, dwCertEncodingType,
3730 pszPublicKeyObjId, dwFlags, pvAuxInfo, pInfo, pcbInfo);
3731 if (hFunc)
3732 CryptFreeOIDFunctionAddress(hFunc, 0);
3733 return ret;
3734 }
3735
3736 BOOL WINAPI CryptImportPublicKeyInfo(HCRYPTPROV hCryptProv,
3737 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, HCRYPTKEY *phKey)
3738 {
3739 return CryptImportPublicKeyInfoEx(hCryptProv, dwCertEncodingType, pInfo,
3740 0, 0, NULL, phKey);
3741 }
3742
3743 static BOOL WINAPI CRYPT_ImportRsaPublicKeyInfoEx(HCRYPTPROV hCryptProv,
3744 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
3745 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey)
3746 {
3747 BOOL ret;
3748 DWORD pubKeySize = 0;
3749
3750 TRACE_(crypt)("(%08lx, %d, %p, %d, %08x, %p, %p)\n", hCryptProv,
3751 dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
3752
3753 ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB,
3754 pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, NULL, &pubKeySize);
3755 if (ret)
3756 {
3757 LPBYTE pubKey = CryptMemAlloc(pubKeySize);
3758
3759 if (pubKey)
3760 {
3761 ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB,
3762 pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, pubKey,
3763 &pubKeySize);
3764 if (ret)
3765 ret = CryptImportKey(hCryptProv, pubKey, pubKeySize, 0, 0,
3766 phKey);
3767 CryptMemFree(pubKey);
3768 }
3769 else
3770 ret = FALSE;
3771 }
3772 return ret;
3773 }
3774
3775 typedef BOOL (WINAPI *ImportPublicKeyInfoExFunc)(HCRYPTPROV hCryptProv,
3776 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
3777 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey);
3778
3779 BOOL WINAPI CryptImportPublicKeyInfoEx(HCRYPTPROV hCryptProv,
3780 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
3781 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey)
3782 {
3783 static HCRYPTOIDFUNCSET set = NULL;
3784 BOOL ret;
3785 ImportPublicKeyInfoExFunc importFunc = NULL;
3786 HCRYPTOIDFUNCADDR hFunc = NULL;
3787
3788 TRACE_(crypt)("(%08lx, %d, %p, %d, %08x, %p, %p)\n", hCryptProv,
3789 dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
3790
3791 if (!set)
3792 set = CryptInitOIDFunctionSet(CRYPT_OID_IMPORT_PUBLIC_KEY_INFO_FUNC, 0);
3793 CryptGetOIDFunctionAddress(set, dwCertEncodingType,
3794 pInfo->Algorithm.pszObjId, 0, (void **)&importFunc, &hFunc);
3795 if (!importFunc)
3796 importFunc = CRYPT_ImportRsaPublicKeyInfoEx;
3797 ret = importFunc(hCryptProv, dwCertEncodingType, pInfo, aiKeyAlg, dwFlags,
3798 pvAuxInfo, phKey);
3799 if (hFunc)
3800 CryptFreeOIDFunctionAddress(hFunc, 0);
3801 return ret;
3802 }
Maarten's multimedia branch