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