push 6fe5edf8439c19d3885814583531c2f2b1495177
[wine/hacks.git] / dlls / crypt32 / encode.c
blob9071e5c4918b81a5b7c334d2dfa64578821da4d0
1 /*
2 * Copyright 2005-2007 Juan Lang
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.
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.
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
18 * This file implements ASN.1 DER encoding of a limited set of types.
19 * It isn't a full ASN.1 implementation. Microsoft implements BER
20 * encoding of many of the basic types in msasn1.dll, but that interface isn't
21 * implemented, so I implement them here.
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.)
28 * RFC3280, http://www.faqs.org/rfcs/rfc3280.html
30 * MSDN, especially "Constants for CryptEncodeObject and CryptDecodeObject"
33 #include "config.h"
34 #include "wine/port.h"
36 #include <assert.h>
37 #include <stdarg.h>
38 #include <stdio.h>
39 #include <stdlib.h>
41 #define NONAMELESSUNION
43 #include "windef.h"
44 #include "winbase.h"
45 #include "wincrypt.h"
46 #include "snmp.h"
47 #include "wine/debug.h"
48 #include "wine/exception.h"
49 #include "wine/unicode.h"
50 #include "crypt32_private.h"
52 WINE_DEFAULT_DEBUG_CHANNEL(cryptasn);
53 WINE_DECLARE_DEBUG_CHANNEL(crypt);
55 typedef BOOL (WINAPI *CryptEncodeObjectFunc)(DWORD, LPCSTR, const void *,
56 BYTE *, DWORD *);
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.
63 BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
64 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
65 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
66 static BOOL WINAPI CRYPT_AsnEncodeExtensions(DWORD dwCertEncodingType,
67 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
68 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
69 static BOOL WINAPI CRYPT_AsnEncodeSequenceOfAny(DWORD dwCertEncodingType,
70 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
71 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
72 static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
73 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
74 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
75 static BOOL WINAPI CRYPT_AsnEncodePubKeyInfo(DWORD dwCertEncodingType,
76 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
77 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
78 static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType,
79 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
80 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
81 static BOOL WINAPI CRYPT_AsnEncodeBitsSwapBytes(DWORD dwCertEncodingType,
82 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
83 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
84 static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType,
85 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
86 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
87 static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType,
88 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
89 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
90 static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType,
91 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
92 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
93 static BOOL WINAPI CRYPT_AsnEncodeChoiceOfTime(DWORD dwCertEncodingType,
94 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
95 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
97 BOOL CRYPT_EncodeEnsureSpace(DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara,
98 BYTE *pbEncoded, DWORD *pcbEncoded, DWORD bytesNeeded)
100 BOOL ret = TRUE;
102 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
104 if (pEncodePara && pEncodePara->pfnAlloc)
105 *(BYTE **)pbEncoded = pEncodePara->pfnAlloc(bytesNeeded);
106 else
107 *(BYTE **)pbEncoded = LocalAlloc(0, bytesNeeded);
108 if (!*(BYTE **)pbEncoded)
109 ret = FALSE;
110 else
111 *pcbEncoded = bytesNeeded;
113 else if (bytesNeeded > *pcbEncoded)
115 *pcbEncoded = bytesNeeded;
116 SetLastError(ERROR_MORE_DATA);
117 ret = FALSE;
119 else
120 *pcbEncoded = bytesNeeded;
121 return ret;
124 BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded)
126 DWORD bytesNeeded, significantBytes = 0;
128 if (len <= 0x7f)
129 bytesNeeded = 1;
130 else
132 DWORD temp;
134 for (temp = len, significantBytes = sizeof(temp); !(temp & 0xff000000);
135 temp <<= 8, significantBytes--)
137 bytesNeeded = significantBytes + 1;
139 if (!pbEncoded)
141 *pcbEncoded = bytesNeeded;
142 return TRUE;
144 if (*pcbEncoded < bytesNeeded)
146 SetLastError(ERROR_MORE_DATA);
147 return FALSE;
149 if (len <= 0x7f)
150 *pbEncoded = (BYTE)len;
151 else
153 DWORD i;
155 *pbEncoded++ = significantBytes | 0x80;
156 for (i = 0; i < significantBytes; i++)
158 *(pbEncoded + significantBytes - i - 1) = (BYTE)(len & 0xff);
159 len >>= 8;
162 *pcbEncoded = bytesNeeded;
163 return TRUE;
166 BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
167 struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags,
168 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
170 BOOL ret;
171 DWORD i, dataLen = 0;
173 TRACE("%p, %d, %08x, %p, %p, %d\n", items, cItem, dwFlags, pEncodePara,
174 pbEncoded, *pcbEncoded);
175 for (i = 0, ret = TRUE; ret && i < cItem; i++)
177 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
178 items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL,
179 NULL, &items[i].size);
180 /* Some functions propagate their errors through the size */
181 if (!ret)
182 *pcbEncoded = items[i].size;
183 dataLen += items[i].size;
185 if (ret)
187 DWORD lenBytes, bytesNeeded;
189 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
190 bytesNeeded = 1 + lenBytes + dataLen;
191 if (!pbEncoded)
192 *pcbEncoded = bytesNeeded;
193 else
195 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
196 pcbEncoded, bytesNeeded)))
198 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
199 pbEncoded = *(BYTE **)pbEncoded;
200 *pbEncoded++ = ASN_SEQUENCE;
201 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
202 pbEncoded += lenBytes;
203 for (i = 0; ret && i < cItem; i++)
205 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
206 items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG,
207 NULL, pbEncoded, &items[i].size);
208 /* Some functions propagate their errors through the size */
209 if (!ret)
210 *pcbEncoded = items[i].size;
211 pbEncoded += items[i].size;
216 TRACE("returning %d (%08x)\n", ret, GetLastError());
217 return ret;
220 BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType,
221 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
222 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
224 BOOL ret;
225 const struct AsnConstructedItem *item =
226 (const struct AsnConstructedItem *)pvStructInfo;
227 DWORD len;
229 if ((ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
230 item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &len)))
232 DWORD dataLen, bytesNeeded;
234 CRYPT_EncodeLen(len, NULL, &dataLen);
235 bytesNeeded = 1 + dataLen + len;
236 if (!pbEncoded)
237 *pcbEncoded = bytesNeeded;
238 else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
239 pbEncoded, pcbEncoded, bytesNeeded)))
241 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
242 pbEncoded = *(BYTE **)pbEncoded;
243 *pbEncoded++ = ASN_CONTEXT | ASN_CONSTRUCTOR | item->tag;
244 CRYPT_EncodeLen(len, pbEncoded, &dataLen);
245 pbEncoded += dataLen;
246 ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
247 item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL,
248 pbEncoded, &len);
249 if (!ret)
251 /* Some functions propagate their errors through the size */
252 *pcbEncoded = len;
256 else
258 /* Some functions propagate their errors through the size */
259 *pcbEncoded = len;
261 return ret;
264 struct AsnEncodeTagSwappedItem
266 BYTE tag;
267 const void *pvStructInfo;
268 CryptEncodeObjectExFunc encodeFunc;
271 /* Sort of a wacky hack, it encodes something using the struct
272 * AsnEncodeTagSwappedItem's encodeFunc, then replaces the tag byte with the tag
273 * given in the struct AsnEncodeTagSwappedItem.
275 static BOOL WINAPI CRYPT_AsnEncodeSwapTag(DWORD dwCertEncodingType,
276 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
277 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
279 BOOL ret;
280 const struct AsnEncodeTagSwappedItem *item =
281 (const struct AsnEncodeTagSwappedItem *)pvStructInfo;
283 ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
284 item->pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
285 if (ret && pbEncoded)
286 *pbEncoded = item->tag;
287 return ret;
290 static BOOL WINAPI CRYPT_AsnEncodeCertVersion(DWORD dwCertEncodingType,
291 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
292 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
294 const DWORD *ver = (const DWORD *)pvStructInfo;
295 BOOL ret;
297 /* CERT_V1 is not encoded */
298 if (*ver == CERT_V1)
300 *pcbEncoded = 0;
301 ret = TRUE;
303 else
305 struct AsnConstructedItem item = { 0, ver, CRYPT_AsnEncodeInt };
307 ret = CRYPT_AsnEncodeConstructed(dwCertEncodingType, X509_INTEGER,
308 &item, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
310 return ret;
313 static BOOL WINAPI CRYPT_CopyEncodedBlob(DWORD dwCertEncodingType,
314 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
315 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
317 const CRYPT_DER_BLOB *blob = (const CRYPT_DER_BLOB *)pvStructInfo;
318 BOOL ret;
320 if (!pbEncoded)
322 *pcbEncoded = blob->cbData;
323 ret = TRUE;
325 else
327 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
328 pcbEncoded, blob->cbData)))
330 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
331 pbEncoded = *(BYTE **)pbEncoded;
332 if (blob->cbData)
333 memcpy(pbEncoded, blob->pbData, blob->cbData);
334 *pcbEncoded = blob->cbData;
335 ret = TRUE;
338 return ret;
341 static BOOL WINAPI CRYPT_AsnEncodeValidity(DWORD dwCertEncodingType,
342 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
343 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
345 BOOL ret;
346 /* This has two filetimes in a row, a NotBefore and a NotAfter */
347 const FILETIME *timePtr = (const FILETIME *)pvStructInfo;
348 struct AsnEncodeSequenceItem items[] = {
349 { timePtr++, CRYPT_AsnEncodeChoiceOfTime, 0 },
350 { timePtr, CRYPT_AsnEncodeChoiceOfTime, 0 },
353 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
354 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
355 pcbEncoded);
356 return ret;
359 /* Like CRYPT_AsnEncodeAlgorithmId, but encodes parameters as an asn.1 NULL
360 * if they are empty.
362 static BOOL WINAPI CRYPT_AsnEncodeAlgorithmIdWithNullParams(
363 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
364 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
365 DWORD *pcbEncoded)
367 const CRYPT_ALGORITHM_IDENTIFIER *algo =
368 (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
369 static const BYTE asn1Null[] = { ASN_NULL, 0 };
370 static const CRYPT_DATA_BLOB nullBlob = { sizeof(asn1Null),
371 (LPBYTE)asn1Null };
372 BOOL ret;
373 struct AsnEncodeSequenceItem items[2] = {
374 { algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
375 { NULL, CRYPT_CopyEncodedBlob, 0 },
378 if (algo->Parameters.cbData)
379 items[1].pvStructInfo = &algo->Parameters;
380 else
381 items[1].pvStructInfo = &nullBlob;
382 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
383 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
384 pcbEncoded);
385 return ret;
388 static BOOL WINAPI CRYPT_AsnEncodeAlgorithmId(DWORD dwCertEncodingType,
389 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
390 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
392 const CRYPT_ALGORITHM_IDENTIFIER *algo =
393 (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
394 BOOL ret;
395 struct AsnEncodeSequenceItem items[] = {
396 { algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
397 { &algo->Parameters, CRYPT_CopyEncodedBlob, 0 },
400 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
401 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
402 pcbEncoded);
403 return ret;
406 static BOOL WINAPI CRYPT_AsnEncodePubKeyInfo(DWORD dwCertEncodingType,
407 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
408 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
410 BOOL ret;
412 __TRY
414 const CERT_PUBLIC_KEY_INFO *info =
415 (const CERT_PUBLIC_KEY_INFO *)pvStructInfo;
416 struct AsnEncodeSequenceItem items[] = {
417 { &info->Algorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
418 { &info->PublicKey, CRYPT_AsnEncodeBits, 0 },
421 TRACE("Encoding public key with OID %s\n",
422 debugstr_a(info->Algorithm.pszObjId));
423 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
424 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
425 pcbEncoded);
427 __EXCEPT_PAGE_FAULT
429 SetLastError(STATUS_ACCESS_VIOLATION);
430 ret = FALSE;
432 __ENDTRY
433 return ret;
436 static BOOL WINAPI CRYPT_AsnEncodeCert(DWORD dwCertEncodingType,
437 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
438 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
440 BOOL ret;
442 __TRY
444 const CERT_SIGNED_CONTENT_INFO *info =
445 (const CERT_SIGNED_CONTENT_INFO *)pvStructInfo;
446 struct AsnEncodeSequenceItem items[] = {
447 { &info->ToBeSigned, CRYPT_CopyEncodedBlob, 0 },
448 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
449 { &info->Signature, CRYPT_AsnEncodeBitsSwapBytes, 0 },
452 if (dwFlags & CRYPT_ENCODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG)
453 items[2].encodeFunc = CRYPT_AsnEncodeBits;
454 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
455 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
456 pcbEncoded);
458 __EXCEPT_PAGE_FAULT
460 SetLastError(STATUS_ACCESS_VIOLATION);
461 ret = FALSE;
463 __ENDTRY
464 return ret;
467 /* Like in Windows, this blithely ignores the validity of the passed-in
468 * CERT_INFO, and just encodes it as-is. The resulting encoded data may not
469 * decode properly, see CRYPT_AsnDecodeCertInfo.
471 static BOOL WINAPI CRYPT_AsnEncodeCertInfo(DWORD dwCertEncodingType,
472 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
473 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
475 BOOL ret;
477 __TRY
479 const CERT_INFO *info = (const CERT_INFO *)pvStructInfo;
480 struct AsnEncodeSequenceItem items[10] = {
481 { &info->dwVersion, CRYPT_AsnEncodeCertVersion, 0 },
482 { &info->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
483 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
484 { &info->Issuer, CRYPT_CopyEncodedBlob, 0 },
485 { &info->NotBefore, CRYPT_AsnEncodeValidity, 0 },
486 { &info->Subject, CRYPT_CopyEncodedBlob, 0 },
487 { &info->SubjectPublicKeyInfo, CRYPT_AsnEncodePubKeyInfo, 0 },
488 { 0 }
490 struct AsnConstructedItem constructed[3] = { { 0 } };
491 DWORD cItem = 7, cConstructed = 0;
493 if (info->IssuerUniqueId.cbData)
495 constructed[cConstructed].tag = 1;
496 constructed[cConstructed].pvStructInfo = &info->IssuerUniqueId;
497 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeBits;
498 items[cItem].pvStructInfo = &constructed[cConstructed];
499 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
500 cConstructed++;
501 cItem++;
503 if (info->SubjectUniqueId.cbData)
505 constructed[cConstructed].tag = 2;
506 constructed[cConstructed].pvStructInfo = &info->SubjectUniqueId;
507 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeBits;
508 items[cItem].pvStructInfo = &constructed[cConstructed];
509 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
510 cConstructed++;
511 cItem++;
513 if (info->cExtension)
515 constructed[cConstructed].tag = 3;
516 constructed[cConstructed].pvStructInfo = &info->cExtension;
517 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeExtensions;
518 items[cItem].pvStructInfo = &constructed[cConstructed];
519 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
520 cConstructed++;
521 cItem++;
524 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
525 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
527 __EXCEPT_PAGE_FAULT
529 SetLastError(STATUS_ACCESS_VIOLATION);
530 ret = FALSE;
532 __ENDTRY
533 return ret;
536 static BOOL WINAPI CRYPT_AsnEncodeCRLEntry(const CRL_ENTRY *entry,
537 BYTE *pbEncoded, DWORD *pcbEncoded)
539 struct AsnEncodeSequenceItem items[3] = {
540 { &entry->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
541 { &entry->RevocationDate, CRYPT_AsnEncodeChoiceOfTime, 0 },
542 { 0 }
544 DWORD cItem = 2;
545 BOOL ret;
547 TRACE("%p, %p, %p\n", entry, pbEncoded, pcbEncoded);
549 if (entry->cExtension)
551 items[cItem].pvStructInfo = &entry->cExtension;
552 items[cItem].encodeFunc = CRYPT_AsnEncodeExtensions;
553 cItem++;
556 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
557 pbEncoded, pcbEncoded);
559 TRACE("returning %d (%08x)\n", ret, GetLastError());
560 return ret;
563 static BOOL WINAPI CRYPT_AsnEncodeCRLEntries(DWORD dwCertEncodingType,
564 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
565 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
567 DWORD cCRLEntry = *(const DWORD *)pvStructInfo;
568 DWORD bytesNeeded, dataLen, lenBytes, i;
569 const CRL_ENTRY *rgCRLEntry = *(const CRL_ENTRY *const *)
570 ((const BYTE *)pvStructInfo + sizeof(DWORD));
571 BOOL ret = TRUE;
573 for (i = 0, dataLen = 0; ret && i < cCRLEntry; i++)
575 DWORD size;
577 ret = CRYPT_AsnEncodeCRLEntry(&rgCRLEntry[i], NULL, &size);
578 if (ret)
579 dataLen += size;
581 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
582 bytesNeeded = 1 + lenBytes + dataLen;
583 if (!pbEncoded)
584 *pcbEncoded = bytesNeeded;
585 else
587 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
588 pcbEncoded, bytesNeeded)))
590 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
591 pbEncoded = *(BYTE **)pbEncoded;
592 *pbEncoded++ = ASN_SEQUENCEOF;
593 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
594 pbEncoded += lenBytes;
595 for (i = 0; i < cCRLEntry; i++)
597 DWORD size = dataLen;
599 ret = CRYPT_AsnEncodeCRLEntry(&rgCRLEntry[i], pbEncoded, &size);
600 pbEncoded += size;
601 dataLen -= size;
605 return ret;
608 static BOOL WINAPI CRYPT_AsnEncodeCRLVersion(DWORD dwCertEncodingType,
609 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
610 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
612 const DWORD *ver = (const DWORD *)pvStructInfo;
613 BOOL ret;
615 /* CRL_V1 is not encoded */
616 if (*ver == CRL_V1)
618 *pcbEncoded = 0;
619 ret = TRUE;
621 else
622 ret = CRYPT_AsnEncodeInt(dwCertEncodingType, X509_INTEGER, ver,
623 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
624 return ret;
627 /* Like in Windows, this blithely ignores the validity of the passed-in
628 * CRL_INFO, and just encodes it as-is. The resulting encoded data may not
629 * decode properly, see CRYPT_AsnDecodeCRLInfo.
631 static BOOL WINAPI CRYPT_AsnEncodeCRLInfo(DWORD dwCertEncodingType,
632 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
633 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
635 BOOL ret;
637 __TRY
639 const CRL_INFO *info = (const CRL_INFO *)pvStructInfo;
640 struct AsnEncodeSequenceItem items[7] = {
641 { &info->dwVersion, CRYPT_AsnEncodeCRLVersion, 0 },
642 { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
643 { &info->Issuer, CRYPT_CopyEncodedBlob, 0 },
644 { &info->ThisUpdate, CRYPT_AsnEncodeChoiceOfTime, 0 },
645 { 0 }
647 struct AsnConstructedItem constructed[1] = { { 0 } };
648 DWORD cItem = 4, cConstructed = 0;
650 if (info->NextUpdate.dwLowDateTime || info->NextUpdate.dwHighDateTime)
652 items[cItem].pvStructInfo = &info->NextUpdate;
653 items[cItem].encodeFunc = CRYPT_AsnEncodeChoiceOfTime;
654 cItem++;
656 if (info->cCRLEntry)
658 items[cItem].pvStructInfo = &info->cCRLEntry;
659 items[cItem].encodeFunc = CRYPT_AsnEncodeCRLEntries;
660 cItem++;
662 if (info->cExtension)
664 constructed[cConstructed].tag = 0;
665 constructed[cConstructed].pvStructInfo = &info->cExtension;
666 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeExtensions;
667 items[cItem].pvStructInfo = &constructed[cConstructed];
668 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
669 cConstructed++;
670 cItem++;
673 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
674 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
676 __EXCEPT_PAGE_FAULT
678 SetLastError(STATUS_ACCESS_VIOLATION);
679 ret = FALSE;
681 __ENDTRY
682 return ret;
685 static BOOL CRYPT_AsnEncodeExtension(CERT_EXTENSION *ext, BYTE *pbEncoded,
686 DWORD *pcbEncoded)
688 BOOL ret;
689 struct AsnEncodeSequenceItem items[3] = {
690 { ext->pszObjId, CRYPT_AsnEncodeOid, 0 },
691 { NULL, NULL, 0 },
692 { NULL, NULL, 0 },
694 DWORD cItem = 1;
696 TRACE("%p, %p, %d\n", ext, pbEncoded, *pcbEncoded);
698 if (ext->fCritical)
700 items[cItem].pvStructInfo = &ext->fCritical;
701 items[cItem].encodeFunc = CRYPT_AsnEncodeBool;
702 cItem++;
704 items[cItem].pvStructInfo = &ext->Value;
705 items[cItem].encodeFunc = CRYPT_AsnEncodeOctets;
706 cItem++;
708 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
709 pbEncoded, pcbEncoded);
710 TRACE("returning %d (%08x)\n", ret, GetLastError());
711 return ret;
714 static BOOL WINAPI CRYPT_AsnEncodeExtensions(DWORD dwCertEncodingType,
715 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
716 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
718 BOOL ret;
720 __TRY
722 DWORD bytesNeeded, dataLen, lenBytes, i;
723 const CERT_EXTENSIONS *exts = (const CERT_EXTENSIONS *)pvStructInfo;
725 ret = TRUE;
726 for (i = 0, dataLen = 0; ret && i < exts->cExtension; i++)
728 DWORD size;
730 ret = CRYPT_AsnEncodeExtension(&exts->rgExtension[i], NULL, &size);
731 if (ret)
732 dataLen += size;
734 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
735 bytesNeeded = 1 + lenBytes + dataLen;
736 if (!pbEncoded)
737 *pcbEncoded = bytesNeeded;
738 else
740 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
741 pcbEncoded, bytesNeeded)))
743 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
744 pbEncoded = *(BYTE **)pbEncoded;
745 *pbEncoded++ = ASN_SEQUENCEOF;
746 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
747 pbEncoded += lenBytes;
748 for (i = 0; i < exts->cExtension; i++)
750 DWORD size = dataLen;
752 ret = CRYPT_AsnEncodeExtension(&exts->rgExtension[i],
753 pbEncoded, &size);
754 pbEncoded += size;
755 dataLen -= size;
760 __EXCEPT_PAGE_FAULT
762 SetLastError(STATUS_ACCESS_VIOLATION);
763 ret = FALSE;
765 __ENDTRY
766 return ret;
769 BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
770 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
771 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
773 LPCSTR pszObjId = (LPCSTR)pvStructInfo;
774 DWORD bytesNeeded = 0, lenBytes;
775 BOOL ret = TRUE;
776 int firstPos = 0;
777 BYTE firstByte = 0;
779 TRACE("%s\n", debugstr_a(pszObjId));
781 if (pszObjId)
783 const char *ptr;
784 int val1, val2;
786 if (sscanf(pszObjId, "%d.%d.%n", &val1, &val2, &firstPos) != 2)
788 SetLastError(CRYPT_E_ASN1_ERROR);
789 return FALSE;
791 bytesNeeded++;
792 firstByte = val1 * 40 + val2;
793 ptr = pszObjId + firstPos;
794 while (ret && *ptr)
796 int pos;
798 /* note I assume each component is at most 32-bits long in base 2 */
799 if (sscanf(ptr, "%d%n", &val1, &pos) == 1)
801 if (val1 >= 0x10000000)
802 bytesNeeded += 5;
803 else if (val1 >= 0x200000)
804 bytesNeeded += 4;
805 else if (val1 >= 0x4000)
806 bytesNeeded += 3;
807 else if (val1 >= 0x80)
808 bytesNeeded += 2;
809 else
810 bytesNeeded += 1;
811 ptr += pos;
812 if (*ptr == '.')
813 ptr++;
815 else
817 SetLastError(CRYPT_E_ASN1_ERROR);
818 return FALSE;
821 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
823 else
824 lenBytes = 1;
825 bytesNeeded += 1 + lenBytes;
826 if (pbEncoded)
828 if (*pcbEncoded < bytesNeeded)
830 SetLastError(ERROR_MORE_DATA);
831 ret = FALSE;
833 else
835 *pbEncoded++ = ASN_OBJECTIDENTIFIER;
836 CRYPT_EncodeLen(bytesNeeded - 1 - lenBytes, pbEncoded, &lenBytes);
837 pbEncoded += lenBytes;
838 if (pszObjId)
840 const char *ptr;
841 int val, pos;
843 *pbEncoded++ = firstByte;
844 ptr = pszObjId + firstPos;
845 while (ret && *ptr)
847 sscanf(ptr, "%d%n", &val, &pos);
849 unsigned char outBytes[5];
850 int numBytes, i;
852 if (val >= 0x10000000)
853 numBytes = 5;
854 else if (val >= 0x200000)
855 numBytes = 4;
856 else if (val >= 0x4000)
857 numBytes = 3;
858 else if (val >= 0x80)
859 numBytes = 2;
860 else
861 numBytes = 1;
862 for (i = numBytes; i > 0; i--)
864 outBytes[i - 1] = val & 0x7f;
865 val >>= 7;
867 for (i = 0; i < numBytes - 1; i++)
868 *pbEncoded++ = outBytes[i] | 0x80;
869 *pbEncoded++ = outBytes[i];
870 ptr += pos;
871 if (*ptr == '.')
872 ptr++;
878 *pcbEncoded = bytesNeeded;
879 return ret;
882 static BOOL CRYPT_AsnEncodeStringCoerce(const CERT_NAME_VALUE *value,
883 BYTE tag, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
884 DWORD *pcbEncoded)
886 BOOL ret = TRUE;
887 LPCSTR str = (LPCSTR)value->Value.pbData;
888 DWORD bytesNeeded, lenBytes, encodedLen;
890 encodedLen = value->Value.cbData ? value->Value.cbData : lstrlenA(str);
891 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
892 bytesNeeded = 1 + lenBytes + encodedLen;
893 if (!pbEncoded)
894 *pcbEncoded = bytesNeeded;
895 else
897 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
898 pbEncoded, pcbEncoded, bytesNeeded)))
900 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
901 pbEncoded = *(BYTE **)pbEncoded;
902 *pbEncoded++ = tag;
903 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
904 pbEncoded += lenBytes;
905 memcpy(pbEncoded, str, encodedLen);
908 return ret;
911 static BOOL CRYPT_AsnEncodeBMPString(const CERT_NAME_VALUE *value,
912 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
913 DWORD *pcbEncoded)
915 BOOL ret = TRUE;
916 LPCWSTR str = (LPCWSTR)value->Value.pbData;
917 DWORD bytesNeeded, lenBytes, strLen;
919 if (value->Value.cbData)
920 strLen = value->Value.cbData / sizeof(WCHAR);
921 else if (value->Value.pbData)
922 strLen = lstrlenW(str);
923 else
924 strLen = 0;
925 CRYPT_EncodeLen(strLen * 2, NULL, &lenBytes);
926 bytesNeeded = 1 + lenBytes + strLen * 2;
927 if (!pbEncoded)
928 *pcbEncoded = bytesNeeded;
929 else
931 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
932 pbEncoded, pcbEncoded, bytesNeeded)))
934 DWORD i;
936 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
937 pbEncoded = *(BYTE **)pbEncoded;
938 *pbEncoded++ = ASN_BMPSTRING;
939 CRYPT_EncodeLen(strLen * 2, pbEncoded, &lenBytes);
940 pbEncoded += lenBytes;
941 for (i = 0; i < strLen; i++)
943 *pbEncoded++ = (str[i] & 0xff00) >> 8;
944 *pbEncoded++ = str[i] & 0x00ff;
948 return ret;
951 static BOOL CRYPT_AsnEncodeUTF8String(const CERT_NAME_VALUE *value,
952 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
953 DWORD *pcbEncoded)
955 BOOL ret = TRUE;
956 LPCWSTR str = (LPCWSTR)value->Value.pbData;
957 DWORD bytesNeeded, lenBytes, encodedLen, strLen;
959 strLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
960 lstrlenW(str);
961 encodedLen = WideCharToMultiByte(CP_UTF8, 0, str, strLen, NULL, 0, NULL,
962 NULL);
963 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
964 bytesNeeded = 1 + lenBytes + encodedLen;
965 if (!pbEncoded)
966 *pcbEncoded = bytesNeeded;
967 else
969 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
970 pbEncoded, pcbEncoded, bytesNeeded)))
972 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
973 pbEncoded = *(BYTE **)pbEncoded;
974 *pbEncoded++ = ASN_UTF8STRING;
975 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
976 pbEncoded += lenBytes;
977 WideCharToMultiByte(CP_UTF8, 0, str, strLen, (LPSTR)pbEncoded,
978 bytesNeeded - lenBytes - 1, NULL, NULL);
981 return ret;
984 static BOOL WINAPI CRYPT_AsnEncodeNameValue(DWORD dwCertEncodingType,
985 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
986 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
988 BOOL ret = TRUE;
990 __TRY
992 const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
994 switch (value->dwValueType)
996 case CERT_RDN_ANY_TYPE:
997 /* explicitly disallowed */
998 SetLastError(E_INVALIDARG);
999 ret = FALSE;
1000 break;
1001 case CERT_RDN_ENCODED_BLOB:
1002 ret = CRYPT_CopyEncodedBlob(dwCertEncodingType, NULL,
1003 &value->Value, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1004 break;
1005 case CERT_RDN_OCTET_STRING:
1006 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_OCTETSTRING,
1007 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1008 break;
1009 case CERT_RDN_NUMERIC_STRING:
1010 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_NUMERICSTRING,
1011 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1012 break;
1013 case CERT_RDN_PRINTABLE_STRING:
1014 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_PRINTABLESTRING,
1015 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1016 break;
1017 case CERT_RDN_TELETEX_STRING:
1018 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_T61STRING,
1019 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1020 break;
1021 case CERT_RDN_VIDEOTEX_STRING:
1022 ret = CRYPT_AsnEncodeStringCoerce(value,
1023 ASN_VIDEOTEXSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1024 break;
1025 case CERT_RDN_IA5_STRING:
1026 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_IA5STRING,
1027 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1028 break;
1029 case CERT_RDN_GRAPHIC_STRING:
1030 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_GRAPHICSTRING,
1031 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1032 break;
1033 case CERT_RDN_VISIBLE_STRING:
1034 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_VISIBLESTRING,
1035 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1036 break;
1037 case CERT_RDN_GENERAL_STRING:
1038 ret = CRYPT_AsnEncodeStringCoerce(value, ASN_GENERALSTRING,
1039 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1040 break;
1041 case CERT_RDN_UNIVERSAL_STRING:
1042 FIXME("CERT_RDN_UNIVERSAL_STRING: unimplemented\n");
1043 SetLastError(CRYPT_E_ASN1_CHOICE);
1044 ret = FALSE;
1045 break;
1046 case CERT_RDN_BMP_STRING:
1047 ret = CRYPT_AsnEncodeBMPString(value, dwFlags, pEncodePara,
1048 pbEncoded, pcbEncoded);
1049 break;
1050 case CERT_RDN_UTF8_STRING:
1051 ret = CRYPT_AsnEncodeUTF8String(value, dwFlags, pEncodePara,
1052 pbEncoded, pcbEncoded);
1053 break;
1054 default:
1055 SetLastError(CRYPT_E_ASN1_CHOICE);
1056 ret = FALSE;
1059 __EXCEPT_PAGE_FAULT
1061 SetLastError(STATUS_ACCESS_VIOLATION);
1062 ret = FALSE;
1064 __ENDTRY
1065 return ret;
1068 static BOOL WINAPI CRYPT_AsnEncodeRdnAttr(DWORD dwCertEncodingType,
1069 CERT_RDN_ATTR *attr, CryptEncodeObjectExFunc nameValueEncodeFunc,
1070 BYTE *pbEncoded, DWORD *pcbEncoded)
1072 DWORD bytesNeeded = 0, lenBytes, size;
1073 BOOL ret;
1075 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL, attr->pszObjId,
1076 0, NULL, NULL, &size);
1077 if (ret)
1079 bytesNeeded += size;
1080 /* hack: a CERT_RDN_ATTR is identical to a CERT_NAME_VALUE beginning
1081 * with dwValueType, so "cast" it to get its encoded size
1083 ret = nameValueEncodeFunc(dwCertEncodingType, NULL,
1084 (CERT_NAME_VALUE *)&attr->dwValueType, 0, NULL, NULL, &size);
1085 if (ret)
1087 bytesNeeded += size;
1088 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1089 bytesNeeded += 1 + lenBytes;
1090 if (pbEncoded)
1092 if (*pcbEncoded < bytesNeeded)
1094 SetLastError(ERROR_MORE_DATA);
1095 ret = FALSE;
1097 else
1099 *pbEncoded++ = ASN_SEQUENCE;
1100 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
1101 &lenBytes);
1102 pbEncoded += lenBytes;
1103 size = bytesNeeded - 1 - lenBytes;
1104 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
1105 attr->pszObjId, 0, NULL, pbEncoded, &size);
1106 if (ret)
1108 pbEncoded += size;
1109 size = bytesNeeded - 1 - lenBytes - size;
1110 ret = nameValueEncodeFunc(dwCertEncodingType,
1111 NULL, (CERT_NAME_VALUE *)&attr->dwValueType,
1112 0, NULL, pbEncoded, &size);
1113 if (!ret)
1114 *pcbEncoded = size;
1118 if (ret)
1119 *pcbEncoded = bytesNeeded;
1121 else
1123 /* Have to propagate index of failing character */
1124 *pcbEncoded = size;
1127 return ret;
1130 static int BLOBComp(const void *l, const void *r)
1132 const CRYPT_DER_BLOB *a = (const CRYPT_DER_BLOB *)l, *b = (const CRYPT_DER_BLOB *)r;
1133 int ret;
1135 if (!(ret = memcmp(a->pbData, b->pbData, min(a->cbData, b->cbData))))
1136 ret = a->cbData - b->cbData;
1137 return ret;
1140 /* This encodes a SET OF, which in DER must be lexicographically sorted.
1142 static BOOL WINAPI CRYPT_DEREncodeSet(DWORD dwCertEncodingType,
1143 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1144 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1146 const CRYPT_BLOB_ARRAY *set = (const CRYPT_BLOB_ARRAY *)pvStructInfo;
1147 DWORD bytesNeeded = 0, lenBytes, i;
1148 BOOL ret;
1150 for (i = 0; i < set->cBlob; i++)
1151 bytesNeeded += set->rgBlob[i].cbData;
1152 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1153 bytesNeeded += 1 + lenBytes;
1154 if (!pbEncoded)
1156 *pcbEncoded = bytesNeeded;
1157 ret = TRUE;
1159 else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1160 pbEncoded, pcbEncoded, bytesNeeded)))
1162 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1163 pbEncoded = *(BYTE **)pbEncoded;
1164 qsort(set->rgBlob, set->cBlob, sizeof(CRYPT_DER_BLOB), BLOBComp);
1165 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_SETOF;
1166 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded, &lenBytes);
1167 pbEncoded += lenBytes;
1168 for (i = 0; ret && i < set->cBlob; i++)
1170 memcpy(pbEncoded, set->rgBlob[i].pbData, set->rgBlob[i].cbData);
1171 pbEncoded += set->rgBlob[i].cbData;
1174 return ret;
1177 struct DERSetDescriptor
1179 DWORD cItems;
1180 const void *items;
1181 size_t itemSize;
1182 size_t itemOffset;
1183 CryptEncodeObjectExFunc encode;
1186 static BOOL WINAPI CRYPT_DEREncodeItemsAsSet(DWORD dwCertEncodingType,
1187 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1188 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1190 const struct DERSetDescriptor *desc =
1191 (const struct DERSetDescriptor *)pvStructInfo;
1192 CRYPT_BLOB_ARRAY setOf = { 0, NULL };
1193 BOOL ret = TRUE;
1194 DWORD i;
1196 if (desc->cItems)
1198 setOf.rgBlob = CryptMemAlloc(desc->cItems * sizeof(CRYPT_DER_BLOB));
1199 if (!setOf.rgBlob)
1200 ret = FALSE;
1201 else
1203 setOf.cBlob = desc->cItems;
1204 memset(setOf.rgBlob, 0, setOf.cBlob * sizeof(CRYPT_DER_BLOB));
1207 for (i = 0; ret && i < setOf.cBlob; i++)
1209 ret = desc->encode(dwCertEncodingType, lpszStructType,
1210 (const BYTE *)desc->items + i * desc->itemSize + desc->itemOffset,
1211 0, NULL, NULL, &setOf.rgBlob[i].cbData);
1212 if (ret)
1214 setOf.rgBlob[i].pbData = CryptMemAlloc(setOf.rgBlob[i].cbData);
1215 if (!setOf.rgBlob[i].pbData)
1216 ret = FALSE;
1217 else
1218 ret = desc->encode(dwCertEncodingType, lpszStructType,
1219 (const BYTE *)desc->items + i * desc->itemSize +
1220 desc->itemOffset, 0, NULL, setOf.rgBlob[i].pbData,
1221 &setOf.rgBlob[i].cbData);
1223 /* Some functions propagate their errors through the size */
1224 if (!ret)
1225 *pcbEncoded = setOf.rgBlob[i].cbData;
1227 if (ret)
1229 DWORD bytesNeeded = 0, lenBytes;
1231 for (i = 0; i < setOf.cBlob; i++)
1232 bytesNeeded += setOf.rgBlob[i].cbData;
1233 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1234 bytesNeeded += 1 + lenBytes;
1235 if (!pbEncoded)
1236 *pcbEncoded = bytesNeeded;
1237 else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1238 pbEncoded, pcbEncoded, bytesNeeded)))
1240 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1241 pbEncoded = *(BYTE **)pbEncoded;
1242 qsort(setOf.rgBlob, setOf.cBlob, sizeof(CRYPT_DER_BLOB),
1243 BLOBComp);
1244 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_SETOF;
1245 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded, &lenBytes);
1246 pbEncoded += lenBytes;
1247 for (i = 0; i < setOf.cBlob; i++)
1249 memcpy(pbEncoded, setOf.rgBlob[i].pbData,
1250 setOf.rgBlob[i].cbData);
1251 pbEncoded += setOf.rgBlob[i].cbData;
1255 for (i = 0; i < setOf.cBlob; i++)
1256 CryptMemFree(setOf.rgBlob[i].pbData);
1257 CryptMemFree(setOf.rgBlob);
1258 return ret;
1261 static BOOL WINAPI CRYPT_AsnEncodeRdn(DWORD dwCertEncodingType, CERT_RDN *rdn,
1262 CryptEncodeObjectExFunc nameValueEncodeFunc, BYTE *pbEncoded,
1263 DWORD *pcbEncoded)
1265 BOOL ret;
1266 CRYPT_BLOB_ARRAY setOf = { 0, NULL };
1268 __TRY
1270 DWORD i;
1272 ret = TRUE;
1273 if (rdn->cRDNAttr)
1275 setOf.cBlob = rdn->cRDNAttr;
1276 setOf.rgBlob = CryptMemAlloc(rdn->cRDNAttr *
1277 sizeof(CRYPT_DER_BLOB));
1278 if (!setOf.rgBlob)
1279 ret = FALSE;
1280 else
1281 memset(setOf.rgBlob, 0, setOf.cBlob * sizeof(CRYPT_DER_BLOB));
1283 for (i = 0; ret && i < rdn->cRDNAttr; i++)
1285 setOf.rgBlob[i].cbData = 0;
1286 ret = CRYPT_AsnEncodeRdnAttr(dwCertEncodingType, &rdn->rgRDNAttr[i],
1287 nameValueEncodeFunc, NULL, &setOf.rgBlob[i].cbData);
1288 if (ret)
1290 setOf.rgBlob[i].pbData = CryptMemAlloc(setOf.rgBlob[i].cbData);
1291 if (!setOf.rgBlob[i].pbData)
1292 ret = FALSE;
1293 else
1294 ret = CRYPT_AsnEncodeRdnAttr(dwCertEncodingType,
1295 &rdn->rgRDNAttr[i], nameValueEncodeFunc,
1296 setOf.rgBlob[i].pbData, &setOf.rgBlob[i].cbData);
1298 if (!ret)
1300 /* Have to propagate index of failing character */
1301 *pcbEncoded = setOf.rgBlob[i].cbData;
1304 if (ret)
1305 ret = CRYPT_DEREncodeSet(X509_ASN_ENCODING, NULL, &setOf, 0, NULL,
1306 pbEncoded, pcbEncoded);
1307 for (i = 0; i < setOf.cBlob; i++)
1308 CryptMemFree(setOf.rgBlob[i].pbData);
1310 __EXCEPT_PAGE_FAULT
1312 SetLastError(STATUS_ACCESS_VIOLATION);
1313 ret = FALSE;
1315 __ENDTRY
1316 CryptMemFree(setOf.rgBlob);
1317 return ret;
1320 static BOOL WINAPI CRYPT_AsnEncodeUnicodeNameValue(DWORD dwCertEncodingType,
1321 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1322 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
1324 static BOOL WINAPI CRYPT_AsnEncodeOrCopyUnicodeNameValue(
1325 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
1326 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1327 DWORD *pcbEncoded)
1329 const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
1330 BOOL ret;
1332 if (value->dwValueType == CERT_RDN_ENCODED_BLOB)
1333 ret = CRYPT_CopyEncodedBlob(dwCertEncodingType, NULL, &value->Value,
1334 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1335 else
1336 ret = CRYPT_AsnEncodeUnicodeNameValue(dwCertEncodingType, NULL, value,
1337 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1338 return ret;
1341 static BOOL WINAPI CRYPT_AsnEncodeUnicodeName(DWORD dwCertEncodingType,
1342 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1343 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1345 BOOL ret = TRUE;
1347 __TRY
1349 const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo;
1350 DWORD bytesNeeded = 0, lenBytes, size, i;
1352 TRACE("encoding name with %d RDNs\n", info->cRDN);
1353 ret = TRUE;
1354 for (i = 0; ret && i < info->cRDN; i++)
1356 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType, &info->rgRDN[i],
1357 CRYPT_AsnEncodeOrCopyUnicodeNameValue, NULL, &size);
1358 if (ret)
1359 bytesNeeded += size;
1360 else
1361 *pcbEncoded = size;
1363 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1364 bytesNeeded += 1 + lenBytes;
1365 if (ret)
1367 if (!pbEncoded)
1368 *pcbEncoded = bytesNeeded;
1369 else
1371 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1372 pbEncoded, pcbEncoded, bytesNeeded)))
1374 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1375 pbEncoded = *(BYTE **)pbEncoded;
1376 *pbEncoded++ = ASN_SEQUENCEOF;
1377 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
1378 &lenBytes);
1379 pbEncoded += lenBytes;
1380 for (i = 0; ret && i < info->cRDN; i++)
1382 size = bytesNeeded;
1383 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType,
1384 &info->rgRDN[i], CRYPT_AsnEncodeOrCopyUnicodeNameValue,
1385 pbEncoded, &size);
1386 if (ret)
1388 pbEncoded += size;
1389 bytesNeeded -= size;
1391 else
1392 *pcbEncoded = size;
1398 __EXCEPT_PAGE_FAULT
1400 SetLastError(STATUS_ACCESS_VIOLATION);
1401 ret = FALSE;
1403 __ENDTRY
1404 return ret;
1407 static BOOL WINAPI CRYPT_AsnEncodePKCSAttribute(DWORD dwCertEncodingType,
1408 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1409 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1411 BOOL ret = FALSE;
1413 __TRY
1415 const CRYPT_ATTRIBUTE *attr = (const CRYPT_ATTRIBUTE *)pvStructInfo;
1417 if (!attr->pszObjId)
1418 SetLastError(E_INVALIDARG);
1419 else
1421 struct AsnEncodeSequenceItem items[2] = {
1422 { attr->pszObjId, CRYPT_AsnEncodeOid, 0 },
1423 { &attr->cValue, CRYPT_DEREncodeSet, 0 },
1426 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
1427 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
1428 pcbEncoded);
1431 __EXCEPT_PAGE_FAULT
1433 SetLastError(STATUS_ACCESS_VIOLATION);
1435 __ENDTRY
1436 return ret;
1439 static BOOL WINAPI CRYPT_AsnEncodePKCSAttributes(DWORD dwCertEncodingType,
1440 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1441 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1443 BOOL ret = FALSE;
1445 __TRY
1447 const CRYPT_ATTRIBUTES *attributes =
1448 (const CRYPT_ATTRIBUTES *)pvStructInfo;
1449 struct DERSetDescriptor desc = { attributes->cAttr, attributes->rgAttr,
1450 sizeof(CRYPT_ATTRIBUTE), 0, CRYPT_AsnEncodePKCSAttribute };
1452 ret = CRYPT_DEREncodeItemsAsSet(X509_ASN_ENCODING, lpszStructType,
1453 &desc, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1455 __EXCEPT_PAGE_FAULT
1457 SetLastError(STATUS_ACCESS_VIOLATION);
1459 __ENDTRY
1460 return ret;
1463 /* Like CRYPT_AsnEncodePKCSContentInfo, but allows the OID to be NULL */
1464 static BOOL WINAPI CRYPT_AsnEncodePKCSContentInfoInternal(
1465 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
1466 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1467 DWORD *pcbEncoded)
1469 const CRYPT_CONTENT_INFO *info = (const CRYPT_CONTENT_INFO *)pvStructInfo;
1470 struct AsnEncodeSequenceItem items[2] = {
1471 { info->pszObjId, CRYPT_AsnEncodeOid, 0 },
1472 { NULL, NULL, 0 },
1474 struct AsnConstructedItem constructed = { 0 };
1475 DWORD cItem = 1;
1477 if (info->Content.cbData)
1479 constructed.tag = 0;
1480 constructed.pvStructInfo = &info->Content;
1481 constructed.encodeFunc = CRYPT_CopyEncodedBlob;
1482 items[cItem].pvStructInfo = &constructed;
1483 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
1484 cItem++;
1486 return CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
1487 cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1490 BOOL CRYPT_AsnEncodePKCSDigestedData(CRYPT_DIGESTED_DATA *digestedData,
1491 void *pvData, DWORD *pcbData)
1493 struct AsnEncodeSequenceItem items[] = {
1494 { &digestedData->version, CRYPT_AsnEncodeInt, 0 },
1495 { &digestedData->DigestAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams,
1496 0 },
1497 { &digestedData->ContentInfo, CRYPT_AsnEncodePKCSContentInfoInternal, 0 },
1498 { &digestedData->hash, CRYPT_AsnEncodeOctets, 0 },
1501 return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items,
1502 sizeof(items) / sizeof(items[0]), 0, NULL, pvData, pcbData);
1505 static BOOL WINAPI CRYPT_AsnEncodePKCSContentInfo(DWORD dwCertEncodingType,
1506 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1507 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1509 BOOL ret = FALSE;
1511 __TRY
1513 const CRYPT_CONTENT_INFO *info =
1514 (const CRYPT_CONTENT_INFO *)pvStructInfo;
1516 if (!info->pszObjId)
1517 SetLastError(E_INVALIDARG);
1518 else
1519 ret = CRYPT_AsnEncodePKCSContentInfoInternal(dwCertEncodingType,
1520 lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded,
1521 pcbEncoded);
1523 __EXCEPT_PAGE_FAULT
1525 SetLastError(STATUS_ACCESS_VIOLATION);
1527 __ENDTRY
1528 return ret;
1531 static BOOL CRYPT_AsnEncodeUnicodeStringCoerce(const CERT_NAME_VALUE *value,
1532 BYTE tag, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1533 DWORD *pcbEncoded)
1535 BOOL ret = TRUE;
1536 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1537 DWORD bytesNeeded, lenBytes, encodedLen;
1539 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1540 lstrlenW(str);
1541 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
1542 bytesNeeded = 1 + lenBytes + encodedLen;
1543 if (!pbEncoded)
1544 *pcbEncoded = bytesNeeded;
1545 else
1547 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1548 pbEncoded, pcbEncoded, bytesNeeded)))
1550 DWORD i;
1552 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1553 pbEncoded = *(BYTE **)pbEncoded;
1554 *pbEncoded++ = tag;
1555 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
1556 pbEncoded += lenBytes;
1557 for (i = 0; i < encodedLen; i++)
1558 *pbEncoded++ = (BYTE)str[i];
1561 return ret;
1564 static BOOL CRYPT_AsnEncodeNumericString(const CERT_NAME_VALUE *value,
1565 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1566 DWORD *pcbEncoded)
1568 BOOL ret = TRUE;
1569 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1570 DWORD bytesNeeded, lenBytes, encodedLen;
1572 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1573 lstrlenW(str);
1574 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
1575 bytesNeeded = 1 + lenBytes + encodedLen;
1576 if (!pbEncoded)
1577 *pcbEncoded = bytesNeeded;
1578 else
1580 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1581 pbEncoded, pcbEncoded, bytesNeeded)))
1583 DWORD i;
1584 BYTE *ptr;
1586 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1587 ptr = *(BYTE **)pbEncoded;
1588 else
1589 ptr = pbEncoded;
1590 *ptr++ = ASN_NUMERICSTRING;
1591 CRYPT_EncodeLen(encodedLen, ptr, &lenBytes);
1592 ptr += lenBytes;
1593 for (i = 0; ret && i < encodedLen; i++)
1595 if (isdigitW(str[i]))
1596 *ptr++ = (BYTE)str[i];
1597 else
1599 *pcbEncoded = i;
1600 SetLastError(CRYPT_E_INVALID_NUMERIC_STRING);
1601 ret = FALSE;
1604 if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG))
1605 CryptMemFree(*(BYTE **)pbEncoded);
1608 return ret;
1611 static inline int isprintableW(WCHAR wc)
1613 return isalnumW(wc) || isspaceW(wc) || wc == '\'' || wc == '(' ||
1614 wc == ')' || wc == '+' || wc == ',' || wc == '-' || wc == '.' ||
1615 wc == '/' || wc == ':' || wc == '=' || wc == '?';
1618 static BOOL CRYPT_AsnEncodePrintableString(const CERT_NAME_VALUE *value,
1619 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1620 DWORD *pcbEncoded)
1622 BOOL ret = TRUE;
1623 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1624 DWORD bytesNeeded, lenBytes, encodedLen;
1626 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1627 lstrlenW(str);
1628 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
1629 bytesNeeded = 1 + lenBytes + encodedLen;
1630 if (!pbEncoded)
1631 *pcbEncoded = bytesNeeded;
1632 else
1634 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1635 pbEncoded, pcbEncoded, bytesNeeded)))
1637 DWORD i;
1638 BYTE *ptr;
1640 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1641 ptr = *(BYTE **)pbEncoded;
1642 else
1643 ptr = pbEncoded;
1644 *ptr++ = ASN_PRINTABLESTRING;
1645 CRYPT_EncodeLen(encodedLen, ptr, &lenBytes);
1646 ptr += lenBytes;
1647 for (i = 0; ret && i < encodedLen; i++)
1649 if (isprintableW(str[i]))
1650 *ptr++ = (BYTE)str[i];
1651 else
1653 *pcbEncoded = i;
1654 SetLastError(CRYPT_E_INVALID_PRINTABLE_STRING);
1655 ret = FALSE;
1658 if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG))
1659 CryptMemFree(*(BYTE **)pbEncoded);
1662 return ret;
1665 static BOOL CRYPT_AsnEncodeIA5String(const CERT_NAME_VALUE *value,
1666 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1667 DWORD *pcbEncoded)
1669 BOOL ret = TRUE;
1670 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1671 DWORD bytesNeeded, lenBytes, encodedLen;
1673 encodedLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1674 lstrlenW(str);
1675 CRYPT_EncodeLen(encodedLen, NULL, &lenBytes);
1676 bytesNeeded = 1 + lenBytes + encodedLen;
1677 if (!pbEncoded)
1678 *pcbEncoded = bytesNeeded;
1679 else
1681 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1682 pbEncoded, pcbEncoded, bytesNeeded)))
1684 DWORD i;
1685 BYTE *ptr;
1687 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1688 ptr = *(BYTE **)pbEncoded;
1689 else
1690 ptr = pbEncoded;
1691 *ptr++ = ASN_IA5STRING;
1692 CRYPT_EncodeLen(encodedLen, ptr, &lenBytes);
1693 ptr += lenBytes;
1694 for (i = 0; ret && i < encodedLen; i++)
1696 if (str[i] <= 0x7f)
1697 *ptr++ = (BYTE)str[i];
1698 else
1700 *pcbEncoded = i;
1701 SetLastError(CRYPT_E_INVALID_IA5_STRING);
1702 ret = FALSE;
1705 if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG))
1706 CryptMemFree(*(BYTE **)pbEncoded);
1709 return ret;
1712 static BOOL CRYPT_AsnEncodeUniversalString(const CERT_NAME_VALUE *value,
1713 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
1714 DWORD *pcbEncoded)
1716 BOOL ret = TRUE;
1717 LPCWSTR str = (LPCWSTR)value->Value.pbData;
1718 DWORD bytesNeeded, lenBytes, strLen;
1720 /* FIXME: doesn't handle composite characters */
1721 strLen = value->Value.cbData ? value->Value.cbData / sizeof(WCHAR) :
1722 lstrlenW(str);
1723 CRYPT_EncodeLen(strLen * 4, NULL, &lenBytes);
1724 bytesNeeded = 1 + lenBytes + strLen * 4;
1725 if (!pbEncoded)
1726 *pcbEncoded = bytesNeeded;
1727 else
1729 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1730 pbEncoded, pcbEncoded, bytesNeeded)))
1732 DWORD i;
1734 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1735 pbEncoded = *(BYTE **)pbEncoded;
1736 *pbEncoded++ = ASN_UNIVERSALSTRING;
1737 CRYPT_EncodeLen(strLen * 4, pbEncoded, &lenBytes);
1738 pbEncoded += lenBytes;
1739 for (i = 0; i < strLen; i++)
1741 *pbEncoded++ = 0;
1742 *pbEncoded++ = 0;
1743 *pbEncoded++ = (BYTE)((str[i] & 0xff00) >> 8);
1744 *pbEncoded++ = (BYTE)(str[i] & 0x00ff);
1748 return ret;
1751 static BOOL WINAPI CRYPT_AsnEncodeUnicodeNameValue(DWORD dwCertEncodingType,
1752 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1753 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1755 BOOL ret = FALSE;
1757 __TRY
1759 const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
1761 switch (value->dwValueType)
1763 case CERT_RDN_ANY_TYPE:
1764 case CERT_RDN_ENCODED_BLOB:
1765 case CERT_RDN_OCTET_STRING:
1766 SetLastError(CRYPT_E_NOT_CHAR_STRING);
1767 break;
1768 case CERT_RDN_NUMERIC_STRING:
1769 ret = CRYPT_AsnEncodeNumericString(value, dwFlags, pEncodePara,
1770 pbEncoded, pcbEncoded);
1771 break;
1772 case CERT_RDN_PRINTABLE_STRING:
1773 ret = CRYPT_AsnEncodePrintableString(value, dwFlags, pEncodePara,
1774 pbEncoded, pcbEncoded);
1775 break;
1776 case CERT_RDN_TELETEX_STRING:
1777 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_T61STRING,
1778 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1779 break;
1780 case CERT_RDN_VIDEOTEX_STRING:
1781 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value,
1782 ASN_VIDEOTEXSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1783 break;
1784 case CERT_RDN_IA5_STRING:
1785 ret = CRYPT_AsnEncodeIA5String(value, dwFlags, pEncodePara,
1786 pbEncoded, pcbEncoded);
1787 break;
1788 case CERT_RDN_GRAPHIC_STRING:
1789 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_GRAPHICSTRING,
1790 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1791 break;
1792 case CERT_RDN_VISIBLE_STRING:
1793 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_VISIBLESTRING,
1794 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1795 break;
1796 case CERT_RDN_GENERAL_STRING:
1797 ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_GENERALSTRING,
1798 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1799 break;
1800 case CERT_RDN_UNIVERSAL_STRING:
1801 ret = CRYPT_AsnEncodeUniversalString(value, dwFlags, pEncodePara,
1802 pbEncoded, pcbEncoded);
1803 break;
1804 case CERT_RDN_BMP_STRING:
1805 ret = CRYPT_AsnEncodeBMPString(value, dwFlags, pEncodePara,
1806 pbEncoded, pcbEncoded);
1807 break;
1808 case CERT_RDN_UTF8_STRING:
1809 ret = CRYPT_AsnEncodeUTF8String(value, dwFlags, pEncodePara,
1810 pbEncoded, pcbEncoded);
1811 break;
1812 default:
1813 SetLastError(CRYPT_E_ASN1_CHOICE);
1816 __EXCEPT_PAGE_FAULT
1818 SetLastError(STATUS_ACCESS_VIOLATION);
1820 __ENDTRY
1821 return ret;
1824 static BOOL WINAPI CRYPT_AsnEncodeName(DWORD dwCertEncodingType,
1825 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1826 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1828 BOOL ret;
1830 __TRY
1832 const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo;
1833 DWORD bytesNeeded = 0, lenBytes, size, i;
1835 TRACE("encoding name with %d RDNs\n", info->cRDN);
1836 ret = TRUE;
1837 for (i = 0; ret && i < info->cRDN; i++)
1839 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType, &info->rgRDN[i],
1840 CRYPT_AsnEncodeNameValue, NULL, &size);
1841 if (ret)
1842 bytesNeeded += size;
1844 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
1845 bytesNeeded += 1 + lenBytes;
1846 if (ret)
1848 if (!pbEncoded)
1849 *pcbEncoded = bytesNeeded;
1850 else
1852 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
1853 pbEncoded, pcbEncoded, bytesNeeded)))
1855 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
1856 pbEncoded = *(BYTE **)pbEncoded;
1857 *pbEncoded++ = ASN_SEQUENCEOF;
1858 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
1859 &lenBytes);
1860 pbEncoded += lenBytes;
1861 for (i = 0; ret && i < info->cRDN; i++)
1863 size = bytesNeeded;
1864 ret = CRYPT_AsnEncodeRdn(dwCertEncodingType,
1865 &info->rgRDN[i], CRYPT_AsnEncodeNameValue, pbEncoded,
1866 &size);
1867 if (ret)
1869 pbEncoded += size;
1870 bytesNeeded -= size;
1877 __EXCEPT_PAGE_FAULT
1879 SetLastError(STATUS_ACCESS_VIOLATION);
1880 ret = FALSE;
1882 __ENDTRY
1883 return ret;
1886 static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
1887 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1888 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1890 BOOL val = *(const BOOL *)pvStructInfo, ret;
1892 TRACE("%d\n", val);
1894 if (!pbEncoded)
1896 *pcbEncoded = 3;
1897 ret = TRUE;
1899 else if (*pcbEncoded < 3)
1901 *pcbEncoded = 3;
1902 SetLastError(ERROR_MORE_DATA);
1903 ret = FALSE;
1905 else
1907 *pcbEncoded = 3;
1908 *pbEncoded++ = ASN_BOOL;
1909 *pbEncoded++ = 1;
1910 *pbEncoded++ = val ? 0xff : 0;
1911 ret = TRUE;
1913 TRACE("returning %d (%08x)\n", ret, GetLastError());
1914 return ret;
1917 static BOOL WINAPI CRYPT_AsnEncodeAltNameEntry(DWORD dwCertEncodingType,
1918 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
1919 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
1921 const CERT_ALT_NAME_ENTRY *entry =
1922 (const CERT_ALT_NAME_ENTRY *)pvStructInfo;
1923 BOOL ret;
1924 DWORD dataLen;
1925 BYTE tag;
1927 ret = TRUE;
1928 switch (entry->dwAltNameChoice)
1930 case CERT_ALT_NAME_RFC822_NAME:
1931 case CERT_ALT_NAME_DNS_NAME:
1932 case CERT_ALT_NAME_URL:
1933 tag = ASN_CONTEXT | (entry->dwAltNameChoice - 1);
1934 if (entry->u.pwszURL)
1936 DWORD i;
1938 /* Not + 1: don't encode the NULL-terminator */
1939 dataLen = lstrlenW(entry->u.pwszURL);
1940 for (i = 0; ret && i < dataLen; i++)
1942 if (entry->u.pwszURL[i] > 0x7f)
1944 SetLastError(CRYPT_E_INVALID_IA5_STRING);
1945 ret = FALSE;
1946 *pcbEncoded = i;
1950 else
1951 dataLen = 0;
1952 break;
1953 case CERT_ALT_NAME_DIRECTORY_NAME:
1954 tag = ASN_CONTEXT | ASN_CONSTRUCTOR | (entry->dwAltNameChoice - 1);
1955 dataLen = entry->u.DirectoryName.cbData;
1956 break;
1957 case CERT_ALT_NAME_IP_ADDRESS:
1958 tag = ASN_CONTEXT | (entry->dwAltNameChoice - 1);
1959 dataLen = entry->u.IPAddress.cbData;
1960 break;
1961 case CERT_ALT_NAME_REGISTERED_ID:
1963 struct AsnEncodeTagSwappedItem swapped =
1964 { ASN_CONTEXT | (entry->dwAltNameChoice - 1), entry->u.pszRegisteredID,
1965 CRYPT_AsnEncodeOid };
1967 return CRYPT_AsnEncodeSwapTag(0, NULL, &swapped, 0, NULL, pbEncoded,
1968 pcbEncoded);
1970 case CERT_ALT_NAME_OTHER_NAME:
1971 FIXME("name type %d unimplemented\n", entry->dwAltNameChoice);
1972 return FALSE;
1973 default:
1974 SetLastError(E_INVALIDARG);
1975 return FALSE;
1977 if (ret)
1979 DWORD bytesNeeded, lenBytes;
1981 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
1982 bytesNeeded = 1 + dataLen + lenBytes;
1983 if (!pbEncoded)
1984 *pcbEncoded = bytesNeeded;
1985 else if (*pcbEncoded < bytesNeeded)
1987 SetLastError(ERROR_MORE_DATA);
1988 *pcbEncoded = bytesNeeded;
1989 ret = FALSE;
1991 else
1993 *pbEncoded++ = tag;
1994 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
1995 pbEncoded += lenBytes;
1996 switch (entry->dwAltNameChoice)
1998 case CERT_ALT_NAME_RFC822_NAME:
1999 case CERT_ALT_NAME_DNS_NAME:
2000 case CERT_ALT_NAME_URL:
2002 DWORD i;
2004 for (i = 0; i < dataLen; i++)
2005 *pbEncoded++ = (BYTE)entry->u.pwszURL[i];
2006 break;
2008 case CERT_ALT_NAME_DIRECTORY_NAME:
2009 memcpy(pbEncoded, entry->u.DirectoryName.pbData, dataLen);
2010 break;
2011 case CERT_ALT_NAME_IP_ADDRESS:
2012 memcpy(pbEncoded, entry->u.IPAddress.pbData, dataLen);
2013 break;
2015 if (ret)
2016 *pcbEncoded = bytesNeeded;
2019 TRACE("returning %d (%08x)\n", ret, GetLastError());
2020 return ret;
2023 static BOOL WINAPI CRYPT_AsnEncodeIntegerSwapBytes(DWORD dwCertEncodingType,
2024 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2025 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2027 BOOL ret;
2029 __TRY
2031 const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo;
2032 CRYPT_DATA_BLOB newBlob = { blob->cbData, NULL };
2034 ret = TRUE;
2035 if (newBlob.cbData)
2037 newBlob.pbData = CryptMemAlloc(newBlob.cbData);
2038 if (newBlob.pbData)
2040 DWORD i;
2042 for (i = 0; i < newBlob.cbData; i++)
2043 newBlob.pbData[newBlob.cbData - i - 1] = blob->pbData[i];
2045 else
2046 ret = FALSE;
2048 if (ret)
2049 ret = CRYPT_AsnEncodeInteger(dwCertEncodingType, lpszStructType,
2050 &newBlob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2051 CryptMemFree(newBlob.pbData);
2053 __EXCEPT_PAGE_FAULT
2055 SetLastError(STATUS_ACCESS_VIOLATION);
2056 ret = FALSE;
2058 __ENDTRY
2059 return ret;
2062 static BOOL WINAPI CRYPT_AsnEncodeAuthorityKeyId(DWORD dwCertEncodingType,
2063 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2064 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2066 BOOL ret;
2068 __TRY
2070 const CERT_AUTHORITY_KEY_ID_INFO *info =
2071 (const CERT_AUTHORITY_KEY_ID_INFO *)pvStructInfo;
2072 struct AsnEncodeSequenceItem items[3] = { { 0 } };
2073 struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
2074 struct AsnConstructedItem constructed = { 0 };
2075 DWORD cItem = 0, cSwapped = 0;
2077 if (info->KeyId.cbData)
2079 swapped[cSwapped].tag = ASN_CONTEXT | 0;
2080 swapped[cSwapped].pvStructInfo = &info->KeyId;
2081 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeIntegerSwapBytes;
2082 items[cItem].pvStructInfo = &swapped[cSwapped];
2083 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2084 cSwapped++;
2085 cItem++;
2087 if (info->CertIssuer.cbData)
2089 constructed.tag = 1;
2090 constructed.pvStructInfo = &info->CertIssuer;
2091 constructed.encodeFunc = CRYPT_CopyEncodedBlob;
2092 items[cItem].pvStructInfo = &constructed;
2093 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
2094 cItem++;
2096 if (info->CertSerialNumber.cbData)
2098 swapped[cSwapped].tag = ASN_CONTEXT | 2;
2099 swapped[cSwapped].pvStructInfo = &info->CertSerialNumber;
2100 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInteger;
2101 items[cItem].pvStructInfo = &swapped[cSwapped];
2102 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2103 cSwapped++;
2104 cItem++;
2106 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, dwFlags,
2107 pEncodePara, pbEncoded, pcbEncoded);
2109 __EXCEPT_PAGE_FAULT
2111 SetLastError(STATUS_ACCESS_VIOLATION);
2112 ret = FALSE;
2114 __ENDTRY
2115 return ret;
2118 static BOOL WINAPI CRYPT_AsnEncodeAltName(DWORD dwCertEncodingType,
2119 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2120 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2122 BOOL ret;
2124 __TRY
2126 const CERT_ALT_NAME_INFO *info =
2127 (const CERT_ALT_NAME_INFO *)pvStructInfo;
2128 DWORD bytesNeeded, dataLen, lenBytes, i;
2130 ret = TRUE;
2131 /* FIXME: should check that cAltEntry is not bigger than 0xff, since we
2132 * can't encode an erroneous entry index if it's bigger than this.
2134 for (i = 0, dataLen = 0; ret && i < info->cAltEntry; i++)
2136 DWORD len;
2138 ret = CRYPT_AsnEncodeAltNameEntry(dwCertEncodingType, NULL,
2139 &info->rgAltEntry[i], 0, NULL, NULL, &len);
2140 if (ret)
2141 dataLen += len;
2142 else if (GetLastError() == CRYPT_E_INVALID_IA5_STRING)
2144 /* CRYPT_AsnEncodeAltNameEntry encoded the index of
2145 * the bad character, now set the index of the bad
2146 * entry
2148 *pcbEncoded = (BYTE)i <<
2149 CERT_ALT_NAME_ENTRY_ERR_INDEX_SHIFT | len;
2152 if (ret)
2154 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
2155 bytesNeeded = 1 + lenBytes + dataLen;
2156 if (!pbEncoded)
2158 *pcbEncoded = bytesNeeded;
2159 ret = TRUE;
2161 else
2163 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2164 pbEncoded, pcbEncoded, bytesNeeded)))
2166 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2167 pbEncoded = *(BYTE **)pbEncoded;
2168 *pbEncoded++ = ASN_SEQUENCEOF;
2169 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
2170 pbEncoded += lenBytes;
2171 for (i = 0; ret && i < info->cAltEntry; i++)
2173 DWORD len = dataLen;
2175 ret = CRYPT_AsnEncodeAltNameEntry(dwCertEncodingType,
2176 NULL, &info->rgAltEntry[i], 0, NULL, pbEncoded, &len);
2177 if (ret)
2179 pbEncoded += len;
2180 dataLen -= len;
2187 __EXCEPT_PAGE_FAULT
2189 SetLastError(STATUS_ACCESS_VIOLATION);
2190 ret = FALSE;
2192 __ENDTRY
2193 return ret;
2196 static BOOL WINAPI CRYPT_AsnEncodeAuthorityKeyId2(DWORD dwCertEncodingType,
2197 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2198 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2200 BOOL ret;
2202 __TRY
2204 const CERT_AUTHORITY_KEY_ID2_INFO *info =
2205 (const CERT_AUTHORITY_KEY_ID2_INFO *)pvStructInfo;
2206 struct AsnEncodeSequenceItem items[3] = { { 0 } };
2207 struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
2208 DWORD cItem = 0, cSwapped = 0;
2210 if (info->KeyId.cbData)
2212 swapped[cSwapped].tag = ASN_CONTEXT | 0;
2213 swapped[cSwapped].pvStructInfo = &info->KeyId;
2214 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeIntegerSwapBytes;
2215 items[cItem].pvStructInfo = &swapped[cSwapped];
2216 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2217 cSwapped++;
2218 cItem++;
2220 if (info->AuthorityCertIssuer.cAltEntry)
2222 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1;
2223 swapped[cSwapped].pvStructInfo = &info->AuthorityCertIssuer;
2224 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
2225 items[cItem].pvStructInfo = &swapped[cSwapped];
2226 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2227 cSwapped++;
2228 cItem++;
2230 if (info->AuthorityCertSerialNumber.cbData)
2232 swapped[cSwapped].tag = ASN_CONTEXT | 2;
2233 swapped[cSwapped].pvStructInfo = &info->AuthorityCertSerialNumber;
2234 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInteger;
2235 items[cItem].pvStructInfo = &swapped[cSwapped];
2236 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2237 cSwapped++;
2238 cItem++;
2240 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, dwFlags,
2241 pEncodePara, pbEncoded, pcbEncoded);
2243 __EXCEPT_PAGE_FAULT
2245 SetLastError(STATUS_ACCESS_VIOLATION);
2246 ret = FALSE;
2248 __ENDTRY
2249 return ret;
2252 static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints(DWORD dwCertEncodingType,
2253 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2254 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2256 BOOL ret;
2258 __TRY
2260 const CERT_BASIC_CONSTRAINTS_INFO *info =
2261 (const CERT_BASIC_CONSTRAINTS_INFO *)pvStructInfo;
2262 struct AsnEncodeSequenceItem items[3] = {
2263 { &info->SubjectType, CRYPT_AsnEncodeBits, 0 },
2264 { 0 }
2266 DWORD cItem = 1;
2268 if (info->fPathLenConstraint)
2270 items[cItem].pvStructInfo = &info->dwPathLenConstraint;
2271 items[cItem].encodeFunc = CRYPT_AsnEncodeInt;
2272 cItem++;
2274 if (info->cSubtreesConstraint)
2276 items[cItem].pvStructInfo = &info->cSubtreesConstraint;
2277 items[cItem].encodeFunc = CRYPT_AsnEncodeSequenceOfAny;
2278 cItem++;
2280 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
2281 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2283 __EXCEPT_PAGE_FAULT
2285 SetLastError(STATUS_ACCESS_VIOLATION);
2286 ret = FALSE;
2288 __ENDTRY
2289 return ret;
2292 static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints2(DWORD dwCertEncodingType,
2293 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2294 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2296 BOOL ret;
2298 __TRY
2300 const CERT_BASIC_CONSTRAINTS2_INFO *info =
2301 (const CERT_BASIC_CONSTRAINTS2_INFO *)pvStructInfo;
2302 struct AsnEncodeSequenceItem items[2] = { { 0 } };
2303 DWORD cItem = 0;
2305 if (info->fCA)
2307 items[cItem].pvStructInfo = &info->fCA;
2308 items[cItem].encodeFunc = CRYPT_AsnEncodeBool;
2309 cItem++;
2311 if (info->fPathLenConstraint)
2313 items[cItem].pvStructInfo = &info->dwPathLenConstraint;
2314 items[cItem].encodeFunc = CRYPT_AsnEncodeInt;
2315 cItem++;
2317 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
2318 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2320 __EXCEPT_PAGE_FAULT
2322 SetLastError(STATUS_ACCESS_VIOLATION);
2323 ret = FALSE;
2325 __ENDTRY
2326 return ret;
2329 static BOOL WINAPI CRYPT_AsnEncodeRsaPubKey(DWORD dwCertEncodingType,
2330 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2331 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2333 BOOL ret;
2335 __TRY
2337 const BLOBHEADER *hdr =
2338 (const BLOBHEADER *)pvStructInfo;
2340 if (hdr->bType != PUBLICKEYBLOB)
2342 SetLastError(E_INVALIDARG);
2343 ret = FALSE;
2345 else
2347 const RSAPUBKEY *rsaPubKey = (const RSAPUBKEY *)
2348 ((const BYTE *)pvStructInfo + sizeof(BLOBHEADER));
2349 CRYPT_INTEGER_BLOB blob = { rsaPubKey->bitlen / 8,
2350 (BYTE *)pvStructInfo + sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) };
2351 struct AsnEncodeSequenceItem items[] = {
2352 { &blob, CRYPT_AsnEncodeUnsignedInteger, 0 },
2353 { &rsaPubKey->pubexp, CRYPT_AsnEncodeInt, 0 },
2356 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
2357 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
2358 pcbEncoded);
2361 __EXCEPT_PAGE_FAULT
2363 SetLastError(STATUS_ACCESS_VIOLATION);
2364 ret = FALSE;
2366 __ENDTRY
2367 return ret;
2370 BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
2371 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2372 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2374 BOOL ret;
2376 __TRY
2378 const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo;
2379 DWORD bytesNeeded, lenBytes;
2381 TRACE("(%d, %p), %08x, %p, %p, %d\n", blob->cbData, blob->pbData,
2382 dwFlags, pEncodePara, pbEncoded, *pcbEncoded);
2384 CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes);
2385 bytesNeeded = 1 + lenBytes + blob->cbData;
2386 if (!pbEncoded)
2388 *pcbEncoded = bytesNeeded;
2389 ret = TRUE;
2391 else
2393 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2394 pcbEncoded, bytesNeeded)))
2396 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2397 pbEncoded = *(BYTE **)pbEncoded;
2398 *pbEncoded++ = ASN_OCTETSTRING;
2399 CRYPT_EncodeLen(blob->cbData, pbEncoded, &lenBytes);
2400 pbEncoded += lenBytes;
2401 if (blob->cbData)
2402 memcpy(pbEncoded, blob->pbData, blob->cbData);
2406 __EXCEPT_PAGE_FAULT
2408 SetLastError(STATUS_ACCESS_VIOLATION);
2409 ret = FALSE;
2411 __ENDTRY
2412 TRACE("returning %d (%08x)\n", ret, GetLastError());
2413 return ret;
2416 static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType,
2417 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2418 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2420 BOOL ret;
2422 __TRY
2424 const CRYPT_BIT_BLOB *blob = (const CRYPT_BIT_BLOB *)pvStructInfo;
2425 DWORD bytesNeeded, lenBytes, dataBytes;
2426 BYTE unusedBits;
2428 /* yep, MS allows cUnusedBits to be >= 8 */
2429 if (!blob->cUnusedBits)
2431 dataBytes = blob->cbData;
2432 unusedBits = 0;
2434 else if (blob->cbData * 8 > blob->cUnusedBits)
2436 dataBytes = (blob->cbData * 8 - blob->cUnusedBits) / 8 + 1;
2437 unusedBits = blob->cUnusedBits >= 8 ? blob->cUnusedBits / 8 :
2438 blob->cUnusedBits;
2440 else
2442 dataBytes = 0;
2443 unusedBits = 0;
2445 CRYPT_EncodeLen(dataBytes + 1, NULL, &lenBytes);
2446 bytesNeeded = 1 + lenBytes + dataBytes + 1;
2447 if (!pbEncoded)
2449 *pcbEncoded = bytesNeeded;
2450 ret = TRUE;
2452 else
2454 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2455 pcbEncoded, bytesNeeded)))
2457 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2458 pbEncoded = *(BYTE **)pbEncoded;
2459 *pbEncoded++ = ASN_BITSTRING;
2460 CRYPT_EncodeLen(dataBytes + 1, pbEncoded, &lenBytes);
2461 pbEncoded += lenBytes;
2462 *pbEncoded++ = unusedBits;
2463 if (dataBytes)
2465 BYTE mask = 0xff << unusedBits;
2467 if (dataBytes > 1)
2469 memcpy(pbEncoded, blob->pbData, dataBytes - 1);
2470 pbEncoded += dataBytes - 1;
2472 *pbEncoded = *(blob->pbData + dataBytes - 1) & mask;
2477 __EXCEPT_PAGE_FAULT
2479 SetLastError(STATUS_ACCESS_VIOLATION);
2480 ret = FALSE;
2482 __ENDTRY
2483 return ret;
2486 static BOOL WINAPI CRYPT_AsnEncodeBitsSwapBytes(DWORD dwCertEncodingType,
2487 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2488 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2490 BOOL ret;
2492 __TRY
2494 const CRYPT_BIT_BLOB *blob = (const CRYPT_BIT_BLOB *)pvStructInfo;
2495 CRYPT_BIT_BLOB newBlob = { blob->cbData, NULL, blob->cUnusedBits };
2497 ret = TRUE;
2498 if (newBlob.cbData)
2500 newBlob.pbData = CryptMemAlloc(newBlob.cbData);
2501 if (newBlob.pbData)
2503 DWORD i;
2505 for (i = 0; i < newBlob.cbData; i++)
2506 newBlob.pbData[newBlob.cbData - i - 1] = blob->pbData[i];
2508 else
2509 ret = FALSE;
2511 if (ret)
2512 ret = CRYPT_AsnEncodeBits(dwCertEncodingType, lpszStructType,
2513 &newBlob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2514 CryptMemFree(newBlob.pbData);
2516 __EXCEPT_PAGE_FAULT
2518 SetLastError(STATUS_ACCESS_VIOLATION);
2519 ret = FALSE;
2521 __ENDTRY
2522 return ret;
2525 BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType,
2526 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2527 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2529 CRYPT_INTEGER_BLOB blob = { sizeof(INT), (BYTE *)pvStructInfo };
2531 return CRYPT_AsnEncodeInteger(dwCertEncodingType, X509_MULTI_BYTE_INTEGER,
2532 &blob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2535 static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType,
2536 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2537 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2539 BOOL ret;
2541 __TRY
2543 DWORD significantBytes, lenBytes;
2544 BYTE padByte = 0, bytesNeeded;
2545 BOOL pad = FALSE;
2546 const CRYPT_INTEGER_BLOB *blob =
2547 (const CRYPT_INTEGER_BLOB *)pvStructInfo;
2549 significantBytes = blob->cbData;
2550 if (significantBytes)
2552 if (blob->pbData[significantBytes - 1] & 0x80)
2554 /* negative, lop off leading (little-endian) 0xffs */
2555 for (; significantBytes > 0 &&
2556 blob->pbData[significantBytes - 1] == 0xff; significantBytes--)
2558 if (blob->pbData[significantBytes - 1] < 0x80)
2560 padByte = 0xff;
2561 pad = TRUE;
2564 else
2566 /* positive, lop off leading (little-endian) zeroes */
2567 for (; significantBytes > 0 &&
2568 !blob->pbData[significantBytes - 1]; significantBytes--)
2570 if (significantBytes == 0)
2571 significantBytes = 1;
2572 if (blob->pbData[significantBytes - 1] > 0x7f)
2574 padByte = 0;
2575 pad = TRUE;
2579 if (pad)
2580 CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes);
2581 else
2582 CRYPT_EncodeLen(significantBytes, NULL, &lenBytes);
2583 bytesNeeded = 1 + lenBytes + significantBytes;
2584 if (pad)
2585 bytesNeeded++;
2586 if (!pbEncoded)
2588 *pcbEncoded = bytesNeeded;
2589 ret = TRUE;
2591 else
2593 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2594 pcbEncoded, bytesNeeded)))
2596 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2597 pbEncoded = *(BYTE **)pbEncoded;
2598 *pbEncoded++ = ASN_INTEGER;
2599 if (pad)
2601 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
2602 pbEncoded += lenBytes;
2603 *pbEncoded++ = padByte;
2605 else
2607 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
2608 pbEncoded += lenBytes;
2610 for (; significantBytes > 0; significantBytes--)
2611 *(pbEncoded++) = blob->pbData[significantBytes - 1];
2615 __EXCEPT_PAGE_FAULT
2617 SetLastError(STATUS_ACCESS_VIOLATION);
2618 ret = FALSE;
2620 __ENDTRY
2621 return ret;
2624 static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType,
2625 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2626 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2628 BOOL ret;
2630 __TRY
2632 DWORD significantBytes, lenBytes;
2633 BYTE bytesNeeded;
2634 BOOL pad = FALSE;
2635 const CRYPT_INTEGER_BLOB *blob =
2636 (const CRYPT_INTEGER_BLOB *)pvStructInfo;
2638 significantBytes = blob->cbData;
2639 if (significantBytes)
2641 /* positive, lop off leading (little-endian) zeroes */
2642 for (; significantBytes > 0 && !blob->pbData[significantBytes - 1];
2643 significantBytes--)
2645 if (significantBytes == 0)
2646 significantBytes = 1;
2647 if (blob->pbData[significantBytes - 1] > 0x7f)
2648 pad = TRUE;
2650 if (pad)
2651 CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes);
2652 else
2653 CRYPT_EncodeLen(significantBytes, NULL, &lenBytes);
2654 bytesNeeded = 1 + lenBytes + significantBytes;
2655 if (pad)
2656 bytesNeeded++;
2657 if (!pbEncoded)
2659 *pcbEncoded = bytesNeeded;
2660 ret = TRUE;
2662 else
2664 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2665 pcbEncoded, bytesNeeded)))
2667 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2668 pbEncoded = *(BYTE **)pbEncoded;
2669 *pbEncoded++ = ASN_INTEGER;
2670 if (pad)
2672 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
2673 pbEncoded += lenBytes;
2674 *pbEncoded++ = 0;
2676 else
2678 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
2679 pbEncoded += lenBytes;
2681 for (; significantBytes > 0; significantBytes--)
2682 *(pbEncoded++) = blob->pbData[significantBytes - 1];
2686 __EXCEPT_PAGE_FAULT
2688 SetLastError(STATUS_ACCESS_VIOLATION);
2689 ret = FALSE;
2691 __ENDTRY
2692 return ret;
2695 static BOOL WINAPI CRYPT_AsnEncodeEnumerated(DWORD dwCertEncodingType,
2696 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2697 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2699 CRYPT_INTEGER_BLOB blob;
2700 BOOL ret;
2702 /* Encode as an unsigned integer, then change the tag to enumerated */
2703 blob.cbData = sizeof(DWORD);
2704 blob.pbData = (BYTE *)pvStructInfo;
2705 ret = CRYPT_AsnEncodeUnsignedInteger(dwCertEncodingType,
2706 X509_MULTI_BYTE_UINT, &blob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2707 if (ret && pbEncoded)
2709 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2710 pbEncoded = *(BYTE **)pbEncoded;
2711 pbEncoded[0] = ASN_ENUMERATED;
2713 return ret;
2716 static BOOL WINAPI CRYPT_AsnEncodeUtcTime(DWORD dwCertEncodingType,
2717 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2718 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2720 BOOL ret;
2722 __TRY
2724 SYSTEMTIME sysTime;
2725 /* sorry, magic number: enough for tag, len, YYMMDDHHMMSSZ\0. I use a
2726 * temporary buffer because the output buffer is not NULL-terminated.
2728 char buf[16];
2729 static const DWORD bytesNeeded = sizeof(buf) - 1;
2731 if (!pbEncoded)
2733 *pcbEncoded = bytesNeeded;
2734 ret = TRUE;
2736 else
2738 /* Sanity check the year, this is a two-digit year format */
2739 ret = FileTimeToSystemTime((const FILETIME *)pvStructInfo,
2740 &sysTime);
2741 if (ret && (sysTime.wYear < 1950 || sysTime.wYear > 2050))
2743 SetLastError(CRYPT_E_BAD_ENCODE);
2744 ret = FALSE;
2746 if (ret)
2748 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
2749 pbEncoded, pcbEncoded, bytesNeeded)))
2751 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2752 pbEncoded = *(BYTE **)pbEncoded;
2753 buf[0] = ASN_UTCTIME;
2754 buf[1] = bytesNeeded - 2;
2755 snprintf(buf + 2, sizeof(buf) - 2,
2756 "%02d%02d%02d%02d%02d%02dZ", sysTime.wYear >= 2000 ?
2757 sysTime.wYear - 2000 : sysTime.wYear - 1900,
2758 sysTime.wMonth, sysTime.wDay, sysTime.wHour,
2759 sysTime.wMinute, sysTime.wSecond);
2760 memcpy(pbEncoded, buf, bytesNeeded);
2765 __EXCEPT_PAGE_FAULT
2767 SetLastError(STATUS_ACCESS_VIOLATION);
2768 ret = FALSE;
2770 __ENDTRY
2771 return ret;
2774 static BOOL WINAPI CRYPT_AsnEncodeGeneralizedTime(DWORD dwCertEncodingType,
2775 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2776 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2778 BOOL ret;
2780 __TRY
2782 SYSTEMTIME sysTime;
2783 /* sorry, magic number: enough for tag, len, YYYYMMDDHHMMSSZ\0. I use a
2784 * temporary buffer because the output buffer is not NULL-terminated.
2786 char buf[18];
2787 static const DWORD bytesNeeded = sizeof(buf) - 1;
2789 if (!pbEncoded)
2791 *pcbEncoded = bytesNeeded;
2792 ret = TRUE;
2794 else
2796 ret = FileTimeToSystemTime((const FILETIME *)pvStructInfo,
2797 &sysTime);
2798 if (ret)
2799 ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2800 pcbEncoded, bytesNeeded);
2801 if (ret)
2803 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2804 pbEncoded = *(BYTE **)pbEncoded;
2805 buf[0] = ASN_GENERALTIME;
2806 buf[1] = bytesNeeded - 2;
2807 snprintf(buf + 2, sizeof(buf) - 2, "%04d%02d%02d%02d%02d%02dZ",
2808 sysTime.wYear, sysTime.wMonth, sysTime.wDay, sysTime.wHour,
2809 sysTime.wMinute, sysTime.wSecond);
2810 memcpy(pbEncoded, buf, bytesNeeded);
2814 __EXCEPT_PAGE_FAULT
2816 SetLastError(STATUS_ACCESS_VIOLATION);
2817 ret = FALSE;
2819 __ENDTRY
2820 return ret;
2823 static BOOL WINAPI CRYPT_AsnEncodeChoiceOfTime(DWORD dwCertEncodingType,
2824 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2825 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2827 BOOL ret;
2829 __TRY
2831 SYSTEMTIME sysTime;
2833 /* Check the year, if it's in the UTCTime range call that encode func */
2834 if (!FileTimeToSystemTime((const FILETIME *)pvStructInfo, &sysTime))
2835 return FALSE;
2836 if (sysTime.wYear >= 1950 && sysTime.wYear <= 2050)
2837 ret = CRYPT_AsnEncodeUtcTime(dwCertEncodingType, lpszStructType,
2838 pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2839 else
2840 ret = CRYPT_AsnEncodeGeneralizedTime(dwCertEncodingType,
2841 lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded,
2842 pcbEncoded);
2844 __EXCEPT_PAGE_FAULT
2846 SetLastError(STATUS_ACCESS_VIOLATION);
2847 ret = FALSE;
2849 __ENDTRY
2850 return ret;
2853 static BOOL WINAPI CRYPT_AsnEncodeSequenceOfAny(DWORD dwCertEncodingType,
2854 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2855 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2857 BOOL ret;
2859 __TRY
2861 DWORD bytesNeeded, dataLen, lenBytes, i;
2862 const CRYPT_SEQUENCE_OF_ANY *seq =
2863 (const CRYPT_SEQUENCE_OF_ANY *)pvStructInfo;
2865 for (i = 0, dataLen = 0; i < seq->cValue; i++)
2866 dataLen += seq->rgValue[i].cbData;
2867 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
2868 bytesNeeded = 1 + lenBytes + dataLen;
2869 if (!pbEncoded)
2871 *pcbEncoded = bytesNeeded;
2872 ret = TRUE;
2874 else
2876 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
2877 pcbEncoded, bytesNeeded)))
2879 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
2880 pbEncoded = *(BYTE **)pbEncoded;
2881 *pbEncoded++ = ASN_SEQUENCEOF;
2882 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
2883 pbEncoded += lenBytes;
2884 for (i = 0; i < seq->cValue; i++)
2886 memcpy(pbEncoded, seq->rgValue[i].pbData,
2887 seq->rgValue[i].cbData);
2888 pbEncoded += seq->rgValue[i].cbData;
2893 __EXCEPT_PAGE_FAULT
2895 SetLastError(STATUS_ACCESS_VIOLATION);
2896 ret = FALSE;
2898 __ENDTRY
2899 return ret;
2902 static BOOL CRYPT_AsnEncodeDistPoint(const CRL_DIST_POINT *distPoint,
2903 BYTE *pbEncoded, DWORD *pcbEncoded)
2905 BOOL ret = TRUE;
2906 struct AsnEncodeSequenceItem items[3] = { { 0 } };
2907 struct AsnConstructedItem constructed = { 0 };
2908 struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
2909 DWORD cItem = 0, cSwapped = 0;
2911 switch (distPoint->DistPointName.dwDistPointNameChoice)
2913 case CRL_DIST_POINT_NO_NAME:
2914 /* do nothing */
2915 break;
2916 case CRL_DIST_POINT_FULL_NAME:
2917 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
2918 swapped[cSwapped].pvStructInfo = &distPoint->DistPointName.u.FullName;
2919 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
2920 constructed.tag = 0;
2921 constructed.pvStructInfo = &swapped[cSwapped];
2922 constructed.encodeFunc = CRYPT_AsnEncodeSwapTag;
2923 items[cItem].pvStructInfo = &constructed;
2924 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
2925 cSwapped++;
2926 cItem++;
2927 break;
2928 case CRL_DIST_POINT_ISSUER_RDN_NAME:
2929 FIXME("unimplemented for CRL_DIST_POINT_ISSUER_RDN_NAME\n");
2930 ret = FALSE;
2931 break;
2932 default:
2933 ret = FALSE;
2935 if (ret && distPoint->ReasonFlags.cbData)
2937 swapped[cSwapped].tag = ASN_CONTEXT | 1;
2938 swapped[cSwapped].pvStructInfo = &distPoint->ReasonFlags;
2939 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBits;
2940 items[cItem].pvStructInfo = &swapped[cSwapped];
2941 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2942 cSwapped++;
2943 cItem++;
2945 if (ret && distPoint->CRLIssuer.cAltEntry)
2947 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 2;
2948 swapped[cSwapped].pvStructInfo = &distPoint->CRLIssuer;
2949 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
2950 items[cItem].pvStructInfo = &swapped[cSwapped];
2951 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
2952 cSwapped++;
2953 cItem++;
2955 if (ret)
2956 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
2957 pbEncoded, pcbEncoded);
2958 return ret;
2961 static BOOL WINAPI CRYPT_AsnEncodeCRLDistPoints(DWORD dwCertEncodingType,
2962 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
2963 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
2965 BOOL ret;
2967 __TRY
2969 const CRL_DIST_POINTS_INFO *info =
2970 (const CRL_DIST_POINTS_INFO *)pvStructInfo;
2972 if (!info->cDistPoint)
2974 SetLastError(E_INVALIDARG);
2975 ret = FALSE;
2977 else
2979 DWORD bytesNeeded, dataLen, lenBytes, i;
2981 ret = TRUE;
2982 for (i = 0, dataLen = 0; ret && i < info->cDistPoint; i++)
2984 DWORD len;
2986 ret = CRYPT_AsnEncodeDistPoint(&info->rgDistPoint[i], NULL,
2987 &len);
2988 if (ret)
2989 dataLen += len;
2990 else if (GetLastError() == CRYPT_E_INVALID_IA5_STRING)
2992 /* Have to propagate index of failing character */
2993 *pcbEncoded = len;
2996 if (ret)
2998 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
2999 bytesNeeded = 1 + lenBytes + dataLen;
3000 if (!pbEncoded)
3002 *pcbEncoded = bytesNeeded;
3003 ret = TRUE;
3005 else
3007 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
3008 pbEncoded, pcbEncoded, bytesNeeded)))
3010 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3011 pbEncoded = *(BYTE **)pbEncoded;
3012 *pbEncoded++ = ASN_SEQUENCEOF;
3013 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
3014 pbEncoded += lenBytes;
3015 for (i = 0; ret && i < info->cDistPoint; i++)
3017 DWORD len = dataLen;
3019 ret = CRYPT_AsnEncodeDistPoint(
3020 &info->rgDistPoint[i], pbEncoded, &len);
3021 if (ret)
3023 pbEncoded += len;
3024 dataLen -= len;
3032 __EXCEPT_PAGE_FAULT
3034 SetLastError(STATUS_ACCESS_VIOLATION);
3035 ret = FALSE;
3037 __ENDTRY
3038 return ret;
3041 static BOOL WINAPI CRYPT_AsnEncodeEnhancedKeyUsage(DWORD dwCertEncodingType,
3042 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3043 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3045 BOOL ret;
3047 __TRY
3049 const CERT_ENHKEY_USAGE *usage =
3050 (const CERT_ENHKEY_USAGE *)pvStructInfo;
3051 DWORD bytesNeeded = 0, lenBytes, size, i;
3053 ret = TRUE;
3054 for (i = 0; ret && i < usage->cUsageIdentifier; i++)
3056 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
3057 usage->rgpszUsageIdentifier[i],
3058 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &size);
3059 if (ret)
3060 bytesNeeded += size;
3062 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
3063 bytesNeeded += 1 + lenBytes;
3064 if (ret)
3066 if (!pbEncoded)
3067 *pcbEncoded = bytesNeeded;
3068 else
3070 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
3071 pbEncoded, pcbEncoded, bytesNeeded)))
3073 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3074 pbEncoded = *(BYTE **)pbEncoded;
3075 *pbEncoded++ = ASN_SEQUENCEOF;
3076 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
3077 &lenBytes);
3078 pbEncoded += lenBytes;
3079 for (i = 0; ret && i < usage->cUsageIdentifier; i++)
3081 size = bytesNeeded;
3082 ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL,
3083 usage->rgpszUsageIdentifier[i],
3084 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, pbEncoded,
3085 &size);
3086 if (ret)
3088 pbEncoded += size;
3089 bytesNeeded -= size;
3096 __EXCEPT_PAGE_FAULT
3098 SetLastError(STATUS_ACCESS_VIOLATION);
3099 ret = FALSE;
3101 __ENDTRY
3102 return ret;
3105 static BOOL WINAPI CRYPT_AsnEncodeIssuingDistPoint(DWORD dwCertEncodingType,
3106 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3107 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3109 BOOL ret;
3111 __TRY
3113 const CRL_ISSUING_DIST_POINT *point =
3114 (const CRL_ISSUING_DIST_POINT *)pvStructInfo;
3115 struct AsnEncodeSequenceItem items[6] = { { 0 } };
3116 struct AsnConstructedItem constructed = { 0 };
3117 struct AsnEncodeTagSwappedItem swapped[5] = { { 0 } };
3118 DWORD cItem = 0, cSwapped = 0;
3120 ret = TRUE;
3121 switch (point->DistPointName.dwDistPointNameChoice)
3123 case CRL_DIST_POINT_NO_NAME:
3124 /* do nothing */
3125 break;
3126 case CRL_DIST_POINT_FULL_NAME:
3127 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
3128 swapped[cSwapped].pvStructInfo = &point->DistPointName.u.FullName;
3129 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName;
3130 constructed.tag = 0;
3131 constructed.pvStructInfo = &swapped[cSwapped];
3132 constructed.encodeFunc = CRYPT_AsnEncodeSwapTag;
3133 items[cItem].pvStructInfo = &constructed;
3134 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
3135 cSwapped++;
3136 cItem++;
3137 break;
3138 default:
3139 SetLastError(E_INVALIDARG);
3140 ret = FALSE;
3142 if (ret && point->fOnlyContainsUserCerts)
3144 swapped[cSwapped].tag = ASN_CONTEXT | 1;
3145 swapped[cSwapped].pvStructInfo = &point->fOnlyContainsUserCerts;
3146 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool;
3147 items[cItem].pvStructInfo = &swapped[cSwapped];
3148 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3149 cSwapped++;
3150 cItem++;
3152 if (ret && point->fOnlyContainsCACerts)
3154 swapped[cSwapped].tag = ASN_CONTEXT | 2;
3155 swapped[cSwapped].pvStructInfo = &point->fOnlyContainsCACerts;
3156 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool;
3157 items[cItem].pvStructInfo = &swapped[cSwapped];
3158 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3159 cSwapped++;
3160 cItem++;
3162 if (ret && point->OnlySomeReasonFlags.cbData)
3164 swapped[cSwapped].tag = ASN_CONTEXT | 3;
3165 swapped[cSwapped].pvStructInfo = &point->OnlySomeReasonFlags;
3166 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBits;
3167 items[cItem].pvStructInfo = &swapped[cSwapped];
3168 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3169 cSwapped++;
3170 cItem++;
3172 if (ret && point->fIndirectCRL)
3174 swapped[cSwapped].tag = ASN_CONTEXT | 4;
3175 swapped[cSwapped].pvStructInfo = &point->fIndirectCRL;
3176 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool;
3177 items[cItem].pvStructInfo = &swapped[cSwapped];
3178 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3179 cSwapped++;
3180 cItem++;
3182 if (ret)
3183 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
3184 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3186 __EXCEPT_PAGE_FAULT
3188 SetLastError(STATUS_ACCESS_VIOLATION);
3189 ret = FALSE;
3191 __ENDTRY
3192 return ret;
3195 static BOOL WINAPI CRYPT_AsnEncodeGeneralSubtree(DWORD dwCertEncodingType,
3196 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3197 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3199 BOOL ret;
3200 const CERT_GENERAL_SUBTREE *subtree =
3201 (const CERT_GENERAL_SUBTREE *)pvStructInfo;
3202 struct AsnEncodeSequenceItem items[3] = {
3203 { &subtree->Base, CRYPT_AsnEncodeAltNameEntry, 0 },
3204 { 0 }
3206 struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
3207 DWORD cItem = 1, cSwapped = 0;
3209 if (subtree->dwMinimum)
3211 swapped[cSwapped].tag = ASN_CONTEXT | 0;
3212 swapped[cSwapped].pvStructInfo = &subtree->dwMinimum;
3213 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInt;
3214 items[cItem].pvStructInfo = &swapped[cSwapped];
3215 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3216 cSwapped++;
3217 cItem++;
3219 if (subtree->fMaximum)
3221 swapped[cSwapped].tag = ASN_CONTEXT | 1;
3222 swapped[cSwapped].pvStructInfo = &subtree->dwMaximum;
3223 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInt;
3224 items[cItem].pvStructInfo = &swapped[cSwapped];
3225 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3226 cSwapped++;
3227 cItem++;
3229 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags,
3230 pEncodePara, pbEncoded, pcbEncoded);
3231 return ret;
3234 static BOOL WINAPI CRYPT_AsnEncodeNameConstraints(DWORD dwCertEncodingType,
3235 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3236 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3238 BOOL ret = FALSE;
3239 CRYPT_BLOB_ARRAY permitted = { 0, NULL }, excluded = { 0, NULL };
3241 TRACE("%p\n", pvStructInfo);
3243 __TRY
3245 const CERT_NAME_CONSTRAINTS_INFO *constraints =
3246 (const CERT_NAME_CONSTRAINTS_INFO *)pvStructInfo;
3247 struct AsnEncodeSequenceItem items[2] = { { 0 } };
3248 struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
3249 DWORD i, cItem = 0, cSwapped = 0;
3251 ret = TRUE;
3252 if (constraints->cPermittedSubtree)
3254 permitted.rgBlob = CryptMemAlloc(
3255 constraints->cPermittedSubtree * sizeof(CRYPT_DER_BLOB));
3256 if (permitted.rgBlob)
3258 permitted.cBlob = constraints->cPermittedSubtree;
3259 memset(permitted.rgBlob, 0,
3260 permitted.cBlob * sizeof(CRYPT_DER_BLOB));
3261 for (i = 0; ret && i < permitted.cBlob; i++)
3262 ret = CRYPT_AsnEncodeGeneralSubtree(dwCertEncodingType,
3263 NULL, &constraints->rgPermittedSubtree[i],
3264 CRYPT_ENCODE_ALLOC_FLAG, NULL,
3265 (BYTE *)&permitted.rgBlob[i].pbData,
3266 &permitted.rgBlob[i].cbData);
3267 if (ret)
3269 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
3270 swapped[cSwapped].pvStructInfo = &permitted;
3271 swapped[cSwapped].encodeFunc = CRYPT_DEREncodeSet;
3272 items[cItem].pvStructInfo = &swapped[cSwapped];
3273 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3274 cSwapped++;
3275 cItem++;
3278 else
3279 ret = FALSE;
3281 if (constraints->cExcludedSubtree)
3283 excluded.rgBlob = CryptMemAlloc(
3284 constraints->cExcludedSubtree * sizeof(CRYPT_DER_BLOB));
3285 if (excluded.rgBlob)
3287 excluded.cBlob = constraints->cExcludedSubtree;
3288 memset(excluded.rgBlob, 0,
3289 excluded.cBlob * sizeof(CRYPT_DER_BLOB));
3290 for (i = 0; ret && i < excluded.cBlob; i++)
3291 ret = CRYPT_AsnEncodeGeneralSubtree(dwCertEncodingType,
3292 NULL, &constraints->rgExcludedSubtree[i],
3293 CRYPT_ENCODE_ALLOC_FLAG, NULL,
3294 (BYTE *)&excluded.rgBlob[i].pbData,
3295 &excluded.rgBlob[i].cbData);
3296 if (ret)
3298 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1;
3299 swapped[cSwapped].pvStructInfo = &excluded;
3300 swapped[cSwapped].encodeFunc = CRYPT_DEREncodeSet;
3301 items[cItem].pvStructInfo = &swapped[cSwapped];
3302 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3303 cSwapped++;
3304 cItem++;
3307 else
3308 ret = FALSE;
3310 if (ret)
3311 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
3312 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3313 for (i = 0; i < permitted.cBlob; i++)
3314 LocalFree(permitted.rgBlob[i].pbData);
3315 for (i = 0; i < excluded.cBlob; i++)
3316 LocalFree(excluded.rgBlob[i].pbData);
3318 __EXCEPT_PAGE_FAULT
3320 SetLastError(STATUS_ACCESS_VIOLATION);
3322 __ENDTRY
3323 CryptMemFree(permitted.rgBlob);
3324 CryptMemFree(excluded.rgBlob);
3325 TRACE("returning %d\n", ret);
3326 return ret;
3329 static BOOL WINAPI CRYPT_AsnEncodeIssuerSerialNumber(
3330 DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
3331 DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
3332 DWORD *pcbEncoded)
3334 BOOL ret;
3335 const CERT_ISSUER_SERIAL_NUMBER *issuerSerial =
3336 (const CERT_ISSUER_SERIAL_NUMBER *)pvStructInfo;
3337 struct AsnEncodeSequenceItem items[] = {
3338 { &issuerSerial->Issuer, CRYPT_CopyEncodedBlob, 0 },
3339 { &issuerSerial->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
3342 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
3343 sizeof(items) / sizeof(items[0]), dwFlags, pEncodePara, pbEncoded,
3344 pcbEncoded);
3345 return ret;
3348 static BOOL WINAPI CRYPT_AsnEncodePKCSSignerInfo(DWORD dwCertEncodingType,
3349 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
3350 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
3352 BOOL ret = FALSE;
3354 if (!(dwCertEncodingType & PKCS_7_ASN_ENCODING))
3356 SetLastError(E_INVALIDARG);
3357 return FALSE;
3360 __TRY
3362 const CMSG_SIGNER_INFO *info = (const CMSG_SIGNER_INFO *)pvStructInfo;
3364 if (!info->Issuer.cbData)
3365 SetLastError(E_INVALIDARG);
3366 else
3368 struct AsnEncodeSequenceItem items[7] = {
3369 { &info->dwVersion, CRYPT_AsnEncodeInt, 0 },
3370 { &info->Issuer, CRYPT_AsnEncodeIssuerSerialNumber, 0 },
3371 { &info->HashAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams,
3372 0 },
3374 struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
3375 DWORD cItem = 3, cSwapped = 0;
3377 if (info->AuthAttrs.cAttr)
3379 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0;
3380 swapped[cSwapped].pvStructInfo = &info->AuthAttrs;
3381 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes;
3382 items[cItem].pvStructInfo = &swapped[cSwapped];
3383 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3384 cSwapped++;
3385 cItem++;
3387 items[cItem].pvStructInfo = &info->HashEncryptionAlgorithm;
3388 items[cItem].encodeFunc = CRYPT_AsnEncodeAlgorithmIdWithNullParams;
3389 cItem++;
3390 items[cItem].pvStructInfo = &info->EncryptedHash;
3391 items[cItem].encodeFunc = CRYPT_AsnEncodeOctets;
3392 cItem++;
3393 if (info->UnauthAttrs.cAttr)
3395 swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1;
3396 swapped[cSwapped].pvStructInfo = &info->UnauthAttrs;
3397 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes;
3398 items[cItem].pvStructInfo = &swapped[cSwapped];
3399 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3400 cSwapped++;
3401 cItem++;
3403 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
3404 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3407 __EXCEPT_PAGE_FAULT
3409 SetLastError(STATUS_ACCESS_VIOLATION);
3411 __ENDTRY
3412 return ret;
3415 BOOL CRYPT_AsnEncodePKCSSignedInfo(CRYPT_SIGNED_INFO *signedInfo, void *pvData,
3416 DWORD *pcbData)
3418 struct AsnEncodeSequenceItem items[7] = {
3419 { &signedInfo->version, CRYPT_AsnEncodeInt, 0 },
3421 struct DERSetDescriptor digestAlgorithmsSet = { 0 }, certSet = { 0 };
3422 struct DERSetDescriptor crlSet = { 0 }, signerSet = { 0 };
3423 struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
3424 DWORD cItem = 1, cSwapped = 0;
3425 BOOL ret = TRUE;
3427 if (signedInfo->cSignerInfo)
3429 digestAlgorithmsSet.cItems = signedInfo->cSignerInfo;
3430 digestAlgorithmsSet.items = signedInfo->rgSignerInfo;
3431 digestAlgorithmsSet.itemSize = sizeof(CMSG_SIGNER_INFO);
3432 digestAlgorithmsSet.itemOffset =
3433 offsetof(CMSG_SIGNER_INFO, HashAlgorithm);
3434 digestAlgorithmsSet.encode = CRYPT_AsnEncodeAlgorithmIdWithNullParams;
3435 items[cItem].pvStructInfo = &digestAlgorithmsSet;
3436 items[cItem].encodeFunc = CRYPT_DEREncodeItemsAsSet;
3437 cItem++;
3439 items[cItem].pvStructInfo = &signedInfo->content;
3440 items[cItem].encodeFunc = CRYPT_AsnEncodePKCSContentInfoInternal;
3441 cItem++;
3442 if (signedInfo->cCertEncoded)
3444 certSet.cItems = signedInfo->cCertEncoded;
3445 certSet.items = signedInfo->rgCertEncoded;
3446 certSet.itemSize = sizeof(CERT_BLOB);
3447 certSet.itemOffset = 0;
3448 certSet.encode = CRYPT_CopyEncodedBlob;
3449 swapped[cSwapped].tag = ASN_CONSTRUCTOR | ASN_CONTEXT | 0;
3450 swapped[cSwapped].pvStructInfo = &certSet;
3451 swapped[cSwapped].encodeFunc = CRYPT_DEREncodeItemsAsSet;
3452 items[cItem].pvStructInfo = &swapped[cSwapped];
3453 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3454 cSwapped++;
3455 cItem++;
3457 if (signedInfo->cCrlEncoded)
3459 crlSet.cItems = signedInfo->cCrlEncoded;
3460 crlSet.items = signedInfo->rgCrlEncoded;
3461 crlSet.itemSize = sizeof(CRL_BLOB);
3462 crlSet.itemOffset = 0;
3463 crlSet.encode = CRYPT_CopyEncodedBlob;
3464 swapped[cSwapped].tag = ASN_CONSTRUCTOR | ASN_CONTEXT | 1;
3465 swapped[cSwapped].pvStructInfo = &crlSet;
3466 swapped[cSwapped].encodeFunc = CRYPT_DEREncodeItemsAsSet;
3467 items[cItem].pvStructInfo = &swapped[cSwapped];
3468 items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
3469 cSwapped++;
3470 cItem++;
3472 if (ret && signedInfo->cSignerInfo)
3474 signerSet.cItems = signedInfo->cSignerInfo;
3475 signerSet.items = signedInfo->rgSignerInfo;
3476 signerSet.itemSize = sizeof(CMSG_SIGNER_INFO);
3477 signerSet.itemOffset = 0;
3478 signerSet.encode = CRYPT_AsnEncodePKCSSignerInfo;
3479 items[cItem].pvStructInfo = &signerSet;
3480 items[cItem].encodeFunc = CRYPT_DEREncodeItemsAsSet;
3481 cItem++;
3483 if (ret)
3484 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
3485 items, cItem, 0, NULL, pvData, pcbData);
3487 return ret;
3490 static CryptEncodeObjectExFunc CRYPT_GetBuiltinEncoder(DWORD dwCertEncodingType,
3491 LPCSTR lpszStructType)
3493 CryptEncodeObjectExFunc encodeFunc = NULL;
3495 if ((dwCertEncodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING
3496 && (dwCertEncodingType & CMSG_ENCODING_TYPE_MASK) != PKCS_7_ASN_ENCODING)
3498 SetLastError(ERROR_FILE_NOT_FOUND);
3499 return NULL;
3502 if (!HIWORD(lpszStructType))
3504 switch (LOWORD(lpszStructType))
3506 case LOWORD(X509_CERT):
3507 encodeFunc = CRYPT_AsnEncodeCert;
3508 break;
3509 case LOWORD(X509_CERT_TO_BE_SIGNED):
3510 encodeFunc = CRYPT_AsnEncodeCertInfo;
3511 break;
3512 case LOWORD(X509_CERT_CRL_TO_BE_SIGNED):
3513 encodeFunc = CRYPT_AsnEncodeCRLInfo;
3514 break;
3515 case LOWORD(X509_EXTENSIONS):
3516 encodeFunc = CRYPT_AsnEncodeExtensions;
3517 break;
3518 case LOWORD(X509_NAME_VALUE):
3519 encodeFunc = CRYPT_AsnEncodeNameValue;
3520 break;
3521 case LOWORD(X509_NAME):
3522 encodeFunc = CRYPT_AsnEncodeName;
3523 break;
3524 case LOWORD(X509_PUBLIC_KEY_INFO):
3525 encodeFunc = CRYPT_AsnEncodePubKeyInfo;
3526 break;
3527 case LOWORD(X509_AUTHORITY_KEY_ID):
3528 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId;
3529 break;
3530 case LOWORD(X509_ALTERNATE_NAME):
3531 encodeFunc = CRYPT_AsnEncodeAltName;
3532 break;
3533 case LOWORD(X509_BASIC_CONSTRAINTS):
3534 encodeFunc = CRYPT_AsnEncodeBasicConstraints;
3535 break;
3536 case LOWORD(X509_BASIC_CONSTRAINTS2):
3537 encodeFunc = CRYPT_AsnEncodeBasicConstraints2;
3538 break;
3539 case LOWORD(RSA_CSP_PUBLICKEYBLOB):
3540 encodeFunc = CRYPT_AsnEncodeRsaPubKey;
3541 break;
3542 case LOWORD(X509_UNICODE_NAME):
3543 encodeFunc = CRYPT_AsnEncodeUnicodeName;
3544 break;
3545 case LOWORD(PKCS_CONTENT_INFO):
3546 encodeFunc = CRYPT_AsnEncodePKCSContentInfo;
3547 break;
3548 case LOWORD(PKCS_ATTRIBUTE):
3549 encodeFunc = CRYPT_AsnEncodePKCSAttribute;
3550 break;
3551 case LOWORD(X509_UNICODE_NAME_VALUE):
3552 encodeFunc = CRYPT_AsnEncodeUnicodeNameValue;
3553 break;
3554 case LOWORD(X509_OCTET_STRING):
3555 encodeFunc = CRYPT_AsnEncodeOctets;
3556 break;
3557 case LOWORD(X509_BITS):
3558 case LOWORD(X509_KEY_USAGE):
3559 encodeFunc = CRYPT_AsnEncodeBits;
3560 break;
3561 case LOWORD(X509_INTEGER):
3562 encodeFunc = CRYPT_AsnEncodeInt;
3563 break;
3564 case LOWORD(X509_MULTI_BYTE_INTEGER):
3565 encodeFunc = CRYPT_AsnEncodeInteger;
3566 break;
3567 case LOWORD(X509_MULTI_BYTE_UINT):
3568 encodeFunc = CRYPT_AsnEncodeUnsignedInteger;
3569 break;
3570 case LOWORD(X509_ENUMERATED):
3571 encodeFunc = CRYPT_AsnEncodeEnumerated;
3572 break;
3573 case LOWORD(X509_CHOICE_OF_TIME):
3574 encodeFunc = CRYPT_AsnEncodeChoiceOfTime;
3575 break;
3576 case LOWORD(X509_AUTHORITY_KEY_ID2):
3577 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId2;
3578 break;
3579 case LOWORD(X509_SEQUENCE_OF_ANY):
3580 encodeFunc = CRYPT_AsnEncodeSequenceOfAny;
3581 break;
3582 case LOWORD(PKCS_UTC_TIME):
3583 encodeFunc = CRYPT_AsnEncodeUtcTime;
3584 break;
3585 case LOWORD(X509_CRL_DIST_POINTS):
3586 encodeFunc = CRYPT_AsnEncodeCRLDistPoints;
3587 break;
3588 case LOWORD(X509_ENHANCED_KEY_USAGE):
3589 encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage;
3590 break;
3591 case LOWORD(PKCS_ATTRIBUTES):
3592 encodeFunc = CRYPT_AsnEncodePKCSAttributes;
3593 break;
3594 case LOWORD(X509_ISSUING_DIST_POINT):
3595 encodeFunc = CRYPT_AsnEncodeIssuingDistPoint;
3596 break;
3597 case LOWORD(X509_NAME_CONSTRAINTS):
3598 encodeFunc = CRYPT_AsnEncodeNameConstraints;
3599 break;
3600 case LOWORD(PKCS7_SIGNER_INFO):
3601 encodeFunc = CRYPT_AsnEncodePKCSSignerInfo;
3602 break;
3605 else if (!strcmp(lpszStructType, szOID_CERT_EXTENSIONS))
3606 encodeFunc = CRYPT_AsnEncodeExtensions;
3607 else if (!strcmp(lpszStructType, szOID_RSA_signingTime))
3608 encodeFunc = CRYPT_AsnEncodeUtcTime;
3609 else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER))
3610 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId;
3611 else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER2))
3612 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId2;
3613 else if (!strcmp(lpszStructType, szOID_CRL_REASON_CODE))
3614 encodeFunc = CRYPT_AsnEncodeEnumerated;
3615 else if (!strcmp(lpszStructType, szOID_KEY_USAGE))
3616 encodeFunc = CRYPT_AsnEncodeBits;
3617 else if (!strcmp(lpszStructType, szOID_SUBJECT_KEY_IDENTIFIER))
3618 encodeFunc = CRYPT_AsnEncodeOctets;
3619 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS))
3620 encodeFunc = CRYPT_AsnEncodeBasicConstraints;
3621 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS2))
3622 encodeFunc = CRYPT_AsnEncodeBasicConstraints2;
3623 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME))
3624 encodeFunc = CRYPT_AsnEncodeAltName;
3625 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME2))
3626 encodeFunc = CRYPT_AsnEncodeAltName;
3627 else if (!strcmp(lpszStructType, szOID_NEXT_UPDATE_LOCATION))
3628 encodeFunc = CRYPT_AsnEncodeAltName;
3629 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME))
3630 encodeFunc = CRYPT_AsnEncodeAltName;
3631 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME2))
3632 encodeFunc = CRYPT_AsnEncodeAltName;
3633 else if (!strcmp(lpszStructType, szOID_CRL_DIST_POINTS))
3634 encodeFunc = CRYPT_AsnEncodeCRLDistPoints;
3635 else if (!strcmp(lpszStructType, szOID_ENHANCED_KEY_USAGE))
3636 encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage;
3637 else if (!strcmp(lpszStructType, szOID_ISSUING_DIST_POINT))
3638 encodeFunc = CRYPT_AsnEncodeIssuingDistPoint;
3639 else if (!strcmp(lpszStructType, szOID_NAME_CONSTRAINTS))
3640 encodeFunc = CRYPT_AsnEncodeNameConstraints;
3641 return encodeFunc;
3644 static CryptEncodeObjectFunc CRYPT_LoadEncoderFunc(DWORD dwCertEncodingType,
3645 LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
3647 static HCRYPTOIDFUNCSET set = NULL;
3648 CryptEncodeObjectFunc encodeFunc = NULL;
3650 if (!set)
3651 set = CryptInitOIDFunctionSet(CRYPT_OID_ENCODE_OBJECT_FUNC, 0);
3652 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
3653 (void **)&encodeFunc, hFunc);
3654 return encodeFunc;
3657 static CryptEncodeObjectExFunc CRYPT_LoadEncoderExFunc(DWORD dwCertEncodingType,
3658 LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
3660 static HCRYPTOIDFUNCSET set = NULL;
3661 CryptEncodeObjectExFunc encodeFunc = NULL;
3663 if (!set)
3664 set = CryptInitOIDFunctionSet(CRYPT_OID_ENCODE_OBJECT_EX_FUNC, 0);
3665 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
3666 (void **)&encodeFunc, hFunc);
3667 return encodeFunc;
3670 BOOL WINAPI CryptEncodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType,
3671 const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
3673 BOOL ret = FALSE;
3674 HCRYPTOIDFUNCADDR hFunc = NULL;
3675 CryptEncodeObjectFunc pCryptEncodeObject = NULL;
3676 CryptEncodeObjectExFunc pCryptEncodeObjectEx = NULL;
3678 TRACE_(crypt)("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
3679 debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
3680 pcbEncoded);
3682 if (!pbEncoded && !pcbEncoded)
3684 SetLastError(ERROR_INVALID_PARAMETER);
3685 return FALSE;
3688 if (!(pCryptEncodeObjectEx = CRYPT_GetBuiltinEncoder(dwCertEncodingType,
3689 lpszStructType)))
3691 TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n",
3692 debugstr_a(lpszStructType));
3693 pCryptEncodeObject = CRYPT_LoadEncoderFunc(dwCertEncodingType,
3694 lpszStructType, &hFunc);
3695 if (!pCryptEncodeObject)
3696 pCryptEncodeObjectEx = CRYPT_LoadEncoderExFunc(dwCertEncodingType,
3697 lpszStructType, &hFunc);
3699 if (pCryptEncodeObject)
3700 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
3701 pvStructInfo, pbEncoded, pcbEncoded);
3702 else if (pCryptEncodeObjectEx)
3703 ret = pCryptEncodeObjectEx(dwCertEncodingType, lpszStructType,
3704 pvStructInfo, 0, NULL, pbEncoded, pcbEncoded);
3705 if (hFunc)
3706 CryptFreeOIDFunctionAddress(hFunc, 0);
3707 TRACE_(crypt)("returning %d\n", ret);
3708 return ret;
3711 BOOL WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType,
3712 const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara,
3713 void *pvEncoded, DWORD *pcbEncoded)
3715 BOOL ret = FALSE;
3716 HCRYPTOIDFUNCADDR hFunc = NULL;
3717 CryptEncodeObjectExFunc encodeFunc = NULL;
3719 TRACE_(crypt)("(0x%08x, %s, %p, 0x%08x, %p, %p, %p)\n", dwCertEncodingType,
3720 debugstr_a(lpszStructType), pvStructInfo, dwFlags, pEncodePara,
3721 pvEncoded, pcbEncoded);
3723 if (!pvEncoded && !pcbEncoded)
3725 SetLastError(ERROR_INVALID_PARAMETER);
3726 return FALSE;
3729 SetLastError(NOERROR);
3730 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG && pvEncoded)
3731 *(BYTE **)pvEncoded = NULL;
3732 encodeFunc = CRYPT_GetBuiltinEncoder(dwCertEncodingType, lpszStructType);
3733 if (!encodeFunc)
3735 TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n",
3736 debugstr_a(lpszStructType));
3737 encodeFunc = CRYPT_LoadEncoderExFunc(dwCertEncodingType, lpszStructType,
3738 &hFunc);
3740 if (encodeFunc)
3741 ret = encodeFunc(dwCertEncodingType, lpszStructType, pvStructInfo,
3742 dwFlags, pEncodePara, pvEncoded, pcbEncoded);
3743 else
3745 CryptEncodeObjectFunc pCryptEncodeObject =
3746 CRYPT_LoadEncoderFunc(dwCertEncodingType, lpszStructType, &hFunc);
3748 if (pCryptEncodeObject)
3750 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
3752 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
3753 pvStructInfo, NULL, pcbEncoded);
3754 if (ret && (ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
3755 pvEncoded, pcbEncoded, *pcbEncoded)))
3756 ret = pCryptEncodeObject(dwCertEncodingType,
3757 lpszStructType, pvStructInfo, *(BYTE **)pvEncoded,
3758 pcbEncoded);
3760 else
3761 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
3762 pvStructInfo, pvEncoded, pcbEncoded);
3765 if (hFunc)
3766 CryptFreeOIDFunctionAddress(hFunc, 0);
3767 TRACE_(crypt)("returning %d\n", ret);
3768 return ret;
3771 BOOL WINAPI CryptExportPublicKeyInfo(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec,
3772 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
3774 return CryptExportPublicKeyInfoEx(hCryptProv, dwKeySpec, dwCertEncodingType,
3775 NULL, 0, NULL, pInfo, pcbInfo);
3778 static BOOL WINAPI CRYPT_ExportRsaPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv,
3779 DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId,
3780 DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
3782 BOOL ret;
3783 HCRYPTKEY key;
3784 static CHAR oid[] = szOID_RSA_RSA;
3786 TRACE_(crypt)("(%08lx, %d, %08x, %s, %08x, %p, %p, %d)\n", hCryptProv,
3787 dwKeySpec, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags,
3788 pvAuxInfo, pInfo, pInfo ? *pcbInfo : 0);
3790 if (!pszPublicKeyObjId)
3791 pszPublicKeyObjId = oid;
3792 if ((ret = CryptGetUserKey(hCryptProv, dwKeySpec, &key)))
3794 DWORD keySize = 0;
3796 ret = CryptExportKey(key, 0, PUBLICKEYBLOB, 0, NULL, &keySize);
3797 if (ret)
3799 LPBYTE pubKey = CryptMemAlloc(keySize);
3801 if (pubKey)
3803 ret = CryptExportKey(key, 0, PUBLICKEYBLOB, 0, pubKey,
3804 &keySize);
3805 if (ret)
3807 DWORD encodedLen = 0;
3809 ret = CryptEncodeObject(dwCertEncodingType,
3810 RSA_CSP_PUBLICKEYBLOB, pubKey, NULL, &encodedLen);
3811 if (ret)
3813 DWORD sizeNeeded = sizeof(CERT_PUBLIC_KEY_INFO) +
3814 strlen(pszPublicKeyObjId) + 1 + encodedLen;
3816 if (!pInfo)
3817 *pcbInfo = sizeNeeded;
3818 else if (*pcbInfo < sizeNeeded)
3820 SetLastError(ERROR_MORE_DATA);
3821 *pcbInfo = sizeNeeded;
3822 ret = FALSE;
3824 else
3826 pInfo->Algorithm.pszObjId = (char *)pInfo +
3827 sizeof(CERT_PUBLIC_KEY_INFO);
3828 lstrcpyA(pInfo->Algorithm.pszObjId,
3829 pszPublicKeyObjId);
3830 pInfo->Algorithm.Parameters.cbData = 0;
3831 pInfo->Algorithm.Parameters.pbData = NULL;
3832 pInfo->PublicKey.pbData =
3833 (BYTE *)pInfo->Algorithm.pszObjId
3834 + lstrlenA(pInfo->Algorithm.pszObjId) + 1;
3835 pInfo->PublicKey.cbData = encodedLen;
3836 pInfo->PublicKey.cUnusedBits = 0;
3837 ret = CryptEncodeObject(dwCertEncodingType,
3838 RSA_CSP_PUBLICKEYBLOB, pubKey,
3839 pInfo->PublicKey.pbData, &pInfo->PublicKey.cbData);
3843 CryptMemFree(pubKey);
3845 else
3846 ret = FALSE;
3848 CryptDestroyKey(key);
3850 return ret;
3853 typedef BOOL (WINAPI *ExportPublicKeyInfoExFunc)(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv,
3854 DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId,
3855 DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo);
3857 BOOL WINAPI CryptExportPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec,
3858 DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags,
3859 void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
3861 static HCRYPTOIDFUNCSET set = NULL;
3862 BOOL ret;
3863 ExportPublicKeyInfoExFunc exportFunc = NULL;
3864 HCRYPTOIDFUNCADDR hFunc = NULL;
3866 TRACE_(crypt)("(%08lx, %d, %08x, %s, %08x, %p, %p, %d)\n", hCryptProv,
3867 dwKeySpec, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags,
3868 pvAuxInfo, pInfo, pInfo ? *pcbInfo : 0);
3870 if (!hCryptProv)
3872 SetLastError(ERROR_INVALID_PARAMETER);
3873 return FALSE;
3876 if (pszPublicKeyObjId)
3878 if (!set)
3879 set = CryptInitOIDFunctionSet(CRYPT_OID_EXPORT_PUBLIC_KEY_INFO_FUNC,
3881 CryptGetOIDFunctionAddress(set, dwCertEncodingType, pszPublicKeyObjId,
3882 0, (void **)&exportFunc, &hFunc);
3884 if (!exportFunc)
3885 exportFunc = CRYPT_ExportRsaPublicKeyInfoEx;
3886 ret = exportFunc(hCryptProv, dwKeySpec, dwCertEncodingType,
3887 pszPublicKeyObjId, dwFlags, pvAuxInfo, pInfo, pcbInfo);
3888 if (hFunc)
3889 CryptFreeOIDFunctionAddress(hFunc, 0);
3890 return ret;
3893 BOOL WINAPI CryptImportPublicKeyInfo(HCRYPTPROV hCryptProv,
3894 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, HCRYPTKEY *phKey)
3896 return CryptImportPublicKeyInfoEx(hCryptProv, dwCertEncodingType, pInfo,
3897 0, 0, NULL, phKey);
3900 static BOOL WINAPI CRYPT_ImportRsaPublicKeyInfoEx(HCRYPTPROV hCryptProv,
3901 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
3902 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey)
3904 BOOL ret;
3905 DWORD pubKeySize = 0;
3907 TRACE_(crypt)("(%08lx, %08x, %p, %08x, %08x, %p, %p)\n", hCryptProv,
3908 dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
3910 ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB,
3911 pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, NULL, &pubKeySize);
3912 if (ret)
3914 LPBYTE pubKey = CryptMemAlloc(pubKeySize);
3916 if (pubKey)
3918 ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB,
3919 pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, pubKey,
3920 &pubKeySize);
3921 if (ret)
3922 ret = CryptImportKey(hCryptProv, pubKey, pubKeySize, 0, 0,
3923 phKey);
3924 CryptMemFree(pubKey);
3926 else
3927 ret = FALSE;
3929 return ret;
3932 typedef BOOL (WINAPI *ImportPublicKeyInfoExFunc)(HCRYPTPROV hCryptProv,
3933 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
3934 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey);
3936 BOOL WINAPI CryptImportPublicKeyInfoEx(HCRYPTPROV hCryptProv,
3937 DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg,
3938 DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey)
3940 static HCRYPTOIDFUNCSET set = NULL;
3941 BOOL ret;
3942 ImportPublicKeyInfoExFunc importFunc = NULL;
3943 HCRYPTOIDFUNCADDR hFunc = NULL;
3945 TRACE_(crypt)("(%08lx, %08x, %p, %08x, %08x, %p, %p)\n", hCryptProv,
3946 dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
3948 if (!set)
3949 set = CryptInitOIDFunctionSet(CRYPT_OID_IMPORT_PUBLIC_KEY_INFO_FUNC, 0);
3950 CryptGetOIDFunctionAddress(set, dwCertEncodingType,
3951 pInfo->Algorithm.pszObjId, 0, (void **)&importFunc, &hFunc);
3952 if (!importFunc)
3953 importFunc = CRYPT_ImportRsaPublicKeyInfoEx;
3954 ret = importFunc(hCryptProv, dwCertEncodingType, pInfo, aiKeyAlg, dwFlags,
3955 pvAuxInfo, phKey);
3956 if (hFunc)
3957 CryptFreeOIDFunctionAddress(hFunc, 0);
3958 return ret;