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