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