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