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