?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 0.9.14.
[wine/multimedia.git] / dlls / crypt32 / encode.c
blobee1c9cc93322c627394eec6abf035a2dbd3bbbd8
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 "excpt.h"
44 #include "wincrypt.h"
45 #include "winreg.h"
46 #include "snmp.h"
47 #include "wine/debug.h"
48 #include "wine/exception.h"
49 #include "crypt32_private.h"
50
51 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
52
53 typedef BOOL (WINAPI *CryptEncodeObjectFunc)(DWORD, LPCSTR, const void *,
54 BYTE *, DWORD *);
55 typedef BOOL (WINAPI *CryptEncodeObjectExFunc)(DWORD, LPCSTR, const void *,
56 DWORD, PCRYPT_ENCODE_PARA, BYTE *, DWORD *);
57
58 /* Prototypes for built-in encoders. They follow the Ex style prototypes.
59 * The dwCertEncodingType and lpszStructType are ignored by the built-in
60 * functions, but the parameters are retained to simplify CryptEncodeObjectEx,
61 * since it must call functions in external DLLs that follow these signatures.
62 */
63 static BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
64 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
65 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
66 static BOOL WINAPI CRYPT_AsnEncodeExtensions(DWORD dwCertEncodingType,
67 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
68 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
69 static BOOL WINAPI CRYPT_AsnEncodeSequenceOfAny(DWORD dwCertEncodingType,
70 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
71 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
72 static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
73 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
74 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
75 static BOOL WINAPI CRYPT_AsnEncodePubKeyInfo(DWORD dwCertEncodingType,
76 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
77 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
78 static BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
79 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
80 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
81 static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType,
82 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
83 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
84 static BOOL WINAPI CRYPT_AsnEncodeBitsSwapBytes(DWORD dwCertEncodingType,
85 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
86 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
87 static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType,
88 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
89 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
90 static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType,
91 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
92 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
93 static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType,
94 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
95 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
96 static BOOL WINAPI CRYPT_AsnEncodeChoiceOfTime(DWORD dwCertEncodingType,
97 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
98 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
99
100 BOOL WINAPI CryptEncodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType,
101 const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
102 {
103 static HCRYPTOIDFUNCSET set = NULL;
104 BOOL ret = FALSE;
105 HCRYPTOIDFUNCADDR hFunc;
106 CryptEncodeObjectFunc pCryptEncodeObject;
107
108 TRACE("(0x%08lx, %s, %p, %p, %p)\n", dwCertEncodingType,
109 debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
110 pcbEncoded);
111
112 if (!pbEncoded && !pcbEncoded)
113 {
114 SetLastError(ERROR_INVALID_PARAMETER);
115 return FALSE;
116 }
117
118 /* Try registered DLL first.. */
119 if (!set)
120 set = CryptInitOIDFunctionSet(CRYPT_OID_ENCODE_OBJECT_FUNC, 0);
121 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
122 (void **)&pCryptEncodeObject, &hFunc);
123 if (pCryptEncodeObject)
124 {
125 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
126 pvStructInfo, pbEncoded, pcbEncoded);
127 CryptFreeOIDFunctionAddress(hFunc, 0);
128 }
129 else
130 {
131 /* If not, use CryptEncodeObjectEx */
132 ret = CryptEncodeObjectEx(dwCertEncodingType, lpszStructType,
133 pvStructInfo, 0, NULL, pbEncoded, pcbEncoded);
134 }
135 return ret;
136 }
137
138 /* Helper function to check *pcbEncoded, set it to the required size, and
139 * optionally to allocate memory. Assumes pbEncoded is not NULL.
140 * If CRYPT_ENCODE_ALLOC_FLAG is set in dwFlags, *pbEncoded will be set to a
141 * pointer to the newly allocated memory.
142 */
143 static BOOL CRYPT_EncodeEnsureSpace(DWORD dwFlags,
144 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded,
145 DWORD bytesNeeded)
146 {
147 BOOL ret = TRUE;
148
149 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
150 {
151 if (pEncodePara && pEncodePara->pfnAlloc)
152 *(BYTE **)pbEncoded = pEncodePara->pfnAlloc(bytesNeeded);
153 else
154 *(BYTE **)pbEncoded = LocalAlloc(0, bytesNeeded);
155 if (!*(BYTE **)pbEncoded)
156 ret = FALSE;
157 else
158 *pcbEncoded = bytesNeeded;
159 }
160 else if (bytesNeeded > *pcbEncoded)
161 {
162 *pcbEncoded = bytesNeeded;
163 SetLastError(ERROR_MORE_DATA);
164 ret = FALSE;
165 }
166 return ret;
167 }
168
169 static BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded)
170 {
171 DWORD bytesNeeded, significantBytes = 0;
172
173 if (len <= 0x7f)
174 bytesNeeded = 1;
175 else
176 {
177 DWORD temp;
178
179 for (temp = len, significantBytes = sizeof(temp); !(temp & 0xff000000);
180 temp <<= 8, significantBytes--)
181 ;
182 bytesNeeded = significantBytes + 1;
183 }
184 if (!pbEncoded)
185 {
186 *pcbEncoded = bytesNeeded;
187 return TRUE;
188 }
189 if (*pcbEncoded < bytesNeeded)
190 {
191 SetLastError(ERROR_MORE_DATA);
192 return FALSE;
193 }
194 if (len <= 0x7f)
195 *pbEncoded = (BYTE)len;
196 else
197 {
198 DWORD i;
199
200 *pbEncoded++ = significantBytes | 0x80;
201 for (i = 0; i < significantBytes; i++)
202 {
203 *(pbEncoded + significantBytes - i - 1) = (BYTE)(len & 0xff);
204 len >>= 8;
205 }
206 }
207 *pcbEncoded = bytesNeeded;
208 return TRUE;
209 }
210
211 struct AsnEncodeSequenceItem
212 {
213 const void *pvStructInfo;
214 CryptEncodeObjectExFunc encodeFunc;
215 DWORD size; /* used during encoding, not for your use */
216 };
217
218 static BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
219 struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags,
220 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
221 {
222 BOOL ret;
223 DWORD i, dataLen = 0;
224
225 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", items, cItem, dwFlags, pEncodePara,
226 pbEncoded, *pcbEncoded);
227 for (i = 0, ret = TRUE; ret && i < cItem; i++)
228 {
229 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
230 items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL,
231 NULL, &items[i].size);
232 /* Some functions propagate their errors through the size */
233 if (!ret)
234 *pcbEncoded = items[i].size;
235 dataLen += items[i].size;
236 }
237 if (ret)
238 {
239 DWORD lenBytes, bytesNeeded;
240
241 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
242 bytesNeeded = 1 + lenBytes + dataLen;
243 if (!pbEncoded)
244 *pcbEncoded = bytesNeeded;
245 else
246 {
247 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
248 pcbEncoded, bytesNeeded)))
249 {
250 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
251 pbEncoded = *(BYTE **)pbEncoded;
252 *pbEncoded++ = ASN_SEQUENCE;
253 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
254 pbEncoded += lenBytes;
255 for (i = 0; ret && i < cItem; i++)
256 {
257 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
258 items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG,
259 NULL, pbEncoded, &items[i].size);
260 /* Some functions propagate their errors through the size */
261 if (!ret)
262 *pcbEncoded = items[i].size;
263 pbEncoded += items[i].size;
264 }
265 }
266 }
267 }
268 TRACE("returning %d (%08lx)\n", ret, GetLastError());
269 return ret;
270 }
271
272 struct AsnConstructedItem
273 {
274 BYTE tag;
275 const void *pvStructInfo;
276 CryptEncodeObjectExFunc encodeFunc;
277 };
278
279 static BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType,
280 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
281 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
282 {
283 BOOL ret;
284 const struct AsnConstructedItem *item =
285 (const struct AsnConstructedItem *)pvStructInfo;
286 DWORD len;
287
288 if ((ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
289 item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &len)))
290 {
291 DWORD dataLen, bytesNeeded;
292
293 CRYPT_EncodeLen(len, NULL, &dataLen);
294 bytesNeeded = 1 + dataLen + len;
295 if (!pbEncoded)
296 *pcbEncoded = bytesNeeded;
297 else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
298 pbEncoded, pcbEncoded, bytesNeeded)))
299 {
300 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
301 pbEncoded = *(BYTE **)pbEncoded;
302 *pbEncoded++ = ASN_CONTEXT | ASN_CONSTRUCTOR | item->tag;
303 CRYPT_EncodeLen(len, pbEncoded, &dataLen);
304 pbEncoded += dataLen;
305 ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
306 item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL,
307 pbEncoded, &len);
308 if (!ret)
309 {
310 /* Some functions propagate their errors through the size */
311 *pcbEncoded = len;
312 }
313 }
314 }
315 else
316 {
317 /* Some functions propagate their errors through the size */
318 *pcbEncoded = len;
319 }
320 return ret;
321 }
322
323 struct AsnEncodeTagSwappedItem
324 {
325 BYTE tag;
326 const void *pvStructInfo;
327 CryptEncodeObjectExFunc encodeFunc;
328 };
329
330 /* Sort of a wacky hack, it encodes something using the struct
331 * AsnEncodeTagSwappedItem's encodeFunc, then replaces the tag byte with the tag
332 * given in the struct AsnEncodeTagSwappedItem.
333 */
334 static BOOL WINAPI CRYPT_AsnEncodeSwapTag(DWORD dwCertEncodingType,
335 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
336 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
337 {
338 BOOL ret;
339 const struct AsnEncodeTagSwappedItem *item =
340 (const struct AsnEncodeTagSwappedItem *)pvStructInfo;
341
342 ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
343 item->pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
344 if (ret && pbEncoded)
345 *pbEncoded = item->tag;
346 return ret;
347 }
348
349 static BOOL WINAPI CRYPT_AsnEncodeCertVersion(DWORD dwCertEncodingType,
350 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
351 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
352 {
353 const DWORD *ver = (const DWORD *)pvStructInfo;
354 BOOL ret;
355
356 /* CERT_V1 is not encoded */
357 if (*ver == CERT_V1)
358 {
359 *pcbEncoded = 0;
360 ret = TRUE;
361 }
362 else
363 {
364 struct AsnConstructedItem item = { 0, ver, CRYPT_AsnEncodeInt };
365
366 ret = CRYPT_AsnEncodeConstructed(dwCertEncodingType, X509_INTEGER,
367 &item, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
368 }
369 return ret;
370 }
371
372 static BOOL WINAPI CRYPT_CopyEncodedBlob(DWORD dwCertEncodingType,
373 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
374 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
375 {
376 const CRYPT_DER_BLOB *blob = (const CRYPT_DER_BLOB *)pvStructInfo;
377 BOOL ret;
378
379 if (!pbEncoded)
380 {
381 *pcbEncoded = blob->cbData;
382 ret = TRUE;
383 }
384 else if (*pcbEncoded < blob->cbData)
385 {
386 *pcbEncoded = blob->cbData;
387 SetLastError(ERROR_MORE_DATA);
388 ret = FALSE;
389 }
390 else
391 {
392 if (blob->cbData)
393 memcpy(pbEncoded, blob->pbData, blob->cbData);
394 *pcbEncoded = blob->cbData;
395 ret = TRUE;
396 }
397 return ret;
398 }
399
400 static BOOL WINAPI CRYPT_AsnEncodeValidity(DWORD dwCertEncodingType,
401 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
402 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
403 {
404 BOOL ret;
405 /* This has two filetimes in a row, a NotBefore and a NotAfter */
406 const FILETIME *timePtr = (const FILETIME *)pvStructInfo;
407 struct AsnEncodeSequenceItem items[] = {
408 { timePtr++, CRYPT_AsnEncodeChoiceOfTime, 0 },
409 { timePtr, CRYPT_AsnEncodeChoiceOfTime, 0 },
410 };
411
412 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
413 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
414 pcbEncoded);
415 return ret;
416 }
417
418 static BOOL WINAPI CRYPT_AsnEncodeAlgorithmId(
419 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
420 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
421 DWORD *pcbEncoded)
422 {
423 const CRYPT_ALGORITHM_IDENTIFIER *algo =
424 (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
425 BOOL ret;
426 struct AsnEncodeSequenceItem items[] = {
427 { algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
428 { &algo->Parameters, CRYPT_CopyEncodedBlob, 0 },
429 };
430
431 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
432 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
433 pcbEncoded);
434 return ret;
435 }
436
437 static BOOL WINAPI CRYPT_AsnEncodePubKeyInfo(DWORD dwCertEncodingType,
438 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
439 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
440 {
441 BOOL ret;
442
443 __TRY
444 {
445 const CERT_PUBLIC_KEY_INFO *info =
446 (const CERT_PUBLIC_KEY_INFO *)pvStructInfo;
447 struct AsnEncodeSequenceItem items[] = {
448 { &info->Algorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
449 { &info->PublicKey, CRYPT_AsnEncodeBits, 0 },
450 };
451
452 TRACE("Encoding public key with OID %s\n",
453 debugstr_a(info->Algorithm.pszObjId));
454 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
455 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
456 pcbEncoded);
457 }
458 __EXCEPT_PAGE_FAULT
459 {
460 SetLastError(STATUS_ACCESS_VIOLATION);
461 ret = FALSE;
462 }
463 __ENDTRY
464 return ret;
465 }
466
467 static BOOL WINAPI CRYPT_AsnEncodeCert(DWORD dwCertEncodingType,
468 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
469 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
470 {
471 BOOL ret;
472
473 __TRY
474 {
475 const CERT_SIGNED_CONTENT_INFO *info =
476 (const CERT_SIGNED_CONTENT_INFO *)pvStructInfo;
477 struct AsnEncodeSequenceItem items[] = {
478 { &info->ToBeSigned, CRYPT_CopyEncodedBlob, 0 },
479 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
480 { &info->Signature, CRYPT_AsnEncodeBitsSwapBytes, 0 },
481 };
482
483 if (dwFlags & CRYPT_ENCODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG)
484 items[2].encodeFunc = CRYPT_AsnEncodeBits;
485 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
486 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
487 pcbEncoded);
488 }
489 __EXCEPT_PAGE_FAULT
490 {
491 SetLastError(STATUS_ACCESS_VIOLATION);
492 ret = FALSE;
493 }
494 __ENDTRY
495 return ret;
496 }
497
498 /* Like in Windows, this blithely ignores the validity of the passed-in
499 * CERT_INFO, and just encodes it as-is. The resulting encoded data may not
500 * decode properly, see CRYPT_AsnDecodeCertInfo.
501 */
502 static BOOL WINAPI CRYPT_AsnEncodeCertInfo(DWORD dwCertEncodingType,
503 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
504 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
505 {
506 BOOL ret;
507
508 __TRY
509 {
510 const CERT_INFO *info = (const CERT_INFO *)pvStructInfo;
511 struct AsnEncodeSequenceItem items[10] = {
512 { &info->dwVersion, CRYPT_AsnEncodeCertVersion, 0 },
513 { &info->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
514 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
515 { &info->Issuer, CRYPT_CopyEncodedBlob, 0 },
516 { &info->NotBefore, CRYPT_AsnEncodeValidity, 0 },
517 { &info->Subject, CRYPT_CopyEncodedBlob, 0 },
518 { &info->SubjectPublicKeyInfo, CRYPT_AsnEncodePubKeyInfo, 0 },
519 { 0 }
520 };
521 struct AsnConstructedItem constructed[3] = { { 0 } };
522 DWORD cItem = 7, cConstructed = 0;
523
524 if (info->IssuerUniqueId.cbData)
525 {
526 constructed[cConstructed].tag = 1;
527 constructed[cConstructed].pvStructInfo = &info->IssuerUniqueId;
528 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeBits;
529 items[cItem].pvStructInfo = &constructed[cConstructed];
530 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
531 cConstructed++;
532 cItem++;
533 }
534 if (info->SubjectUniqueId.cbData)
535 {
536 constructed[cConstructed].tag = 2;
537 constructed[cConstructed].pvStructInfo = &info->SubjectUniqueId;
538 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeBits;
539 items[cItem].pvStructInfo = &constructed[cConstructed];
540 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
541 cConstructed++;
542 cItem++;
543 }
544 if (info->cExtension)
545 {
546 constructed[cConstructed].tag = 3;
547 constructed[cConstructed].pvStructInfo = &info->cExtension;
548 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeExtensions;
549 items[cItem].pvStructInfo = &constructed[cConstructed];
550 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
551 cConstructed++;
552 cItem++;
553 }
554
555 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
556 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
557 }
558 __EXCEPT_PAGE_FAULT
559 {
560 SetLastError(STATUS_ACCESS_VIOLATION);
561 ret = FALSE;
562 }
563 __ENDTRY
564 return ret;
565 }
566
567 static BOOL WINAPI CRYPT_AsnEncodeCRLEntry(const CRL_ENTRY *entry,
568 BYTE *pbEncoded, DWORD *pcbEncoded)
569 {
570 struct AsnEncodeSequenceItem items[3] = {
571 { &entry->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
572 { &entry->RevocationDate, CRYPT_AsnEncodeChoiceOfTime, 0 },
573 { 0 }
574 };
575 DWORD cItem = 2;
576 BOOL ret;
577
578 TRACE("%p, %p, %p\n", entry, pbEncoded, pcbEncoded);
579
580 if (entry->cExtension)
581 {
582 items[cItem].pvStructInfo = &entry->cExtension;
583 items[cItem].encodeFunc = CRYPT_AsnEncodeExtensions;
584 cItem++;
585 }
586
587 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
588 pbEncoded, pcbEncoded);
589
590 TRACE("returning %d (%08lx)\n", ret, GetLastError());
591 return ret;
592 }
593
594 static BOOL WINAPI CRYPT_AsnEncodeCRLEntries(DWORD dwCertEncodingType,
595 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
596 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
597 {
598 DWORD cCRLEntry = *(const DWORD *)pvStructInfo;
599 DWORD bytesNeeded, dataLen, lenBytes, i;
600 const CRL_ENTRY *rgCRLEntry = *(const CRL_ENTRY **)
601 ((const BYTE *)pvStructInfo + sizeof(DWORD));
602 BOOL ret = TRUE;
603
604 for (i = 0, dataLen = 0; ret && i < cCRLEntry; i++)
605 {
606 DWORD size;
607
608 ret = CRYPT_AsnEncodeCRLEntry(&rgCRLEntry[i], NULL, &size);
609 if (ret)
610 dataLen += size;
611 }
612 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
613 bytesNeeded = 1 + lenBytes + dataLen;
614 if (!pbEncoded)
615 *pcbEncoded = bytesNeeded;
616 else
617 {
618 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
619 pcbEncoded, bytesNeeded)))
620 {
621 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
622 pbEncoded = *(BYTE **)pbEncoded;
623 *pbEncoded++ = ASN_SEQUENCEOF;
624 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
625 pbEncoded += lenBytes;
626 for (i = 0; i < cCRLEntry; i++)
627 {
628 DWORD size = dataLen;
629
630 ret = CRYPT_AsnEncodeCRLEntry(&rgCRLEntry[i], pbEncoded, &size);
631 pbEncoded += size;
632 dataLen -= size;
633 }
634 }
635 }
636 return ret;
637 }
638
639 static BOOL WINAPI CRYPT_AsnEncodeCRLVersion(DWORD dwCertEncodingType,
640 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
641 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
642 {
643 const DWORD *ver = (const DWORD *)pvStructInfo;
644 BOOL ret;
645
646 /* CRL_V1 is not encoded */
647 if (*ver == CRL_V1)
648 {
649 *pcbEncoded = 0;
650 ret = TRUE;
651 }
652 else
653 ret = CRYPT_AsnEncodeInt(dwCertEncodingType, X509_INTEGER, ver,
654 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
655 return ret;
656 }
657
658 /* Like in Windows, this blithely ignores the validity of the passed-in
659 * CRL_INFO, and just encodes it as-is. The resulting encoded data may not
660 * decode properly, see CRYPT_AsnDecodeCRLInfo.
661 */
662 static BOOL WINAPI CRYPT_AsnEncodeCRLInfo(DWORD dwCertEncodingType,
663 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
664 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
665 {
666 BOOL ret;
667
668 __TRY
669 {
670 const CRL_INFO *info = (const CRL_INFO *)pvStructInfo;
671 struct AsnEncodeSequenceItem items[7] = {
672 { &info->dwVersion, CRYPT_AsnEncodeCRLVersion, 0 },
673 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
674 { &info->Issuer, CRYPT_CopyEncodedBlob, 0 },
675 { &info->ThisUpdate, CRYPT_AsnEncodeChoiceOfTime, 0 },
676 { 0 }
677 };
678 DWORD cItem = 4;
679
680 if (info->NextUpdate.dwLowDateTime || info->NextUpdate.dwHighDateTime)
681 {
682 items[cItem].pvStructInfo = &info->NextUpdate;
683 items[cItem].encodeFunc = CRYPT_AsnEncodeChoiceOfTime;
684 cItem++;
685 }
686 if (info->cCRLEntry)
687 {
688 items[cItem].pvStructInfo = &info->cCRLEntry;
689 items[cItem].encodeFunc = CRYPT_AsnEncodeCRLEntries;
690 cItem++;
691 }
692 if (info->cExtension)
693 {
694 items[cItem].pvStructInfo = &info->cExtension;
695 items[cItem].encodeFunc = CRYPT_AsnEncodeExtensions;
696 cItem++;
697 }
698
699 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
700 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
701 }
702 __EXCEPT_PAGE_FAULT
703 {
704 SetLastError(STATUS_ACCESS_VIOLATION);
705 ret = FALSE;
706 }
707 __ENDTRY
708 return ret;
709 }
710
711 static BOOL CRYPT_AsnEncodeExtension(CERT_EXTENSION *ext, BYTE *pbEncoded,
712 DWORD *pcbEncoded)
713 {
714 BOOL ret;
715 struct AsnEncodeSequenceItem items[3] = {
716 { ext->pszObjId, CRYPT_AsnEncodeOid, 0 },
717 { NULL, NULL, 0 },
718 { NULL, NULL, 0 },
719 };
720 DWORD cItem = 1;
721
722 TRACE("%p, %p, %ld\n", ext, pbEncoded, *pcbEncoded);
723
724 if (ext->fCritical)
725 {
726 items[cItem].pvStructInfo = &ext->fCritical;
727 items[cItem].encodeFunc = CRYPT_AsnEncodeBool;
728 cItem++;
729 }
730 items[cItem].pvStructInfo = &ext->Value;
731 items[cItem].encodeFunc = CRYPT_AsnEncodeOctets;
732 cItem++;
733
734 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
735 pbEncoded, pcbEncoded);
736 TRACE("returning %d (%08lx)\n", ret, GetLastError());
737 return ret;
738 }
739
740 static BOOL WINAPI CRYPT_AsnEncodeExtensions(DWORD dwCertEncodingType,
741 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
742 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
743 {
744 BOOL ret;
745
746 __TRY
747 {
748 DWORD bytesNeeded, dataLen, lenBytes, i;
749 const CERT_EXTENSIONS *exts = (const CERT_EXTENSIONS *)pvStructInfo;
750
751 ret = TRUE;
752 for (i = 0, dataLen = 0; ret && i < exts->cExtension; i++)
753 {
754 DWORD size;
755
756 ret = CRYPT_AsnEncodeExtension(&exts->rgExtension[i], NULL, &size);
757 if (ret)
758 dataLen += size;
759 }
760 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
761 bytesNeeded = 1 + lenBytes + dataLen;
762 if (!pbEncoded)
763 *pcbEncoded = bytesNeeded;
764 else
765 {
766 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
767 pcbEncoded, bytesNeeded)))
768 {
769 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
770 pbEncoded = *(BYTE **)pbEncoded;
771 *pbEncoded++ = ASN_SEQUENCEOF;
772 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
773 pbEncoded += lenBytes;
774 for (i = 0; i < exts->cExtension; i++)
775 {
776 DWORD size = dataLen;
777
778 ret = CRYPT_AsnEncodeExtension(&exts->rgExtension[i],
779 pbEncoded, &size);
780 pbEncoded += size;
781 dataLen -= size;
782 }
783 }
784 }
785 }
786 __EXCEPT_PAGE_FAULT
787 {
788 SetLastError(STATUS_ACCESS_VIOLATION);
789 ret = FALSE;
790 }
791 __ENDTRY
792 return ret;
793 }
794
795 static BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
796 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
797 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
798 {
799 LPCSTR pszObjId = (LPCSTR)pvStructInfo;
800 DWORD bytesNeeded = 0, lenBytes;
801 BOOL ret = TRUE;
802 int firstPos = 0;
803 BYTE firstByte = 0;
804
805 TRACE("%s\n", debugstr_a(pszObjId));
806
807 if (pszObjId)
808 {
809 const char *ptr;
810 int val1, val2;
811
812 if (sscanf(pszObjId, "%d.%d.%n", &val1, &val2, &firstPos) != 2)
813 {
814 SetLastError(CRYPT_E_ASN1_ERROR);
815 return FALSE;
816 }
817 bytesNeeded++;
818 firstByte = val1 * 40 + val2;
819 ptr = pszObjId + firstPos;
820 while (ret && *ptr)
821 {
822 int pos;
823
824 /* note I assume each component is at most 32-bits long in base 2 */
825 if (sscanf(ptr, "%d%n", &val1, &pos) == 1)
826 {
827 if (val1 >= 0x10000000)
828 bytesNeeded += 5;
829 else if (val1 >= 0x200000)
830 bytesNeeded += 4;
831 else if (val1 >= 0x4000)
832 bytesNeeded += 3;
833 else if (val1 >= 0x80)
834 bytesNeeded += 2;
835 else
836 bytesNeeded += 1;
837 ptr += pos;
838 if (*ptr == '.')
839 ptr++;
840 }
841 else
842 {
843 SetLastError(CRYPT_E_ASN1_ERROR);
844 return FALSE;
845 }
846 }
847 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
848 }
849 else
850 lenBytes = 1;
851 bytesNeeded += 1 + lenBytes;
852 if (pbEncoded)
853 {
854 if (*pcbEncoded < bytesNeeded)
855 {
856 SetLastError(ERROR_MORE_DATA);
857 ret = FALSE;
858 }
859 else
860 {
861 *pbEncoded++ = ASN_OBJECTIDENTIFIER;
862 CRYPT_EncodeLen(bytesNeeded - 1 - lenBytes, pbEncoded, &lenBytes);
863 pbEncoded += lenBytes;
864 if (pszObjId)
865 {
866 const char *ptr;
867 int val, pos;
868
869 *pbEncoded++ = firstByte;
870 ptr = pszObjId + firstPos;
871 while (ret && *ptr)
872 {
873 sscanf(ptr, "%d%n", &val, &pos);
874 {
875 unsigned char outBytes[5];
876 int numBytes, i;
877
878 if (val >= 0x10000000)
879 numBytes = 5;
880 else if (val >= 0x200000)
881 numBytes = 4;
882 else if (val >= 0x4000)
883 numBytes = 3;
884 else if (val >= 0x80)
885 numBytes = 2;
886 else
887 numBytes = 1;
888 for (i = numBytes; i > 0; i--)
889 {
890 outBytes[i - 1] = val & 0x7f;
891 val >>= 7;
892 }
893 for (i = 0; i < numBytes - 1; i++)
894 *pbEncoded++ = outBytes[i] | 0x80;
895 *pbEncoded++ = outBytes[i];
896 ptr += pos;
897 if (*ptr == '.')
898 ptr++;
899 }
900 }
901 }
902 }
903 }
904 *pcbEncoded = bytesNeeded;
905 return ret;
906 }
907
908 static BOOL WINAPI CRYPT_AsnEncodeNameValue(DWORD dwCertEncodingType,
909 CERT_NAME_VALUE *value, BYTE *pbEncoded, DWORD *pcbEncoded)
910 {
911 BYTE tag;
912 DWORD bytesNeeded, lenBytes, encodedLen;
913 BOOL ret = TRUE;
914
915 switch (value->dwValueType)
916 {
917 case CERT_RDN_NUMERIC_STRING:
918 tag = ASN_NUMERICSTRING;
919 encodedLen = value->Value.cbData;
920 break;
921 case CERT_RDN_PRINTABLE_STRING:
922 tag = ASN_PRINTABLESTRING;
923 encodedLen = value->Value.cbData;
924 break;
925 case CERT_RDN_IA5_STRING:
926 tag = ASN_IA5STRING;
927 encodedLen = value->Value.cbData;
928 break;
929 case CERT_RDN_ANY_TYPE:
930 /* explicitly disallowed */
931 SetLastError(E_INVALIDARG);
932 return FALSE;
933 default:
934 FIXME("String type %ld unimplemented\n", value->dwValueType);
935 return FALSE;
936 }
937 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
938 bytesNeeded = 1 + lenBytes + encodedLen;
939 if (pbEncoded)
940 {
941 if (*pcbEncoded < bytesNeeded)
942 {
943 SetLastError(ERROR_MORE_DATA);
944 ret = FALSE;
945 }
946 else
947 {
948 *pbEncoded++ = tag;
949 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
950 pbEncoded += lenBytes;
951 switch (value->dwValueType)
952 {
953 case CERT_RDN_NUMERIC_STRING:
954 case CERT_RDN_PRINTABLE_STRING:
955 case CERT_RDN_IA5_STRING:
956 memcpy(pbEncoded, value->Value.pbData, value->Value.cbData);
957 }
958 }
959 }
960 *pcbEncoded = bytesNeeded;
961 return ret;
962 }
963
964 static BOOL WINAPI CRYPT_AsnEncodeRdnAttr(DWORD dwCertEncodingType,
965 CERT_RDN_ATTR *attr, BYTE *pbEncoded, DWORD *pcbEncoded)
966 {
967 DWORD bytesNeeded = 0, lenBytes, size;
968 BOOL ret;
969
970 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL, attr->pszObjId,
971 0, NULL, NULL, &size);
972 if (ret)
973 {
974 bytesNeeded += size;
975 /* hack: a CERT_RDN_ATTR is identical to a CERT_NAME_VALUE beginning
976 * with dwValueType, so "cast" it to get its encoded size
977 */
978 ret = CRYPT_AsnEncodeNameValue(dwCertEncodingType,
979 (CERT_NAME_VALUE *)&attr->dwValueType, NULL, &size);
980 if (ret)
981 {
982 bytesNeeded += size;
983 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
984 bytesNeeded += 1 + lenBytes;
985 if (pbEncoded)
986 {
987 if (*pcbEncoded < bytesNeeded)
988 {
989 SetLastError(ERROR_MORE_DATA);
990 ret = FALSE;
991 }
992 else
993 {
994 *pbEncoded++ = ASN_SEQUENCE;
995 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
996 &lenBytes);
997 pbEncoded += lenBytes;
998 size = bytesNeeded - 1 - lenBytes;
999 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
1000 attr->pszObjId, 0, NULL, pbEncoded, &size);
1001 if (ret)
1002 {
1003 pbEncoded += size;
1004 size = bytesNeeded - 1 - lenBytes - size;
1005 ret = CRYPT_AsnEncodeNameValue(dwCertEncodingType,
1006 (CERT_NAME_VALUE *)&attr->dwValueType, pbEncoded,
1007 &size);
1008 }
1009 }
1010 }
1011 *pcbEncoded = bytesNeeded;
1012 }
1013 }
1014 return ret;
1015 }
1016
1017 static int BLOBComp(const void *l, const void *r)
1018 {
1019 CRYPT_DER_BLOB *a = (CRYPT_DER_BLOB *)l, *b = (CRYPT_DER_BLOB *)r;
1020 int ret;
1021
1022 if (!(ret = memcmp(a->pbData, b->pbData, min(a->cbData, b->cbData))))
1023 ret = a->cbData - b->cbData;
1024 return ret;
1025 }
1026
1027 /* This encodes as a SET OF, which in DER must be lexicographically sorted.
1028 */
1029 static BOOL WINAPI CRYPT_AsnEncodeRdn(DWORD dwCertEncodingType, CERT_RDN *rdn,
1030 BYTE *pbEncoded, DWORD *pcbEncoded)
1031 {
1032 BOOL ret;
1033 CRYPT_DER_BLOB *blobs = NULL;
1034
1035 __TRY
1036 {
1037 DWORD bytesNeeded = 0, lenBytes, i;
1038
1039 blobs = NULL;
1040 ret = TRUE;
1041 if (rdn->cRDNAttr)
1042 {
1043 blobs = CryptMemAlloc(rdn->cRDNAttr * sizeof(CRYPT_DER_BLOB));
1044 if (!blobs)
1045 ret = FALSE;
1046 else
1047 memset(blobs, 0, rdn->cRDNAttr * sizeof(CRYPT_DER_BLOB));
1048 }
1049 for (i = 0; ret && i < rdn->cRDNAttr; i++)
1050 {
1051 ret = CRYPT_AsnEncodeRdnAttr(dwCertEncodingType, &rdn->rgRDNAttr[i],
1052 NULL, &blobs[i].cbData);
1053 if (ret)
1054 bytesNeeded += blobs[i].cbData;
1055 }
1056 if (ret)
1057 {
1058 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1059 bytesNeeded += 1 + lenBytes;
1060 if (pbEncoded)
1061 {
1062 if (*pcbEncoded < bytesNeeded)
1063 {
1064 SetLastError(ERROR_MORE_DATA);
1065 ret = FALSE;
1066 }
1067 else
1068 {
1069 for (i = 0; ret && i < rdn->cRDNAttr; i++)
1070 {
1071 blobs[i].pbData = CryptMemAlloc(blobs[i].cbData);
1072 if (!blobs[i].pbData)
1073 ret = FALSE;
1074 else
1075 ret = CRYPT_AsnEncodeRdnAttr(dwCertEncodingType,
1076 &rdn->rgRDNAttr[i], blobs[i].pbData,
1077 &blobs[i].cbData);
1078 }
1079 if (ret)
1080 {
1081 qsort(blobs, rdn->cRDNAttr, sizeof(CRYPT_DER_BLOB),
1082 BLOBComp);
1083 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_SETOF;
1084 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
1085 &lenBytes);
1086 pbEncoded += lenBytes;
1087 for (i = 0; ret && i < rdn->cRDNAttr; i++)
1088 {
1089 memcpy(pbEncoded, blobs[i].pbData, blobs[i].cbData);
1090 pbEncoded += blobs[i].cbData;
1091 }
1092 }
1093 }
1094 }
1095 *pcbEncoded = bytesNeeded;
1096 }
1097 if (blobs)
1098 {
1099 for (i = 0; i < rdn->cRDNAttr; i++)
1100 CryptMemFree(blobs[i].pbData);
1101 }
1102 }
1103 __EXCEPT_PAGE_FAULT
1104 {
1105 SetLastError(STATUS_ACCESS_VIOLATION);
1106 ret = FALSE;
1107 }
1108 __ENDTRY
1109 CryptMemFree(blobs);
1110 return ret;
1111 }
1112
1113 static BOOL WINAPI CRYPT_AsnEncodeName(DWORD dwCertEncodingType,
1114 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1115 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1116 {
1117 BOOL ret;
1118
1119 __TRY
1120 {
1121 const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo;
1122 DWORD bytesNeeded = 0, lenBytes, size, i;
1123
1124 TRACE("encoding name with %ld RDNs\n", info->cRDN);
1125 ret = TRUE;
1126 for (i = 0; ret && i < info->cRDN; i++)
1127 {
1128 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType, &info->rgRDN[i], NULL,
1129 &size);
1130 if (ret)
1131 bytesNeeded += size;
1132 }
1133 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1134 bytesNeeded += 1 + lenBytes;
1135 if (ret)
1136 {
1137 if (!pbEncoded)
1138 *pcbEncoded = bytesNeeded;
1139 else
1140 {
1141 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1142 pbEncoded, pcbEncoded, bytesNeeded)))
1143 {
1144 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1145 pbEncoded = *(BYTE **)pbEncoded;
1146 *pbEncoded++ = ASN_SEQUENCEOF;
1147 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
1148 &lenBytes);
1149 pbEncoded += lenBytes;
1150 for (i = 0; ret && i < info->cRDN; i++)
1151 {
1152 size = bytesNeeded;
1153 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType,
1154 &info->rgRDN[i], pbEncoded, &size);
1155 if (ret)
1156 {
1157 pbEncoded += size;
1158 bytesNeeded -= size;
1159 }
1160 }
1161 }
1162 }
1163 }
1164 }
1165 __EXCEPT_PAGE_FAULT
1166 {
1167 SetLastError(STATUS_ACCESS_VIOLATION);
1168 ret = FALSE;
1169 }
1170 __ENDTRY
1171 return ret;
1172 }
1173
1174 static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
1175 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1176 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1177 {
1178 BOOL val = *(const BOOL *)pvStructInfo, ret;
1179
1180 TRACE("%d\n", val);
1181
1182 if (!pbEncoded)
1183 {
1184 *pcbEncoded = 3;
1185 ret = TRUE;
1186 }
1187 else if (*pcbEncoded < 3)
1188 {
1189 *pcbEncoded = 3;
1190 SetLastError(ERROR_MORE_DATA);
1191 ret = FALSE;
1192 }
1193 else
1194 {
1195 *pcbEncoded = 3;
1196 *pbEncoded++ = ASN_BOOL;
1197 *pbEncoded++ = 1;
1198 *pbEncoded++ = val ? 0xff : 0;
1199 ret = TRUE;
1200 }
1201 TRACE("returning %d (%08lx)\n", ret, GetLastError());
1202 return ret;
1203 }
1204
1205 static BOOL CRYPT_AsnEncodeAltNameEntry(const CERT_ALT_NAME_ENTRY *entry,
1206 BYTE *pbEncoded, DWORD *pcbEncoded)
1207 {
1208 BOOL ret;
1209 DWORD dataLen;
1210
1211 ret = TRUE;
1212 switch (entry->dwAltNameChoice)
1213 {
1214 case CERT_ALT_NAME_RFC822_NAME:
1215 case CERT_ALT_NAME_DNS_NAME:
1216 case CERT_ALT_NAME_URL:
1217 if (entry->u.pwszURL)
1218 {
1219 DWORD i;
1220
1221 /* Not + 1: don't encode the NULL-terminator */
1222 dataLen = lstrlenW(entry->u.pwszURL);
1223 for (i = 0; ret && i < dataLen; i++)
1224 {
1225 if (entry->u.pwszURL[i] > 0x7f)
1226 {
1227 SetLastError(CRYPT_E_INVALID_IA5_STRING);
1228 ret = FALSE;
1229 *pcbEncoded = i;
1230 }
1231 }
1232 }
1233 else
1234 dataLen = 0;
1235 break;
1236 case CERT_ALT_NAME_IP_ADDRESS:
1237 dataLen = entry->u.IPAddress.cbData;
1238 break;
1239 case CERT_ALT_NAME_REGISTERED_ID:
1240 /* FIXME: encode OID */
1241 case CERT_ALT_NAME_OTHER_NAME:
1242 case CERT_ALT_NAME_DIRECTORY_NAME:
1243 FIXME("name type %ld unimplemented\n", entry->dwAltNameChoice);
1244 return FALSE;
1245 default:
1246 SetLastError(E_INVALIDARG);
1247 return FALSE;
1248 }
1249 if (ret)
1250 {
1251 DWORD bytesNeeded, lenBytes;
1252
1253 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
1254 bytesNeeded = 1 + dataLen + lenBytes;
1255 if (!pbEncoded)
1256 *pcbEncoded = bytesNeeded;
1257 else if (*pcbEncoded < bytesNeeded)
1258 {
1259 SetLastError(ERROR_MORE_DATA);
1260 *pcbEncoded = bytesNeeded;
1261 ret = FALSE;
1262 }
1263 else
1264 {
1265 *pbEncoded++ = ASN_CONTEXT | (entry->dwAltNameChoice - 1);
1266 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
1267 pbEncoded += lenBytes;
1268 switch (entry->dwAltNameChoice)
1269 {
1270 case CERT_ALT_NAME_RFC822_NAME:
1271 case CERT_ALT_NAME_DNS_NAME:
1272 case CERT_ALT_NAME_URL:
1273 {
1274 DWORD i;
1275
1276 for (i = 0; i < dataLen; i++)
1277 *pbEncoded++ = (BYTE)entry->u.pwszURL[i];
1278 break;
1279 }
1280 case CERT_ALT_NAME_IP_ADDRESS:
1281 memcpy(pbEncoded, entry->u.IPAddress.pbData, dataLen);
1282 break;
1283 }
1284 if (ret)
1285 *pcbEncoded = bytesNeeded;
1286 }
1287 }
1288 TRACE("returning %d (%08lx)\n", ret, GetLastError());
1289 return ret;
1290 }
1291
1292 static BOOL WINAPI CRYPT_AsnEncodeAltName(DWORD dwCertEncodingType,
1293 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1294 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1295 {
1296 BOOL ret;
1297
1298 __TRY
1299 {
1300 const CERT_ALT_NAME_INFO *info =
1301 (const CERT_ALT_NAME_INFO *)pvStructInfo;
1302 DWORD bytesNeeded, dataLen, lenBytes, i;
1303
1304 ret = TRUE;
1305 /* FIXME: should check that cAltEntry is not bigger than 0xff, since we
1306 * can't encode an erroneous entry index if it's bigger than this.
1307 */
1308 for (i = 0, dataLen = 0; ret && i < info->cAltEntry; i++)
1309 {
1310 DWORD len;
1311
1312 ret = CRYPT_AsnEncodeAltNameEntry(&info->rgAltEntry[i], NULL,
1313 &len);
1314 if (ret)
1315 dataLen += len;
1316 else if (GetLastError() == CRYPT_E_INVALID_IA5_STRING)
1317 {
1318 /* CRYPT_AsnEncodeAltNameEntry encoded the index of
1319 * the bad character, now set the index of the bad
1320 * entry
1321 */
1322 *pcbEncoded = (BYTE)i <<
1323 CERT_ALT_NAME_ENTRY_ERR_INDEX_SHIFT | len;
1324 }
1325 }
1326 if (ret)
1327 {
1328 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
1329 bytesNeeded = 1 + lenBytes + dataLen;
1330 if (!pbEncoded)
1331 {
1332 *pcbEncoded = bytesNeeded;
1333 ret = TRUE;
1334 }
1335 else
1336 {
1337 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1338 pbEncoded, pcbEncoded, bytesNeeded)))
1339 {
1340 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1341 pbEncoded = *(BYTE **)pbEncoded;
1342 *pbEncoded++ = ASN_SEQUENCEOF;
1343 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
1344 pbEncoded += lenBytes;
1345 for (i = 0; ret && i < info->cAltEntry; i++)
1346 {
1347 DWORD len = dataLen;
1348
1349 ret = CRYPT_AsnEncodeAltNameEntry(&info->rgAltEntry[i],
1350 pbEncoded, &len);
1351 if (ret)
1352 {
1353 pbEncoded += len;
1354 dataLen -= len;
1355 }
1356 }
1357 }
1358 }
1359 }
1360 }
1361 __EXCEPT_PAGE_FAULT
1362 {
1363 SetLastError(STATUS_ACCESS_VIOLATION);
1364 ret = FALSE;
1365 }
1366 __ENDTRY
1367 return ret;
1368 }
1369
1370 static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints(DWORD dwCertEncodingType,
1371 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1372 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1373 {
1374 BOOL ret;
1375
1376 __TRY
1377 {
1378 const CERT_BASIC_CONSTRAINTS_INFO *info =
1379 (const CERT_BASIC_CONSTRAINTS_INFO *)pvStructInfo;
1380 struct AsnEncodeSequenceItem items[3] = {
1381 { &info->SubjectType, CRYPT_AsnEncodeBits, 0 },
1382 { 0 }
1383 };
1384 DWORD cItem = 1;
1385
1386 if (info->fPathLenConstraint)
1387 {
1388 items[cItem].pvStructInfo = &info->dwPathLenConstraint;
1389 items[cItem].encodeFunc = CRYPT_AsnEncodeInt;
1390 cItem++;
1391 }
1392 if (info->cSubtreesConstraint)
1393 {
1394 items[cItem].pvStructInfo = &info->cSubtreesConstraint;
1395 items[cItem].encodeFunc = CRYPT_AsnEncodeSequenceOfAny;
1396 cItem++;
1397 }
1398 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
1399 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1400 }
1401 __EXCEPT_PAGE_FAULT
1402 {
1403 SetLastError(STATUS_ACCESS_VIOLATION);
1404 ret = FALSE;
1405 }
1406 __ENDTRY
1407 return ret;
1408 }
1409
1410 static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints2(DWORD dwCertEncodingType,
1411 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1412 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1413 {
1414 BOOL ret;
1415
1416 __TRY
1417 {
1418 const CERT_BASIC_CONSTRAINTS2_INFO *info =
1419 (const CERT_BASIC_CONSTRAINTS2_INFO *)pvStructInfo;
1420 struct AsnEncodeSequenceItem items[2] = { { 0 } };
1421 DWORD cItem = 0;
1422
1423 if (info->fCA)
1424 {
1425 items[cItem].pvStructInfo = &info->fCA;
1426 items[cItem].encodeFunc = CRYPT_AsnEncodeBool;
1427 cItem++;
1428 }
1429 if (info->fPathLenConstraint)
1430 {
1431 items[cItem].pvStructInfo = &info->dwPathLenConstraint;
1432 items[cItem].encodeFunc = CRYPT_AsnEncodeInt;
1433 cItem++;
1434 }
1435 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
1436 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1437 }
1438 __EXCEPT_PAGE_FAULT
1439 {
1440 SetLastError(STATUS_ACCESS_VIOLATION);
1441 ret = FALSE;
1442 }
1443 __ENDTRY
1444 return ret;
1445 }
1446
1447 static BOOL WINAPI CRYPT_AsnEncodeRsaPubKey(DWORD dwCertEncodingType,
1448 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1449 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1450 {
1451 BOOL ret;
1452
1453 __TRY
1454 {
1455 const BLOBHEADER *hdr =
1456 (const BLOBHEADER *)pvStructInfo;
1457
1458 if (hdr->bType != PUBLICKEYBLOB)
1459 {
1460 SetLastError(E_INVALIDARG);
1461 ret = FALSE;
1462 }
1463 else
1464 {
1465 const RSAPUBKEY *rsaPubKey = (const RSAPUBKEY *)
1466 ((const BYTE *)pvStructInfo + sizeof(BLOBHEADER));
1467 CRYPT_INTEGER_BLOB blob = { rsaPubKey->bitlen / 8,
1468 (BYTE *)pvStructInfo + sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) };
1469 struct AsnEncodeSequenceItem items[] = {
1470 { &blob, CRYPT_AsnEncodeUnsignedInteger, 0 },
1471 { &rsaPubKey->pubexp, CRYPT_AsnEncodeInt, 0 },
1472 };
1473
1474 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
1475 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
1476 pcbEncoded);
1477 }
1478 }
1479 __EXCEPT_PAGE_FAULT
1480 {
1481 SetLastError(STATUS_ACCESS_VIOLATION);
1482 ret = FALSE;
1483 }
1484 __ENDTRY
1485 return ret;
1486 }
1487
1488 static BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
1489 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1490 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1491 {
1492 BOOL ret;
1493
1494 __TRY
1495 {
1496 const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo;
1497 DWORD bytesNeeded, lenBytes;
1498
1499 TRACE("(%ld, %p), %08lx, %p, %p, %ld\n", blob->cbData, blob->pbData,
1500 dwFlags, pEncodePara, pbEncoded, *pcbEncoded);
1501
1502 CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes);
1503 bytesNeeded = 1 + lenBytes + blob->cbData;
1504 if (!pbEncoded)
1505 {
1506 *pcbEncoded = bytesNeeded;
1507 ret = TRUE;
1508 }
1509 else
1510 {
1511 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
1512 pcbEncoded, bytesNeeded)))
1513 {
1514 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1515 pbEncoded = *(BYTE **)pbEncoded;
1516 *pbEncoded++ = ASN_OCTETSTRING;
1517 CRYPT_EncodeLen(blob->cbData, pbEncoded, &lenBytes);
1518 pbEncoded += lenBytes;
1519 if (blob->cbData)
1520 memcpy(pbEncoded, blob->pbData, blob->cbData);
1521 }
1522 }
1523 }
1524 __EXCEPT_PAGE_FAULT
1525 {
1526 SetLastError(STATUS_ACCESS_VIOLATION);
1527 ret = FALSE;
1528 }
1529 __ENDTRY
1530 TRACE("returning %d (%08lx)\n", ret, GetLastError());
1531 return ret;
1532 }
1533
1534 static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType,
1535 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1536 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1537 {
1538 BOOL ret;
1539
1540 __TRY
1541 {
1542 const CRYPT_BIT_BLOB *blob = (const CRYPT_BIT_BLOB *)pvStructInfo;
1543 DWORD bytesNeeded, lenBytes, dataBytes;
1544 BYTE unusedBits;
1545
1546 /* yep, MS allows cUnusedBits to be >= 8 */
1547 if (!blob->cUnusedBits)
1548 {
1549 dataBytes = blob->cbData;
1550 unusedBits = 0;
1551 }
1552 else if (blob->cbData * 8 > blob->cUnusedBits)
1553 {
1554 dataBytes = (blob->cbData * 8 - blob->cUnusedBits) / 8 + 1;
1555 unusedBits = blob->cUnusedBits >= 8 ? blob->cUnusedBits / 8 :
1556 blob->cUnusedBits;
1557 }
1558 else
1559 {
1560 dataBytes = 0;
1561 unusedBits = 0;
1562 }
1563 CRYPT_EncodeLen(dataBytes + 1, NULL, &lenBytes);
1564 bytesNeeded = 1 + lenBytes + dataBytes + 1;
1565 if (!pbEncoded)
1566 {
1567 *pcbEncoded = bytesNeeded;
1568 ret = TRUE;
1569 }
1570 else
1571 {
1572 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
1573 pcbEncoded, bytesNeeded)))
1574 {
1575 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1576 pbEncoded = *(BYTE **)pbEncoded;
1577 *pbEncoded++ = ASN_BITSTRING;
1578 CRYPT_EncodeLen(dataBytes + 1, pbEncoded, &lenBytes);
1579 pbEncoded += lenBytes;
1580 *pbEncoded++ = unusedBits;
1581 if (dataBytes)
1582 {
1583 BYTE mask = 0xff << unusedBits;
1584
1585 if (dataBytes > 1)
1586 {
1587 memcpy(pbEncoded, blob->pbData, dataBytes - 1);
1588 pbEncoded += dataBytes - 1;
1589 }
1590 *pbEncoded = *(blob->pbData + dataBytes - 1) & mask;
1591 }
1592 }
1593 }
1594 }
1595 __EXCEPT_PAGE_FAULT
1596 {
1597 SetLastError(STATUS_ACCESS_VIOLATION);
1598 ret = FALSE;
1599 }
1600 __ENDTRY
1601 return ret;
1602 }
1603
1604 static BOOL WINAPI CRYPT_AsnEncodeBitsSwapBytes(DWORD dwCertEncodingType,
1605 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1606 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1607 {
1608 BOOL ret;
1609
1610 __TRY
1611 {
1612 const CRYPT_BIT_BLOB *blob = (const CRYPT_BIT_BLOB *)pvStructInfo;
1613 CRYPT_BIT_BLOB newBlob = { blob->cbData, NULL, blob->cUnusedBits };
1614
1615 ret = TRUE;
1616 if (newBlob.cbData)
1617 {
1618 newBlob.pbData = CryptMemAlloc(newBlob.cbData);
1619 if (newBlob.pbData)
1620 {
1621 DWORD i;
1622
1623 for (i = 0; i < newBlob.cbData; i++)
1624 newBlob.pbData[newBlob.cbData - i - 1] = blob->pbData[i];
1625 }
1626 else
1627 ret = FALSE;
1628 }
1629 if (ret)
1630 ret = CRYPT_AsnEncodeBits(dwCertEncodingType, lpszStructType,
1631 &newBlob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1632 CryptMemFree(newBlob.pbData);
1633 }
1634 __EXCEPT_PAGE_FAULT
1635 {
1636 SetLastError(STATUS_ACCESS_VIOLATION);
1637 ret = FALSE;
1638 }
1639 __ENDTRY
1640 return ret;
1641 }
1642
1643 static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType,
1644 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1645 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1646 {
1647 CRYPT_INTEGER_BLOB blob = { sizeof(INT), (BYTE *)pvStructInfo };
1648
1649 return CRYPT_AsnEncodeInteger(dwCertEncodingType, X509_MULTI_BYTE_INTEGER,
1650 &blob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1651 }
1652
1653 static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType,
1654 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1655 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1656 {
1657 BOOL ret;
1658
1659 __TRY
1660 {
1661 DWORD significantBytes, lenBytes;
1662 BYTE padByte = 0, bytesNeeded;
1663 BOOL pad = FALSE;
1664 const CRYPT_INTEGER_BLOB *blob =
1665 (const CRYPT_INTEGER_BLOB *)pvStructInfo;
1666
1667 significantBytes = blob->cbData;
1668 if (significantBytes)
1669 {
1670 if (blob->pbData[significantBytes - 1] & 0x80)
1671 {
1672 /* negative, lop off leading (little-endian) 0xffs */
1673 for (; significantBytes > 0 &&
1674 blob->pbData[significantBytes - 1] == 0xff; significantBytes--)
1675 ;
1676 if (blob->pbData[significantBytes - 1] < 0x80)
1677 {
1678 padByte = 0xff;
1679 pad = TRUE;
1680 }
1681 }
1682 else
1683 {
1684 /* positive, lop off leading (little-endian) zeroes */
1685 for (; significantBytes > 0 &&
1686 !blob->pbData[significantBytes - 1]; significantBytes--)
1687 ;
1688 if (significantBytes == 0)
1689 significantBytes = 1;
1690 if (blob->pbData[significantBytes - 1] > 0x7f)
1691 {
1692 padByte = 0;
1693 pad = TRUE;
1694 }
1695 }
1696 }
1697 if (pad)
1698 CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes);
1699 else
1700 CRYPT_EncodeLen(significantBytes, NULL, &lenBytes);
1701 bytesNeeded = 1 + lenBytes + significantBytes;
1702 if (pad)
1703 bytesNeeded++;
1704 if (!pbEncoded)
1705 {
1706 *pcbEncoded = bytesNeeded;
1707 ret = TRUE;
1708 }
1709 else
1710 {
1711 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
1712 pcbEncoded, bytesNeeded)))
1713 {
1714 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1715 pbEncoded = *(BYTE **)pbEncoded;
1716 *pbEncoded++ = ASN_INTEGER;
1717 if (pad)
1718 {
1719 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
1720 pbEncoded += lenBytes;
1721 *pbEncoded++ = padByte;
1722 }
1723 else
1724 {
1725 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
1726 pbEncoded += lenBytes;
1727 }
1728 for (; significantBytes > 0; significantBytes--)
1729 *(pbEncoded++) = blob->pbData[significantBytes - 1];
1730 }
1731 }
1732 }
1733 __EXCEPT_PAGE_FAULT
1734 {
1735 SetLastError(STATUS_ACCESS_VIOLATION);
1736 ret = FALSE;
1737 }
1738 __ENDTRY
1739 return ret;
1740 }
1741
1742 static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType,
1743 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1744 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1745 {
1746 BOOL ret;
1747
1748 __TRY
1749 {
1750 DWORD significantBytes, lenBytes;
1751 BYTE bytesNeeded;
1752 BOOL pad = FALSE;
1753 const CRYPT_INTEGER_BLOB *blob =
1754 (const CRYPT_INTEGER_BLOB *)pvStructInfo;
1755
1756 significantBytes = blob->cbData;
1757 if (significantBytes)
1758 {
1759 /* positive, lop off leading (little-endian) zeroes */
1760 for (; significantBytes > 0 && !blob->pbData[significantBytes - 1];
1761 significantBytes--)
1762 ;
1763 if (significantBytes == 0)
1764 significantBytes = 1;
1765 if (blob->pbData[significantBytes - 1] > 0x7f)
1766 pad = TRUE;
1767 }
1768 if (pad)
1769 CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes);
1770 else
1771 CRYPT_EncodeLen(significantBytes, NULL, &lenBytes);
1772 bytesNeeded = 1 + lenBytes + significantBytes;
1773 if (pad)
1774 bytesNeeded++;
1775 if (!pbEncoded)
1776 {
1777 *pcbEncoded = bytesNeeded;
1778 ret = TRUE;
1779 }
1780 else
1781 {
1782 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
1783 pcbEncoded, bytesNeeded)))
1784 {
1785 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1786 pbEncoded = *(BYTE **)pbEncoded;
1787 *pbEncoded++ = ASN_INTEGER;
1788 if (pad)
1789 {
1790 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
1791 pbEncoded += lenBytes;
1792 *pbEncoded++ = 0;
1793 }
1794 else
1795 {
1796 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
1797 pbEncoded += lenBytes;
1798 }
1799 for (; significantBytes > 0; significantBytes--)
1800 *(pbEncoded++) = blob->pbData[significantBytes - 1];
1801 }
1802 }
1803 }
1804 __EXCEPT_PAGE_FAULT
1805 {
1806 SetLastError(STATUS_ACCESS_VIOLATION);
1807 ret = FALSE;
1808 }
1809 __ENDTRY
1810 return ret;
1811 }
1812
1813 static BOOL WINAPI CRYPT_AsnEncodeEnumerated(DWORD dwCertEncodingType,
1814 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1815 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1816 {
1817 CRYPT_INTEGER_BLOB blob;
1818 BOOL ret;
1819
1820 /* Encode as an unsigned integer, then change the tag to enumerated */
1821 blob.cbData = sizeof(DWORD);
1822 blob.pbData = (BYTE *)pvStructInfo;
1823 ret = CRYPT_AsnEncodeUnsignedInteger(dwCertEncodingType,
1824 X509_MULTI_BYTE_UINT, &blob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1825 if (ret && pbEncoded)
1826 {
1827 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1828 pbEncoded = *(BYTE **)pbEncoded;
1829 pbEncoded[0] = ASN_ENUMERATED;
1830 }
1831 return ret;
1832 }
1833
1834 static BOOL WINAPI CRYPT_AsnEncodeUtcTime(DWORD dwCertEncodingType,
1835 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1836 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1837 {
1838 BOOL ret;
1839
1840 __TRY
1841 {
1842 SYSTEMTIME sysTime;
1843 /* sorry, magic number: enough for tag, len, YYMMDDHHMMSSZ\0. I use a
1844 * temporary buffer because the output buffer is not NULL-terminated.
1845 */
1846 char buf[16];
1847 static const DWORD bytesNeeded = sizeof(buf) - 1;
1848
1849 if (!pbEncoded)
1850 {
1851 *pcbEncoded = bytesNeeded;
1852 ret = TRUE;
1853 }
1854 else
1855 {
1856 /* Sanity check the year, this is a two-digit year format */
1857 ret = FileTimeToSystemTime((const FILETIME *)pvStructInfo,
1858 &sysTime);
1859 if (ret && (sysTime.wYear < 1950 || sysTime.wYear > 2050))
1860 {
1861 SetLastError(CRYPT_E_BAD_ENCODE);
1862 ret = FALSE;
1863 }
1864 if (ret)
1865 {
1866 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1867 pbEncoded, pcbEncoded, bytesNeeded)))
1868 {
1869 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1870 pbEncoded = *(BYTE **)pbEncoded;
1871 buf[0] = ASN_UTCTIME;
1872 buf[1] = bytesNeeded - 2;
1873 snprintf(buf + 2, sizeof(buf) - 2,
1874 "%02d%02d%02d%02d%02d%02dZ", sysTime.wYear >= 2000 ?
1875 sysTime.wYear - 2000 : sysTime.wYear - 1900,
1876 sysTime.wMonth, sysTime.wDay, sysTime.wHour,
1877 sysTime.wMinute, sysTime.wSecond);
1878 memcpy(pbEncoded, buf, bytesNeeded);
1879 }
1880 }
1881 }
1882 }
1883 __EXCEPT_PAGE_FAULT
1884 {
1885 SetLastError(STATUS_ACCESS_VIOLATION);
1886 ret = FALSE;
1887 }
1888 __ENDTRY
1889 return ret;
1890 }
1891
1892 static BOOL WINAPI CRYPT_AsnEncodeGeneralizedTime(DWORD dwCertEncodingType,
1893 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1894 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1895 {
1896 BOOL ret;
1897
1898 __TRY
1899 {
1900 SYSTEMTIME sysTime;
1901 /* sorry, magic number: enough for tag, len, YYYYMMDDHHMMSSZ\0. I use a
1902 * temporary buffer because the output buffer is not NULL-terminated.
1903 */
1904 char buf[18];
1905 static const DWORD bytesNeeded = sizeof(buf) - 1;
1906
1907 if (!pbEncoded)
1908 {
1909 *pcbEncoded = bytesNeeded;
1910 ret = TRUE;
1911 }
1912 else
1913 {
1914 ret = FileTimeToSystemTime((const FILETIME *)pvStructInfo,
1915 &sysTime);
1916 if (ret)
1917 ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
1918 pcbEncoded, bytesNeeded);
1919 if (ret)
1920 {
1921 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1922 pbEncoded = *(BYTE **)pbEncoded;
1923 buf[0] = ASN_GENERALTIME;
1924 buf[1] = bytesNeeded - 2;
1925 snprintf(buf + 2, sizeof(buf) - 2, "%04d%02d%02d%02d%02d%02dZ",
1926 sysTime.wYear, sysTime.wMonth, sysTime.wDay, sysTime.wHour,
1927 sysTime.wMinute, sysTime.wSecond);
1928 memcpy(pbEncoded, buf, bytesNeeded);
1929 }
1930 }
1931 }
1932 __EXCEPT_PAGE_FAULT
1933 {
1934 SetLastError(STATUS_ACCESS_VIOLATION);
1935 ret = FALSE;
1936 }
1937 __ENDTRY
1938 return ret;
1939 }
1940
1941 static BOOL WINAPI CRYPT_AsnEncodeChoiceOfTime(DWORD dwCertEncodingType,
1942 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1943 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1944 {
1945 BOOL ret;
1946
1947 __TRY
1948 {
1949 SYSTEMTIME sysTime;
1950
1951 /* Check the year, if it's in the UTCTime range call that encode func */
1952 if (!FileTimeToSystemTime((const FILETIME *)pvStructInfo, &sysTime))
1953 return FALSE;
1954 if (sysTime.wYear >= 1950 && sysTime.wYear <= 2050)
1955 ret = CRYPT_AsnEncodeUtcTime(dwCertEncodingType, lpszStructType,
1956 pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1957 else
1958 ret = CRYPT_AsnEncodeGeneralizedTime(dwCertEncodingType,
1959 lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded,
1960 pcbEncoded);
1961 }
1962 __EXCEPT_PAGE_FAULT
1963 {
1964 SetLastError(STATUS_ACCESS_VIOLATION);
1965 ret = FALSE;
1966 }
1967 __ENDTRY
1968 return ret;
1969 }
1970
1971 static BOOL WINAPI CRYPT_AsnEncodeSequenceOfAny(DWORD dwCertEncodingType,
1972 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1973 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1974 {
1975 BOOL ret;
1976
1977 __TRY
1978 {
1979 DWORD bytesNeeded, dataLen, lenBytes, i;
1980 const CRYPT_SEQUENCE_OF_ANY *seq =
1981 (const CRYPT_SEQUENCE_OF_ANY *)pvStructInfo;
1982
1983 for (i = 0, dataLen = 0; i < seq->cValue; i++)
1984 dataLen += seq->rgValue[i].cbData;
1985 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
1986 bytesNeeded = 1 + lenBytes + dataLen;
1987 if (!pbEncoded)
1988 {
1989 *pcbEncoded = bytesNeeded;
1990 ret = TRUE;
1991 }
1992 else
1993 {
1994 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
1995 pcbEncoded, bytesNeeded)))
1996 {
1997 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1998 pbEncoded = *(BYTE **)pbEncoded;
1999 *pbEncoded++ = ASN_SEQUENCEOF;
2000 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
2001 pbEncoded += lenBytes;
2002 for (i = 0; i < seq->cValue; i++)
2003 {
2004 memcpy(pbEncoded, seq->rgValue[i].pbData,
2005 seq->rgValue[i].cbData);
2006 pbEncoded += seq->rgValue[i].cbData;
2007 }
2008 }
2009 }
2010 }
2011 __EXCEPT_PAGE_FAULT
2012 {
2013 SetLastError(STATUS_ACCESS_VIOLATION);
2014 ret = FALSE;
2015 }
2016 __ENDTRY
2017 return ret;
2018 }
2019
2020 static BOOL CRYPT_AsnEncodeDistPoint(const CRL_DIST_POINT *distPoint,
2021 BYTE *pbEncoded, DWORD *pcbEncoded)
2022 {
2023 BOOL ret = TRUE;
2024 struct AsnEncodeSequenceItem items[3] = { { 0 } };
2025 struct AsnConstructedItem constructed = { 0 };
2026 struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
2027 DWORD cItem = 0, cSwapped = 0;
2028
2029 switch (distPoint->DistPointName.dwDistPointNameChoice)
2030 {
2031 case CRL_DIST_POINT_NO_NAME:
2032 /* do nothing */
2033 break;
2034 case CRL_DIST_POINT_FULL_NAME:
2035 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
2036 swapped[cSwapped].pvStructInfo = &distPoint->DistPointName.u.FullName;
2037 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
2038 constructed.tag = 0;
2039 constructed.pvStructInfo = &swapped[cSwapped];
2040 constructed.encodeFunc = CRYPT_AsnEncodeSwapTag;
2041 items[cItem].pvStructInfo = &constructed;
2042 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
2043 cSwapped++;
2044 cItem++;
2045 break;
2046 case CRL_DIST_POINT_ISSUER_RDN_NAME:
2047 FIXME("unimplemented for CRL_DIST_POINT_ISSUER_RDN_NAME\n");
2048 ret = FALSE;
2049 break;
2050 default:
2051 ret = FALSE;
2052 }
2053 if (ret && distPoint->ReasonFlags.cbData)
2054 {
2055 swapped[cSwapped].tag = ASN_CONTEXT | 1;
2056 swapped[cSwapped].pvStructInfo = &distPoint->ReasonFlags;
2057 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBits;
2058 items[cItem].pvStructInfo = &swapped[cSwapped];
2059 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2060 cSwapped++;
2061 cItem++;
2062 }
2063 if (ret && distPoint->CRLIssuer.cAltEntry)
2064 {
2065 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 2;
2066 swapped[cSwapped].pvStructInfo = &distPoint->CRLIssuer;
2067 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
2068 items[cItem].pvStructInfo = &swapped[cSwapped];
2069 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2070 cSwapped++;
2071 cItem++;
2072 }
2073 if (ret)
2074 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
2075 pbEncoded, pcbEncoded);
2076 return ret;
2077 }
2078
2079 static BOOL WINAPI CRYPT_AsnEncodeCRLDistPoints(DWORD dwCertEncodingType,
2080 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2081 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2082 {
2083 BOOL ret;
2084
2085 __TRY
2086 {
2087 const CRL_DIST_POINTS_INFO *info =
2088 (const CRL_DIST_POINTS_INFO *)pvStructInfo;
2089
2090 if (!info->cDistPoint)
2091 {
2092 SetLastError(E_INVALIDARG);
2093 ret = FALSE;
2094 }
2095 else
2096 {
2097 DWORD bytesNeeded, dataLen, lenBytes, i;
2098
2099 ret = TRUE;
2100 for (i = 0, dataLen = 0; ret && i < info->cDistPoint; i++)
2101 {
2102 DWORD len;
2103
2104 ret = CRYPT_AsnEncodeDistPoint(&info->rgDistPoint[i], NULL,
2105 &len);
2106 if (ret)
2107 dataLen += len;
2108 else if (GetLastError() == CRYPT_E_INVALID_IA5_STRING)
2109 {
2110 /* Have to propagate index of failing character */
2111 *pcbEncoded = len;
2112 }
2113 }
2114 if (ret)
2115 {
2116 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
2117 bytesNeeded = 1 + lenBytes + dataLen;
2118 if (!pbEncoded)
2119 {
2120 *pcbEncoded = bytesNeeded;
2121 ret = TRUE;
2122 }
2123 else
2124 {
2125 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2126 pbEncoded, pcbEncoded, bytesNeeded)))
2127 {
2128 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2129 pbEncoded = *(BYTE **)pbEncoded;
2130 *pbEncoded++ = ASN_SEQUENCEOF;
2131 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
2132 pbEncoded += lenBytes;
2133 for (i = 0; ret && i < info->cDistPoint; i++)
2134 {
2135 DWORD len = dataLen;
2136
2137 ret = CRYPT_AsnEncodeDistPoint(
2138 &info->rgDistPoint[i], pbEncoded, &len);
2139 if (ret)
2140 {
2141 pbEncoded += len;
2142 dataLen -= len;
2143 }
2144 }
2145 }
2146 }
2147 }
2148 }
2149 }
2150 __EXCEPT_PAGE_FAULT
2151 {
2152 SetLastError(STATUS_ACCESS_VIOLATION);
2153 ret = FALSE;
2154 }
2155 __ENDTRY
2156 return ret;
2157 }
2158
2159 static BOOL WINAPI CRYPT_AsnEncodeEnhancedKeyUsage(DWORD dwCertEncodingType,
2160 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2161 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2162 {
2163 BOOL ret;
2164
2165 __TRY
2166 {
2167 const CERT_ENHKEY_USAGE *usage =
2168 (const CERT_ENHKEY_USAGE *)pvStructInfo;
2169 DWORD bytesNeeded = 0, lenBytes, size, i;
2170
2171 ret = TRUE;
2172 for (i = 0; ret && i < usage->cUsageIdentifier; i++)
2173 {
2174 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
2175 usage->rgpszUsageIdentifier[i],
2176 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &size);
2177 if (ret)
2178 bytesNeeded += size;
2179 }
2180 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
2181 bytesNeeded += 1 + lenBytes;
2182 if (ret)
2183 {
2184 if (!pbEncoded)
2185 *pcbEncoded = bytesNeeded;
2186 else
2187 {
2188 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2189 pbEncoded, pcbEncoded, bytesNeeded)))
2190 {
2191 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2192 pbEncoded = *(BYTE **)pbEncoded;
2193 *pbEncoded++ = ASN_SEQUENCEOF;
2194 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
2195 &lenBytes);
2196 pbEncoded += lenBytes;
2197 for (i = 0; ret && i < usage->cUsageIdentifier; i++)
2198 {
2199 size = bytesNeeded;
2200 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
2201 usage->rgpszUsageIdentifier[i],
2202 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, pbEncoded,
2203 &size);
2204 if (ret)
2205 {
2206 pbEncoded += size;
2207 bytesNeeded -= size;
2208 }
2209 }
2210 }
2211 }
2212 }
2213 }
2214 __EXCEPT_PAGE_FAULT
2215 {
2216 SetLastError(STATUS_ACCESS_VIOLATION);
2217 ret = FALSE;
2218 }
2219 __ENDTRY
2220 return ret;
2221 }
2222
2223 BOOL WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType,
2224 const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara,
2225 void *pvEncoded, DWORD *pcbEncoded)
2226 {
2227 static HCRYPTOIDFUNCSET set = NULL;
2228 BOOL ret = FALSE;
2229 CryptEncodeObjectExFunc encodeFunc = NULL;
2230 HCRYPTOIDFUNCADDR hFunc = NULL;
2231
2232 TRACE("(0x%08lx, %s, %p, 0x%08lx, %p, %p, %p)\n", dwCertEncodingType,
2233 debugstr_a(lpszStructType), pvStructInfo, dwFlags, pEncodePara,
2234 pvEncoded, pcbEncoded);
2235
2236 if (!pvEncoded && !pcbEncoded)
2237 {
2238 SetLastError(ERROR_INVALID_PARAMETER);
2239 return FALSE;
2240 }
2241 if ((dwCertEncodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING
2242 && (dwCertEncodingType & CMSG_ENCODING_TYPE_MASK) != PKCS_7_ASN_ENCODING)
2243 {
2244 SetLastError(ERROR_FILE_NOT_FOUND);
2245 return FALSE;
2246 }
2247
2248 SetLastError(NOERROR);
2249 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG && pvEncoded)
2250 *(BYTE **)pvEncoded = NULL;
2251 if (!HIWORD(lpszStructType))
2252 {
2253 switch (LOWORD(lpszStructType))
2254 {
2255 case (WORD)X509_CERT:
2256 encodeFunc = CRYPT_AsnEncodeCert;
2257 break;
2258 case (WORD)X509_CERT_TO_BE_SIGNED:
2259 encodeFunc = CRYPT_AsnEncodeCertInfo;
2260 break;
2261 case (WORD)X509_CERT_CRL_TO_BE_SIGNED:
2262 encodeFunc = CRYPT_AsnEncodeCRLInfo;
2263 break;
2264 case (WORD)X509_EXTENSIONS:
2265 encodeFunc = CRYPT_AsnEncodeExtensions;
2266 break;
2267 case (WORD)X509_NAME:
2268 encodeFunc = CRYPT_AsnEncodeName;
2269 break;
2270 case (WORD)X509_PUBLIC_KEY_INFO:
2271 encodeFunc = CRYPT_AsnEncodePubKeyInfo;
2272 break;
2273 case (WORD)X509_ALTERNATE_NAME:
2274 encodeFunc = CRYPT_AsnEncodeAltName;
2275 break;
2276 case (WORD)X509_BASIC_CONSTRAINTS:
2277 encodeFunc = CRYPT_AsnEncodeBasicConstraints;
2278 break;
2279 case (WORD)X509_BASIC_CONSTRAINTS2:
2280 encodeFunc = CRYPT_AsnEncodeBasicConstraints2;
2281 break;
2282 case (WORD)RSA_CSP_PUBLICKEYBLOB:
2283 encodeFunc = CRYPT_AsnEncodeRsaPubKey;
2284 break;
2285 case (WORD)X509_OCTET_STRING:
2286 encodeFunc = CRYPT_AsnEncodeOctets;
2287 break;
2288 case (WORD)X509_BITS:
2289 case (WORD)X509_KEY_USAGE:
2290 encodeFunc = CRYPT_AsnEncodeBits;
2291 break;
2292 case (WORD)X509_INTEGER:
2293 encodeFunc = CRYPT_AsnEncodeInt;
2294 break;
2295 case (WORD)X509_MULTI_BYTE_INTEGER:
2296 encodeFunc = CRYPT_AsnEncodeInteger;
2297 break;
2298 case (WORD)X509_MULTI_BYTE_UINT:
2299 encodeFunc = CRYPT_AsnEncodeUnsignedInteger;
2300 break;
2301 case (WORD)X509_ENUMERATED:
2302 encodeFunc = CRYPT_AsnEncodeEnumerated;
2303 break;
2304 case (WORD)X509_CHOICE_OF_TIME:
2305 encodeFunc = CRYPT_AsnEncodeChoiceOfTime;
2306 break;
2307 case (WORD)X509_SEQUENCE_OF_ANY:
2308 encodeFunc = CRYPT_AsnEncodeSequenceOfAny;
2309 break;
2310 case (WORD)PKCS_UTC_TIME:
2311 encodeFunc = CRYPT_AsnEncodeUtcTime;
2312 break;
2313 case (WORD)X509_CRL_DIST_POINTS:
2314 encodeFunc = CRYPT_AsnEncodeCRLDistPoints;
2315 break;
2316 case (WORD)X509_ENHANCED_KEY_USAGE:
2317 encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage;
2318 break;
2319 default:
2320 FIXME("%d: unimplemented\n", LOWORD(lpszStructType));
2321 }
2322 }
2323 else if (!strcmp(lpszStructType, szOID_CERT_EXTENSIONS))
2324 encodeFunc = CRYPT_AsnEncodeExtensions;
2325 else if (!strcmp(lpszStructType, szOID_RSA_signingTime))
2326 encodeFunc = CRYPT_AsnEncodeUtcTime;
2327 else if (!strcmp(lpszStructType, szOID_CRL_REASON_CODE))
2328 encodeFunc = CRYPT_AsnEncodeEnumerated;
2329 else if (!strcmp(lpszStructType, szOID_KEY_USAGE))
2330 encodeFunc = CRYPT_AsnEncodeBits;
2331 else if (!strcmp(lpszStructType, szOID_SUBJECT_KEY_IDENTIFIER))
2332 encodeFunc = CRYPT_AsnEncodeOctets;
2333 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS))
2334 encodeFunc = CRYPT_AsnEncodeBasicConstraints;
2335 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS2))
2336 encodeFunc = CRYPT_AsnEncodeBasicConstraints2;
2337 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME))
2338 encodeFunc = CRYPT_AsnEncodeAltName;
2339 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME2))
2340 encodeFunc = CRYPT_AsnEncodeAltName;
2341 else if (!strcmp(lpszStructType, szOID_NEXT_UPDATE_LOCATION))
2342 encodeFunc = CRYPT_AsnEncodeAltName;
2343 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME))
2344 encodeFunc = CRYPT_AsnEncodeAltName;
2345 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME2))
2346 encodeFunc = CRYPT_AsnEncodeAltName;
2347 else if (!strcmp(lpszStructType, szOID_CRL_DIST_POINTS))
2348 encodeFunc = CRYPT_AsnEncodeCRLDistPoints;
2349 else if (!strcmp(lpszStructType, szOID_ENHANCED_KEY_USAGE))
2350 encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage;
2351 else
2352 TRACE("OID %s not found or unimplemented, looking for DLL\n",
2353 debugstr_a(lpszStructType));
2354 if (!encodeFunc)
2355 {
2356 if (!set)
2357 set = CryptInitOIDFunctionSet(CRYPT_OID_ENCODE_OBJECT_EX_FUNC, 0);
2358 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
2359 (void **)&encodeFunc, &hFunc);
2360 }
2361 if (encodeFunc)
2362 ret = encodeFunc(dwCertEncodingType, lpszStructType, pvStructInfo,
2363 dwFlags, pEncodePara, pvEncoded, pcbEncoded);
2364 else
2365 SetLastError(ERROR_FILE_NOT_FOUND);
2366 if (hFunc)
2367 CryptFreeOIDFunctionAddress(hFunc, 0);
2368 return ret;
2369 }
2370
2371 BOOL WINAPI CryptExportPublicKeyInfo(HCRYPTPROV hCryptProv, DWORD dwKeySpec,
2372 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
2373 {
2374 return CryptExportPublicKeyInfoEx(hCryptProv, dwKeySpec, dwCertEncodingType,
2375 NULL, 0, NULL, pInfo, pcbInfo);
2376 }
2377
2378 static BOOL WINAPI CRYPT_ExportRsaPublicKeyInfoEx(HCRYPTPROV hCryptProv,
2379 DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId,
2380 DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
2381 {
2382 BOOL ret;
2383 HCRYPTKEY key;
2384
2385 TRACE("(%ld, %ld, %08lx, %s, %08lx, %p, %p, %p)\n", hCryptProv, dwKeySpec,
2386 dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags, pvAuxInfo,
2387 pInfo, pcbInfo);
2388
2389 if (!pszPublicKeyObjId)
2390 pszPublicKeyObjId = szOID_RSA_RSA;
2391 if ((ret = CryptGetUserKey(hCryptProv, dwKeySpec, &key)))
2392 {
2393 DWORD keySize = 0;
2394
2395 ret = CryptExportKey(key, 0, PUBLICKEYBLOB, 0, NULL, &keySize);
2396 if (ret)
2397 {
2398 LPBYTE pubKey = CryptMemAlloc(keySize);
2399
2400 if (pubKey)
2401 {
2402 ret = CryptExportKey(key, 0, PUBLICKEYBLOB, 0, pubKey,
2403 &keySize);
2404 if (ret)
2405 {
2406 DWORD encodedLen = 0;
2407
2408 ret = CryptEncodeObject(dwCertEncodingType,
2409 RSA_CSP_PUBLICKEYBLOB, pubKey, NULL, &encodedLen);
2410 if (ret)
2411 {
2412 DWORD sizeNeeded = sizeof(CERT_PUBLIC_KEY_INFO) +
2413 strlen(pszPublicKeyObjId) + 1 + encodedLen;
2414
2415 if (!pInfo)
2416 *pcbInfo = sizeNeeded;
2417 else if (*pcbInfo < sizeNeeded)
2418 {
2419 SetLastError(ERROR_MORE_DATA);
2420 *pcbInfo = sizeNeeded;
2421 ret = FALSE;
2422 }
2423 else
2424 {
2425 pInfo->Algorithm.pszObjId = (char *)pInfo +
2426 sizeof(CERT_PUBLIC_KEY_INFO);
2427 lstrcpyA(pInfo->Algorithm.pszObjId,
2428 pszPublicKeyObjId);
2429 pInfo->Algorithm.Parameters.cbData = 0;
2430 pInfo->Algorithm.Parameters.pbData = NULL;
2431 pInfo->PublicKey.pbData =
2432 (BYTE *)pInfo->Algorithm.pszObjId
2433 + lstrlenA(pInfo->Algorithm.pszObjId) + 1;
2434 pInfo->PublicKey.cbData = encodedLen;
2435 pInfo->PublicKey.cUnusedBits = 0;
2436 ret = CryptEncodeObject(dwCertEncodingType,
2437 RSA_CSP_PUBLICKEYBLOB, pubKey,
2438 pInfo->PublicKey.pbData, &pInfo->PublicKey.cbData);
2439 }
2440 }
2441 }
2442 CryptMemFree(pubKey);
2443 }
2444 else
2445 ret = FALSE;
2446 }
2447 CryptDestroyKey(key);
2448 }
2449 return ret;
2450 }
2451
2452 typedef BOOL (WINAPI *ExportPublicKeyInfoExFunc)(HCRYPTPROV hCryptProv,
2453 DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId,
2454 DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo);
2455
2456 BOOL WINAPI CryptExportPublicKeyInfoEx(HCRYPTPROV hCryptProv, DWORD dwKeySpec,
2457 DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags,
2458 void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
2459 {
2460 static HCRYPTOIDFUNCSET set = NULL;
2461 BOOL ret;
2462 ExportPublicKeyInfoExFunc exportFunc = NULL;
2463 HCRYPTOIDFUNCADDR hFunc = NULL;
2464
2465 TRACE("(%ld, %ld, %08lx, %s, %08lx, %p, %p, %p)\n", hCryptProv, dwKeySpec,
2466 dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags, pvAuxInfo,
2467 pInfo, pcbInfo);
2468
2469 if (!hCryptProv)
2470 {
2471 SetLastError(ERROR_INVALID_PARAMETER);
2472 return FALSE;
2473 }
2474
2475 if (pszPublicKeyObjId)
2476 {
2477 if (!set)
2478 set = CryptInitOIDFunctionSet(CRYPT_OID_EXPORT_PUBLIC_KEY_INFO_FUNC,
2479 0);
2480 CryptGetOIDFunctionAddress(set, dwCertEncodingType, pszPublicKeyObjId,
2481 0, (void **)&exportFunc, &hFunc);
2482 }
2483 if (!exportFunc)
2484 exportFunc = CRYPT_ExportRsaPublicKeyInfoEx;
2485 ret = exportFunc(hCryptProv, dwKeySpec, dwCertEncodingType,
2486 pszPublicKeyObjId, dwFlags, pvAuxInfo, pInfo, pcbInfo);
2487 if (hFunc)
2488 CryptFreeOIDFunctionAddress(hFunc, 0);
2489 return ret;
2490 }
2491
2492 BOOL WINAPI CryptImportPublicKeyInfo(HCRYPTPROV hCryptProv,
2493 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, HCRYPTKEY *phKey)
2494 {
2495 return CryptImportPublicKeyInfoEx(hCryptProv, dwCertEncodingType, pInfo,
2496 0, 0, NULL, phKey);
2497 }
2498
2499 static BOOL WINAPI CRYPT_ImportRsaPublicKeyInfoEx(HCRYPTPROV hCryptProv,
2500 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
2501 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey)
2502 {
2503 BOOL ret;
2504 DWORD pubKeySize = 0;
2505
2506 TRACE("(%ld, %ld, %p, %d, %08lx, %p, %p)\n", hCryptProv,
2507 dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
2508
2509 ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB,
2510 pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, NULL, &pubKeySize);
2511 if (ret)
2512 {
2513 LPBYTE pubKey = CryptMemAlloc(pubKeySize);
2514
2515 if (pubKey)
2516 {
2517 ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB,
2518 pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, pubKey,
2519 &pubKeySize);
2520 if (ret)
2521 ret = CryptImportKey(hCryptProv, pubKey, pubKeySize, 0, 0,
2522 phKey);
2523 CryptMemFree(pubKey);
2524 }
2525 else
2526 ret = FALSE;
2527 }
2528 return ret;
2529 }
2530
2531 typedef BOOL (WINAPI *ImportPublicKeyInfoExFunc)(HCRYPTPROV hCryptProv,
2532 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
2533 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey);
2534
2535 BOOL WINAPI CryptImportPublicKeyInfoEx(HCRYPTPROV hCryptProv,
2536 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
2537 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey)
2538 {
2539 static HCRYPTOIDFUNCSET set = NULL;
2540 BOOL ret;
2541 ImportPublicKeyInfoExFunc importFunc = NULL;
2542 HCRYPTOIDFUNCADDR hFunc = NULL;
2543
2544 TRACE("(%ld, %ld, %p, %d, %08lx, %p, %p)\n", hCryptProv,
2545 dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
2546
2547 if (!set)
2548 set = CryptInitOIDFunctionSet(CRYPT_OID_IMPORT_PUBLIC_KEY_INFO_FUNC, 0);
2549 CryptGetOIDFunctionAddress(set, dwCertEncodingType,
2550 pInfo->Algorithm.pszObjId, 0, (void **)&importFunc, &hFunc);
2551 if (!importFunc)
2552 importFunc = CRYPT_ImportRsaPublicKeyInfoEx;
2553 ret = importFunc(hCryptProv, dwCertEncodingType, pInfo, aiKeyAlg, dwFlags,
2554 pvAuxInfo, phKey);
2555 if (hFunc)
2556 CryptFreeOIDFunctionAddress(hFunc, 0);
2557 return ret;
2558 }
Maarten's multimedia branch