?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus/tests: Comment out a test that corrupts the stack on Vista.
[wine/multimedia.git] / dlls / crypt32 / object.c
blobb3f82936172128535f7596d8cd141d1a84bd7bd6
1 /*
2 * crypt32 Crypt*Object functions
3 *
4 * Copyright 2007 Juan Lang
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20 #include <stdarg.h>
21 #define NONAMELESSUNION
22 #include "windef.h"
23 #include "winbase.h"
24 #include "wincrypt.h"
25 #include "mssip.h"
26 #include "winuser.h"
27 #include "wintrust.h"
28 #include "crypt32_private.h"
29 #include "cryptres.h"
30 #include "wine/unicode.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
34
35 static BOOL CRYPT_ReadBlobFromFile(LPCWSTR fileName, PCERT_BLOB blob)
36 {
37 BOOL ret = FALSE;
38 HANDLE file;
39
40 TRACE("%s\n", debugstr_w(fileName));
41
42 file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
43 OPEN_EXISTING, 0, NULL);
44 if (file != INVALID_HANDLE_VALUE)
45 {
46 ret = TRUE;
47 blob->cbData = GetFileSize(file, NULL);
48 if (blob->cbData)
49 {
50 blob->pbData = CryptMemAlloc(blob->cbData);
51 if (blob->pbData)
52 {
53 DWORD read;
54
55 ret = ReadFile(file, blob->pbData, blob->cbData, &read, NULL);
56 }
57 }
58 CloseHandle(file);
59 }
60 TRACE("returning %d\n", ret);
61 return ret;
62 }
63
64 static BOOL CRYPT_QueryContextBlob(const CERT_BLOB *blob,
65 DWORD dwExpectedContentTypeFlags, HCERTSTORE store,
66 DWORD *contentType, const void **ppvContext)
67 {
68 BOOL ret = FALSE;
69
70 if (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CERT)
71 {
72 ret = pCertInterface->addEncodedToStore(store, X509_ASN_ENCODING,
73 blob->pbData, blob->cbData, CERT_STORE_ADD_ALWAYS, ppvContext);
74 if (ret && contentType)
75 *contentType = CERT_QUERY_CONTENT_CERT;
76 }
77 if (!ret && (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CRL))
78 {
79 ret = pCRLInterface->addEncodedToStore(store, X509_ASN_ENCODING,
80 blob->pbData, blob->cbData, CERT_STORE_ADD_ALWAYS, ppvContext);
81 if (ret && contentType)
82 *contentType = CERT_QUERY_CONTENT_CRL;
83 }
84 if (!ret && (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CTL))
85 {
86 ret = pCTLInterface->addEncodedToStore(store, X509_ASN_ENCODING,
87 blob->pbData, blob->cbData, CERT_STORE_ADD_ALWAYS, ppvContext);
88 if (ret && contentType)
89 *contentType = CERT_QUERY_CONTENT_CTL;
90 }
91 return ret;
92 }
93
94 static BOOL CRYPT_QueryContextObject(DWORD dwObjectType, const void *pvObject,
95 DWORD dwExpectedContentTypeFlags, DWORD dwExpectedFormatTypeFlags,
96 DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, DWORD *pdwFormatType,
97 HCERTSTORE *phCertStore, const void **ppvContext)
98 {
99 CERT_BLOB fileBlob;
100 const CERT_BLOB *blob;
101 HCERTSTORE store;
102 BOOL ret;
103 DWORD formatType = 0;
104
105 switch (dwObjectType)
106 {
107 case CERT_QUERY_OBJECT_FILE:
108 /* Cert, CRL, and CTL contexts can't be "embedded" in a file, so
109 * just read the file directly
110 */
111 ret = CRYPT_ReadBlobFromFile(pvObject, &fileBlob);
112 blob = &fileBlob;
113 break;
114 case CERT_QUERY_OBJECT_BLOB:
115 blob = pvObject;
116 ret = TRUE;
117 break;
118 default:
119 SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */
120 ret = FALSE;
121 }
122 if (!ret)
123 return FALSE;
124
125 ret = FALSE;
126 store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
127 CERT_STORE_CREATE_NEW_FLAG, NULL);
128 if (dwExpectedFormatTypeFlags & CERT_QUERY_FORMAT_FLAG_BINARY)
129 {
130 ret = CRYPT_QueryContextBlob(blob, dwExpectedContentTypeFlags, store,
131 pdwContentType, ppvContext);
132 if (ret)
133 formatType = CERT_QUERY_FORMAT_BINARY;
134 }
135 if (!ret &&
136 (dwExpectedFormatTypeFlags & CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED))
137 {
138 CRYPT_DATA_BLOB trimmed = { blob->cbData, blob->pbData };
139 CRYPT_DATA_BLOB decoded;
140
141 while (trimmed.cbData && !trimmed.pbData[trimmed.cbData - 1])
142 trimmed.cbData--;
143 ret = CryptStringToBinaryA((LPSTR)trimmed.pbData, trimmed.cbData,
144 CRYPT_STRING_BASE64_ANY, NULL, &decoded.cbData, NULL, NULL);
145 if (ret)
146 {
147 decoded.pbData = CryptMemAlloc(decoded.cbData);
148 if (decoded.pbData)
149 {
150 ret = CryptStringToBinaryA((LPSTR)trimmed.pbData,
151 trimmed.cbData, CRYPT_STRING_BASE64_ANY, decoded.pbData,
152 &decoded.cbData, NULL, NULL);
153 if (ret)
154 {
155 ret = CRYPT_QueryContextBlob(&decoded,
156 dwExpectedContentTypeFlags, store, pdwContentType,
157 ppvContext);
158 if (ret)
159 formatType = CERT_QUERY_FORMAT_BASE64_ENCODED;
160 }
161 CryptMemFree(decoded.pbData);
162 }
163 else
164 ret = FALSE;
165 }
166 }
167 if (ret)
168 {
169 if (pdwMsgAndCertEncodingType)
170 *pdwMsgAndCertEncodingType = X509_ASN_ENCODING;
171 if (pdwFormatType)
172 *pdwFormatType = formatType;
173 if (phCertStore)
174 *phCertStore = CertDuplicateStore(store);
175 }
176 CertCloseStore(store, 0);
177 if (blob == &fileBlob)
178 CryptMemFree(blob->pbData);
179 TRACE("returning %d\n", ret);
180 return ret;
181 }
182
183 static BOOL CRYPT_QuerySerializedContextObject(DWORD dwObjectType,
184 const void *pvObject, DWORD dwExpectedContentTypeFlags,
185 DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType,
186 HCERTSTORE *phCertStore, const void **ppvContext)
187 {
188 CERT_BLOB fileBlob;
189 const CERT_BLOB *blob;
190 const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
191 const void *context;
192 DWORD contextType;
193 BOOL ret;
194
195 switch (dwObjectType)
196 {
197 case CERT_QUERY_OBJECT_FILE:
198 /* Cert, CRL, and CTL contexts can't be "embedded" in a file, so
199 * just read the file directly
200 */
201 ret = CRYPT_ReadBlobFromFile(pvObject, &fileBlob);
202 blob = &fileBlob;
203 break;
204 case CERT_QUERY_OBJECT_BLOB:
205 blob = pvObject;
206 ret = TRUE;
207 break;
208 default:
209 SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */
210 ret = FALSE;
211 }
212 if (!ret)
213 return FALSE;
214
215 ret = FALSE;
216 context = CRYPT_ReadSerializedElement(blob->pbData, blob->cbData,
217 CERT_STORE_ALL_CONTEXT_FLAG, &contextType);
218 if (context)
219 {
220 DWORD contentType, certStoreOffset;
221
222 ret = TRUE;
223 switch (contextType)
224 {
225 case CERT_STORE_CERTIFICATE_CONTEXT:
226 contextInterface = pCertInterface;
227 contentType = CERT_QUERY_CONTENT_SERIALIZED_CERT;
228 certStoreOffset = offsetof(CERT_CONTEXT, hCertStore);
229 if (!(dwExpectedContentTypeFlags &
230 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT))
231 {
232 SetLastError(ERROR_INVALID_DATA);
233 ret = FALSE;
234 goto end;
235 }
236 break;
237 case CERT_STORE_CRL_CONTEXT:
238 contextInterface = pCRLInterface;
239 contentType = CERT_QUERY_CONTENT_SERIALIZED_CRL;
240 certStoreOffset = offsetof(CRL_CONTEXT, hCertStore);
241 if (!(dwExpectedContentTypeFlags &
242 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL))
243 {
244 SetLastError(ERROR_INVALID_DATA);
245 ret = FALSE;
246 goto end;
247 }
248 break;
249 case CERT_STORE_CTL_CONTEXT:
250 contextInterface = pCTLInterface;
251 contentType = CERT_QUERY_CONTENT_SERIALIZED_CTL;
252 certStoreOffset = offsetof(CTL_CONTEXT, hCertStore);
253 if (!(dwExpectedContentTypeFlags &
254 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL))
255 {
256 SetLastError(ERROR_INVALID_DATA);
257 ret = FALSE;
258 goto end;
259 }
260 break;
261 default:
262 SetLastError(ERROR_INVALID_DATA);
263 ret = FALSE;
264 goto end;
265 }
266 if (pdwMsgAndCertEncodingType)
267 *pdwMsgAndCertEncodingType = X509_ASN_ENCODING;
268 if (pdwContentType)
269 *pdwContentType = contentType;
270 if (phCertStore)
271 *phCertStore = CertDuplicateStore(
272 *(HCERTSTORE *)((const BYTE *)context + certStoreOffset));
273 if (ppvContext)
274 *ppvContext = contextInterface->duplicate(context);
275 }
276
277 end:
278 if (contextInterface && context)
279 contextInterface->free(context);
280 if (blob == &fileBlob)
281 CryptMemFree(blob->pbData);
282 TRACE("returning %d\n", ret);
283 return ret;
284 }
285
286 static BOOL CRYPT_QuerySerializedStoreFromFile(LPCWSTR fileName,
287 DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType,
288 HCERTSTORE *phCertStore, HCRYPTMSG *phMsg)
289 {
290 HANDLE file;
291 BOOL ret = FALSE;
292
293 TRACE("%s\n", debugstr_w(fileName));
294 file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
295 OPEN_EXISTING, 0, NULL);
296 if (file != INVALID_HANDLE_VALUE)
297 {
298 HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
299 CERT_STORE_CREATE_NEW_FLAG, NULL);
300
301 ret = CRYPT_ReadSerializedStoreFromFile(file, store);
302 if (ret)
303 {
304 if (pdwMsgAndCertEncodingType)
305 *pdwMsgAndCertEncodingType = X509_ASN_ENCODING;
306 if (pdwContentType)
307 *pdwContentType = CERT_QUERY_CONTENT_SERIALIZED_STORE;
308 if (phCertStore)
309 *phCertStore = CertDuplicateStore(store);
310 }
311 CertCloseStore(store, 0);
312 CloseHandle(file);
313 }
314 TRACE("returning %d\n", ret);
315 return ret;
316 }
317
318 static BOOL CRYPT_QuerySerializedStoreFromBlob(const CRYPT_DATA_BLOB *blob,
319 DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType,
320 HCERTSTORE *phCertStore, HCRYPTMSG *phMsg)
321 {
322 HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
323 CERT_STORE_CREATE_NEW_FLAG, NULL);
324 BOOL ret;
325
326 TRACE("(%d, %p)\n", blob->cbData, blob->pbData);
327
328 ret = CRYPT_ReadSerializedStoreFromBlob(blob, store);
329 if (ret)
330 {
331 if (pdwMsgAndCertEncodingType)
332 *pdwMsgAndCertEncodingType = X509_ASN_ENCODING;
333 if (pdwContentType)
334 *pdwContentType = CERT_QUERY_CONTENT_SERIALIZED_STORE;
335 if (phCertStore)
336 *phCertStore = CertDuplicateStore(store);
337 }
338 CertCloseStore(store, 0);
339 TRACE("returning %d\n", ret);
340 return ret;
341 }
342
343 static BOOL CRYPT_QuerySerializedStoreObject(DWORD dwObjectType,
344 const void *pvObject, DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType,
345 HCERTSTORE *phCertStore, HCRYPTMSG *phMsg)
346 {
347 switch (dwObjectType)
348 {
349 case CERT_QUERY_OBJECT_FILE:
350 return CRYPT_QuerySerializedStoreFromFile(pvObject,
351 pdwMsgAndCertEncodingType, pdwContentType, phCertStore, phMsg);
352 case CERT_QUERY_OBJECT_BLOB:
353 return CRYPT_QuerySerializedStoreFromBlob(pvObject,
354 pdwMsgAndCertEncodingType, pdwContentType, phCertStore, phMsg);
355 default:
356 FIXME("unimplemented for type %d\n", dwObjectType);
357 SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */
358 return FALSE;
359 }
360 }
361
362 static BOOL CRYPT_QuerySignedMessage(const CRYPT_DATA_BLOB *blob,
363 DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, HCRYPTMSG *phMsg)
364 {
365 DWORD encodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
366 BOOL ret = FALSE;
367 HCRYPTMSG msg;
368
369 if ((msg = CryptMsgOpenToDecode(encodingType, 0, 0, 0, NULL, NULL)))
370 {
371 ret = CryptMsgUpdate(msg, blob->pbData, blob->cbData, TRUE);
372 if (ret)
373 {
374 DWORD type, len = sizeof(type);
375
376 ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &type, &len);
377 if (ret)
378 {
379 if (type != CMSG_SIGNED)
380 {
381 SetLastError(ERROR_INVALID_DATA);
382 ret = FALSE;
383 }
384 }
385 }
386 if (!ret)
387 {
388 CryptMsgClose(msg);
389 msg = CryptMsgOpenToDecode(encodingType, 0, CMSG_SIGNED, 0, NULL,
390 NULL);
391 if (msg)
392 {
393 ret = CryptMsgUpdate(msg, blob->pbData, blob->cbData, TRUE);
394 if (!ret)
395 {
396 CryptMsgClose(msg);
397 msg = NULL;
398 }
399 }
400 }
401 }
402 if (ret)
403 {
404 if (pdwMsgAndCertEncodingType)
405 *pdwMsgAndCertEncodingType = encodingType;
406 if (pdwContentType)
407 *pdwContentType = CERT_QUERY_CONTENT_PKCS7_SIGNED;
408 if (phMsg)
409 *phMsg = msg;
410 }
411 return ret;
412 }
413
414 static BOOL CRYPT_QueryUnsignedMessage(const CRYPT_DATA_BLOB *blob,
415 DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, HCRYPTMSG *phMsg)
416 {
417 DWORD encodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
418 BOOL ret = FALSE;
419 HCRYPTMSG msg;
420
421 if ((msg = CryptMsgOpenToDecode(encodingType, 0, 0, 0, NULL, NULL)))
422 {
423 ret = CryptMsgUpdate(msg, blob->pbData, blob->cbData, TRUE);
424 if (ret)
425 {
426 DWORD type, len = sizeof(type);
427
428 ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &type, &len);
429 if (ret)
430 {
431 if (type != CMSG_DATA)
432 {
433 SetLastError(ERROR_INVALID_DATA);
434 ret = FALSE;
435 }
436 }
437 }
438 if (!ret)
439 {
440 CryptMsgClose(msg);
441 msg = CryptMsgOpenToDecode(encodingType, 0, CMSG_DATA, 0,
442 NULL, NULL);
443 if (msg)
444 {
445 ret = CryptMsgUpdate(msg, blob->pbData, blob->cbData, TRUE);
446 if (!ret)
447 {
448 CryptMsgClose(msg);
449 msg = NULL;
450 }
451 }
452 }
453 }
454 if (ret)
455 {
456 if (pdwMsgAndCertEncodingType)
457 *pdwMsgAndCertEncodingType = encodingType;
458 if (pdwContentType)
459 *pdwContentType = CERT_QUERY_CONTENT_PKCS7_SIGNED;
460 if (phMsg)
461 *phMsg = msg;
462 }
463 return ret;
464 }
465
466 /* Used to decode non-embedded messages */
467 static BOOL CRYPT_QueryMessageObject(DWORD dwObjectType, const void *pvObject,
468 DWORD dwExpectedContentTypeFlags, DWORD dwExpectedFormatTypeFlags,
469 DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, DWORD *pdwFormatType,
470 HCERTSTORE *phCertStore, HCRYPTMSG *phMsg)
471 {
472 CERT_BLOB fileBlob;
473 const CERT_BLOB *blob;
474 BOOL ret;
475 HCRYPTMSG msg = NULL;
476 DWORD encodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
477 DWORD formatType = 0;
478
479 TRACE("(%d, %p, %08x, %08x, %p, %p, %p, %p, %p)\n", dwObjectType, pvObject,
480 dwExpectedContentTypeFlags, dwExpectedFormatTypeFlags,
481 pdwMsgAndCertEncodingType, pdwContentType, pdwFormatType, phCertStore,
482 phMsg);
483
484 switch (dwObjectType)
485 {
486 case CERT_QUERY_OBJECT_FILE:
487 /* This isn't an embedded PKCS7 message, so just read the file
488 * directly
489 */
490 ret = CRYPT_ReadBlobFromFile(pvObject, &fileBlob);
491 blob = &fileBlob;
492 break;
493 case CERT_QUERY_OBJECT_BLOB:
494 blob = pvObject;
495 ret = TRUE;
496 break;
497 default:
498 SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */
499 ret = FALSE;
500 }
501 if (!ret)
502 return FALSE;
503
504 ret = FALSE;
505 if (dwExpectedFormatTypeFlags & CERT_QUERY_FORMAT_FLAG_BINARY)
506 {
507 /* Try it first as a signed message */
508 if (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED)
509 ret = CRYPT_QuerySignedMessage(blob, pdwMsgAndCertEncodingType,
510 pdwContentType, &msg);
511 /* Failing that, try as an unsigned message */
512 if (!ret &&
513 (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED))
514 ret = CRYPT_QueryUnsignedMessage(blob, pdwMsgAndCertEncodingType,
515 pdwContentType, &msg);
516 if (ret)
517 formatType = CERT_QUERY_FORMAT_BINARY;
518 }
519 if (!ret &&
520 (dwExpectedFormatTypeFlags & CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED))
521 {
522 CRYPT_DATA_BLOB trimmed = { blob->cbData, blob->pbData };
523 CRYPT_DATA_BLOB decoded;
524
525 while (trimmed.cbData && !trimmed.pbData[trimmed.cbData - 1])
526 trimmed.cbData--;
527 ret = CryptStringToBinaryA((LPSTR)trimmed.pbData, trimmed.cbData,
528 CRYPT_STRING_BASE64_ANY, NULL, &decoded.cbData, NULL, NULL);
529 if (ret)
530 {
531 decoded.pbData = CryptMemAlloc(decoded.cbData);
532 if (decoded.pbData)
533 {
534 ret = CryptStringToBinaryA((LPSTR)trimmed.pbData,
535 trimmed.cbData, CRYPT_STRING_BASE64_ANY, decoded.pbData,
536 &decoded.cbData, NULL, NULL);
537 if (ret)
538 {
539 /* Try it first as a signed message */
540 if (dwExpectedContentTypeFlags &
541 CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED)
542 ret = CRYPT_QuerySignedMessage(&decoded,
543 pdwMsgAndCertEncodingType, pdwContentType, &msg);
544 /* Failing that, try as an unsigned message */
545 if (!ret && (dwExpectedContentTypeFlags &
546 CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED))
547 ret = CRYPT_QueryUnsignedMessage(&decoded,
548 pdwMsgAndCertEncodingType, pdwContentType, &msg);
549 if (ret)
550 formatType = CERT_QUERY_FORMAT_BASE64_ENCODED;
551 }
552 CryptMemFree(decoded.pbData);
553 }
554 else
555 ret = FALSE;
556 }
557 if (!ret && !(blob->cbData % sizeof(WCHAR)))
558 {
559 CRYPT_DATA_BLOB decoded;
560 LPWSTR str = (LPWSTR)blob->pbData;
561 DWORD strLen = blob->cbData / sizeof(WCHAR);
562
563 /* Try again, assuming the input string is UTF-16 base64 */
564 while (strLen && !str[strLen - 1])
565 strLen--;
566 ret = CryptStringToBinaryW(str, strLen, CRYPT_STRING_BASE64_ANY,
567 NULL, &decoded.cbData, NULL, NULL);
568 if (ret)
569 {
570 decoded.pbData = CryptMemAlloc(decoded.cbData);
571 if (decoded.pbData)
572 {
573 ret = CryptStringToBinaryW(str, strLen,
574 CRYPT_STRING_BASE64_ANY, decoded.pbData, &decoded.cbData,
575 NULL, NULL);
576 if (ret)
577 {
578 /* Try it first as a signed message */
579 if (dwExpectedContentTypeFlags &
580 CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED)
581 ret = CRYPT_QuerySignedMessage(&decoded,
582 pdwMsgAndCertEncodingType, pdwContentType, &msg);
583 /* Failing that, try as an unsigned message */
584 if (!ret && (dwExpectedContentTypeFlags &
585 CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED))
586 ret = CRYPT_QueryUnsignedMessage(&decoded,
587 pdwMsgAndCertEncodingType, pdwContentType, &msg);
588 if (ret)
589 formatType = CERT_QUERY_FORMAT_BASE64_ENCODED;
590 }
591 CryptMemFree(decoded.pbData);
592 }
593 else
594 ret = FALSE;
595 }
596 }
597 }
598 if (ret)
599 {
600 if (pdwFormatType)
601 *pdwFormatType = formatType;
602 if (phCertStore)
603 *phCertStore = CertOpenStore(CERT_STORE_PROV_MSG, encodingType, 0,
604 0, msg);
605 if (phMsg)
606 *phMsg = msg;
607 else
608 CryptMsgClose(msg);
609 }
610 if (blob == &fileBlob)
611 CryptMemFree(blob->pbData);
612 TRACE("returning %d\n", ret);
613 return ret;
614 }
615
616 static BOOL CRYPT_QueryEmbeddedMessageObject(DWORD dwObjectType,
617 const void *pvObject, DWORD dwExpectedContentTypeFlags,
618 DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType,
619 HCERTSTORE *phCertStore, HCRYPTMSG *phMsg)
620 {
621 HANDLE file;
622 GUID subject;
623 BOOL ret = FALSE;
624
625 TRACE("%s\n", debugstr_w(pvObject));
626
627 if (dwObjectType != CERT_QUERY_OBJECT_FILE)
628 {
629 WARN("don't know what to do for type %d embedded signed messages\n",
630 dwObjectType);
631 SetLastError(E_INVALIDARG);
632 return FALSE;
633 }
634 file = CreateFileW(pvObject, GENERIC_READ, FILE_SHARE_READ,
635 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
636 if (file != INVALID_HANDLE_VALUE)
637 {
638 ret = CryptSIPRetrieveSubjectGuid(pvObject, file, &subject);
639 if (ret)
640 {
641 SIP_DISPATCH_INFO sip;
642
643 memset(&sip, 0, sizeof(sip));
644 sip.cbSize = sizeof(sip);
645 ret = CryptSIPLoad(&subject, 0, &sip);
646 if (ret)
647 {
648 SIP_SUBJECTINFO subjectInfo;
649 CERT_BLOB blob;
650 DWORD encodingType;
651
652 memset(&subjectInfo, 0, sizeof(subjectInfo));
653 subjectInfo.cbSize = sizeof(subjectInfo);
654 subjectInfo.pgSubjectType = &subject;
655 subjectInfo.hFile = file;
656 subjectInfo.pwsFileName = pvObject;
657 ret = sip.pfGet(&subjectInfo, &encodingType, 0, &blob.cbData,
658 NULL);
659 if (ret)
660 {
661 blob.pbData = CryptMemAlloc(blob.cbData);
662 if (blob.pbData)
663 {
664 ret = sip.pfGet(&subjectInfo, &encodingType, 0,
665 &blob.cbData, blob.pbData);
666 if (ret)
667 {
668 ret = CRYPT_QueryMessageObject(
669 CERT_QUERY_OBJECT_BLOB, &blob,
670 CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED,
671 CERT_QUERY_FORMAT_FLAG_BINARY,
672 pdwMsgAndCertEncodingType, NULL, NULL,
673 phCertStore, phMsg);
674 if (ret && pdwContentType)
675 *pdwContentType =
676 CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED;
677 }
678 CryptMemFree(blob.pbData);
679 }
680 else
681 {
682 SetLastError(ERROR_OUTOFMEMORY);
683 ret = FALSE;
684 }
685 }
686 }
687 }
688 CloseHandle(file);
689 }
690 TRACE("returning %d\n", ret);
691 return ret;
692 }
693
694 BOOL WINAPI CryptQueryObject(DWORD dwObjectType, const void *pvObject,
695 DWORD dwExpectedContentTypeFlags, DWORD dwExpectedFormatTypeFlags,
696 DWORD dwFlags, DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType,
697 DWORD *pdwFormatType, HCERTSTORE *phCertStore, HCRYPTMSG *phMsg,
698 const void **ppvContext)
699 {
700 static const DWORD unimplementedTypes =
701 CERT_QUERY_CONTENT_FLAG_PKCS10 | CERT_QUERY_CONTENT_FLAG_PFX |
702 CERT_QUERY_CONTENT_FLAG_CERT_PAIR;
703 BOOL ret = TRUE;
704
705 TRACE("(%08x, %p, %08x, %08x, %08x, %p, %p, %p, %p, %p, %p)\n",
706 dwObjectType, pvObject, dwExpectedContentTypeFlags,
707 dwExpectedFormatTypeFlags, dwFlags, pdwMsgAndCertEncodingType,
708 pdwContentType, pdwFormatType, phCertStore, phMsg, ppvContext);
709
710 if (dwObjectType != CERT_QUERY_OBJECT_BLOB &&
711 dwObjectType != CERT_QUERY_OBJECT_FILE)
712 {
713 WARN("unsupported type %d\n", dwObjectType);
714 SetLastError(E_INVALIDARG);
715 return FALSE;
716 }
717 if (!pvObject)
718 {
719 WARN("missing required argument\n");
720 SetLastError(E_INVALIDARG);
721 return FALSE;
722 }
723 if (dwExpectedContentTypeFlags & unimplementedTypes)
724 WARN("unimplemented for types %08x\n",
725 dwExpectedContentTypeFlags & unimplementedTypes);
726
727 if (pdwFormatType)
728 *pdwFormatType = CERT_QUERY_FORMAT_BINARY;
729 if (phCertStore)
730 *phCertStore = NULL;
731 if (phMsg)
732 *phMsg = NULL;
733 if (ppvContext)
734 *ppvContext = NULL;
735
736 ret = FALSE;
737 if ((dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CERT) ||
738 (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CRL) ||
739 (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CTL))
740 {
741 ret = CRYPT_QueryContextObject(dwObjectType, pvObject,
742 dwExpectedContentTypeFlags, dwExpectedFormatTypeFlags,
743 pdwMsgAndCertEncodingType, pdwContentType, pdwFormatType, phCertStore,
744 ppvContext);
745 }
746 if (!ret &&
747 (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE))
748 {
749 ret = CRYPT_QuerySerializedStoreObject(dwObjectType, pvObject,
750 pdwMsgAndCertEncodingType, pdwContentType, phCertStore, phMsg);
751 }
752 if (!ret &&
753 ((dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT) ||
754 (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL) ||
755 (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL)))
756 {
757 ret = CRYPT_QuerySerializedContextObject(dwObjectType, pvObject,
758 dwExpectedContentTypeFlags, pdwMsgAndCertEncodingType, pdwContentType,
759 phCertStore, ppvContext);
760 }
761 if (!ret &&
762 ((dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED) ||
763 (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED)))
764 {
765 ret = CRYPT_QueryMessageObject(dwObjectType, pvObject,
766 dwExpectedContentTypeFlags, dwExpectedFormatTypeFlags,
767 pdwMsgAndCertEncodingType, pdwContentType, pdwFormatType,
768 phCertStore, phMsg);
769 }
770 if (!ret &&
771 (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED))
772 {
773 ret = CRYPT_QueryEmbeddedMessageObject(dwObjectType, pvObject,
774 dwExpectedContentTypeFlags, pdwMsgAndCertEncodingType, pdwContentType,
775 phCertStore, phMsg);
776 }
777 if (!ret)
778 SetLastError(CRYPT_E_NO_MATCH);
779 TRACE("returning %d\n", ret);
780 return ret;
781 }
782
783 static BOOL WINAPI CRYPT_FormatHexString(DWORD dwCertEncodingType,
784 DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
785 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
786 DWORD *pcbFormat)
787 {
788 BOOL ret;
789 DWORD bytesNeeded;
790
791 if (cbEncoded)
792 bytesNeeded = (cbEncoded * 3) * sizeof(WCHAR);
793 else
794 bytesNeeded = sizeof(WCHAR);
795 if (!pbFormat)
796 {
797 *pcbFormat = bytesNeeded;
798 ret = TRUE;
799 }
800 else if (*pcbFormat < bytesNeeded)
801 {
802 *pcbFormat = bytesNeeded;
803 SetLastError(ERROR_MORE_DATA);
804 ret = FALSE;
805 }
806 else
807 {
808 static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
809 static const WCHAR endFmt[] = { '%','0','2','x',0 };
810 DWORD i;
811 LPWSTR ptr = pbFormat;
812
813 *pcbFormat = bytesNeeded;
814 if (cbEncoded)
815 {
816 for (i = 0; i < cbEncoded; i++)
817 {
818 if (i < cbEncoded - 1)
819 ptr += sprintfW(ptr, fmt, pbEncoded[i]);
820 else
821 ptr += sprintfW(ptr, endFmt, pbEncoded[i]);
822 }
823 }
824 else
825 *ptr = 0;
826 ret = TRUE;
827 }
828 return ret;
829 }
830
831 #define MAX_STRING_RESOURCE_LEN 128
832
833 static const WCHAR commaSpace[] = { ',',' ',0 };
834
835 struct BitToString
836 {
837 BYTE bit;
838 int id;
839 WCHAR str[MAX_STRING_RESOURCE_LEN];
840 };
841
842 static BOOL CRYPT_FormatBits(BYTE bits, const struct BitToString *map,
843 DWORD mapEntries, void *pbFormat, DWORD *pcbFormat, BOOL *first)
844 {
845 DWORD bytesNeeded = sizeof(WCHAR);
846 int i;
847 BOOL ret = TRUE, localFirst = *first;
848
849 for (i = 0; i < mapEntries; i++)
850 if (bits & map[i].bit)
851 {
852 if (!localFirst)
853 bytesNeeded += strlenW(commaSpace) * sizeof(WCHAR);
854 localFirst = FALSE;
855 bytesNeeded += strlenW(map[i].str) * sizeof(WCHAR);
856 }
857 if (!pbFormat)
858 {
859 *first = localFirst;
860 *pcbFormat = bytesNeeded;
861 }
862 else if (*pcbFormat < bytesNeeded)
863 {
864 *first = localFirst;
865 *pcbFormat = bytesNeeded;
866 SetLastError(ERROR_MORE_DATA);
867 ret = FALSE;
868 }
869 else
870 {
871 LPWSTR str = pbFormat;
872
873 localFirst = *first;
874 *pcbFormat = bytesNeeded;
875 for (i = 0; i < mapEntries; i++)
876 if (bits & map[i].bit)
877 {
878 if (!localFirst)
879 {
880 strcpyW(str, commaSpace);
881 str += strlenW(commaSpace);
882 }
883 localFirst = FALSE;
884 strcpyW(str, map[i].str);
885 str += strlenW(map[i].str);
886 }
887 *first = localFirst;
888 }
889 return ret;
890 }
891
892 static struct BitToString keyUsageByte0Map[] = {
893 { CERT_DIGITAL_SIGNATURE_KEY_USAGE, IDS_DIGITAL_SIGNATURE, { 0 } },
894 { CERT_NON_REPUDIATION_KEY_USAGE, IDS_NON_REPUDIATION, { 0 } },
895 { CERT_KEY_ENCIPHERMENT_KEY_USAGE, IDS_KEY_ENCIPHERMENT, { 0 } },
896 { CERT_DATA_ENCIPHERMENT_KEY_USAGE, IDS_DATA_ENCIPHERMENT, { 0 } },
897 { CERT_KEY_AGREEMENT_KEY_USAGE, IDS_KEY_AGREEMENT, { 0 } },
898 { CERT_KEY_CERT_SIGN_KEY_USAGE, IDS_CERT_SIGN, { 0 } },
899 { CERT_OFFLINE_CRL_SIGN_KEY_USAGE, IDS_OFFLINE_CRL_SIGN, { 0 } },
900 { CERT_CRL_SIGN_KEY_USAGE, IDS_CRL_SIGN, { 0 } },
901 { CERT_ENCIPHER_ONLY_KEY_USAGE, IDS_ENCIPHER_ONLY, { 0 } },
902 };
903 static struct BitToString keyUsageByte1Map[] = {
904 { CERT_DECIPHER_ONLY_KEY_USAGE, IDS_DECIPHER_ONLY, { 0 } },
905 };
906
907 static BOOL WINAPI CRYPT_FormatKeyUsage(DWORD dwCertEncodingType,
908 DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
909 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
910 DWORD *pcbFormat)
911 {
912 DWORD size;
913 CRYPT_BIT_BLOB *bits;
914 BOOL ret;
915
916 if (!cbEncoded)
917 {
918 SetLastError(E_INVALIDARG);
919 return FALSE;
920 }
921 if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_KEY_USAGE,
922 pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &bits, &size)))
923 {
924 WCHAR infoNotAvailable[MAX_STRING_RESOURCE_LEN];
925 DWORD bytesNeeded = sizeof(WCHAR);
926
927 LoadStringW(hInstance, IDS_INFO_NOT_AVAILABLE, infoNotAvailable,
928 sizeof(infoNotAvailable) / sizeof(infoNotAvailable[0]));
929 if (!bits->cbData || bits->cbData > 2)
930 {
931 bytesNeeded += strlenW(infoNotAvailable) * sizeof(WCHAR);
932 if (!pbFormat)
933 *pcbFormat = bytesNeeded;
934 else if (*pcbFormat < bytesNeeded)
935 {
936 *pcbFormat = bytesNeeded;
937 SetLastError(ERROR_MORE_DATA);
938 ret = FALSE;
939 }
940 else
941 {
942 LPWSTR str = pbFormat;
943
944 *pcbFormat = bytesNeeded;
945 strcpyW(str, infoNotAvailable);
946 }
947 }
948 else
949 {
950 static BOOL stringsLoaded = FALSE;
951 int i;
952 DWORD bitStringLen;
953 BOOL first = TRUE;
954
955 if (!stringsLoaded)
956 {
957 for (i = 0;
958 i < sizeof(keyUsageByte0Map) / sizeof(keyUsageByte0Map[0]);
959 i++)
960 LoadStringW(hInstance, keyUsageByte0Map[i].id,
961 keyUsageByte0Map[i].str, MAX_STRING_RESOURCE_LEN);
962 for (i = 0;
963 i < sizeof(keyUsageByte1Map) / sizeof(keyUsageByte1Map[0]);
964 i++)
965 LoadStringW(hInstance, keyUsageByte1Map[i].id,
966 keyUsageByte1Map[i].str, MAX_STRING_RESOURCE_LEN);
967 stringsLoaded = TRUE;
968 }
969 CRYPT_FormatBits(bits->pbData[0], keyUsageByte0Map,
970 sizeof(keyUsageByte0Map) / sizeof(keyUsageByte0Map[0]),
971 NULL, &bitStringLen, &first);
972 bytesNeeded += bitStringLen;
973 if (bits->cbData == 2)
974 {
975 CRYPT_FormatBits(bits->pbData[1], keyUsageByte1Map,
976 sizeof(keyUsageByte1Map) / sizeof(keyUsageByte1Map[0]),
977 NULL, &bitStringLen, &first);
978 bytesNeeded += bitStringLen;
979 }
980 bytesNeeded += 3 * sizeof(WCHAR); /* " (" + ")" */
981 CRYPT_FormatHexString(0, 0, 0, NULL, NULL, bits->pbData,
982 bits->cbData, NULL, &size);
983 bytesNeeded += size;
984 if (!pbFormat)
985 *pcbFormat = bytesNeeded;
986 else if (*pcbFormat < bytesNeeded)
987 {
988 *pcbFormat = bytesNeeded;
989 SetLastError(ERROR_MORE_DATA);
990 ret = FALSE;
991 }
992 else
993 {
994 LPWSTR str = pbFormat;
995
996 bitStringLen = bytesNeeded;
997 first = TRUE;
998 CRYPT_FormatBits(bits->pbData[0], keyUsageByte0Map,
999 sizeof(keyUsageByte0Map) / sizeof(keyUsageByte0Map[0]),
1000 str, &bitStringLen, &first);
1001 str += bitStringLen / sizeof(WCHAR) - 1;
1002 if (bits->cbData == 2)
1003 {
1004 bitStringLen = bytesNeeded;
1005 CRYPT_FormatBits(bits->pbData[1], keyUsageByte1Map,
1006 sizeof(keyUsageByte1Map) / sizeof(keyUsageByte1Map[0]),
1007 str, &bitStringLen, &first);
1008 str += bitStringLen / sizeof(WCHAR) - 1;
1009 }
1010 *str++ = ' ';
1011 *str++ = '(';
1012 CRYPT_FormatHexString(0, 0, 0, NULL, NULL, bits->pbData,
1013 bits->cbData, str, &size);
1014 str += size / sizeof(WCHAR) - 1;
1015 *str++ = ')';
1016 *str = 0;
1017 }
1018 }
1019 LocalFree(bits);
1020 }
1021 return ret;
1022 }
1023
1024 static const WCHAR crlf[] = { '\r','\n',0 };
1025
1026 static WCHAR subjectTypeHeader[MAX_STRING_RESOURCE_LEN];
1027 static WCHAR subjectTypeCA[MAX_STRING_RESOURCE_LEN];
1028 static WCHAR subjectTypeEndCert[MAX_STRING_RESOURCE_LEN];
1029 static WCHAR pathLengthHeader[MAX_STRING_RESOURCE_LEN];
1030
1031 static BOOL WINAPI CRYPT_FormatBasicConstraints2(DWORD dwCertEncodingType,
1032 DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
1033 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
1034 DWORD *pcbFormat)
1035 {
1036 DWORD size;
1037 CERT_BASIC_CONSTRAINTS2_INFO *info;
1038 BOOL ret;
1039
1040 if (!cbEncoded)
1041 {
1042 SetLastError(E_INVALIDARG);
1043 return FALSE;
1044 }
1045 if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_BASIC_CONSTRAINTS2,
1046 pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)))
1047 {
1048 static const WCHAR pathFmt[] = { '%','d',0 };
1049 static BOOL stringsLoaded = FALSE;
1050 DWORD bytesNeeded = sizeof(WCHAR); /* space for the NULL terminator */
1051 WCHAR pathLength[MAX_STRING_RESOURCE_LEN];
1052 LPCWSTR sep, subjectType;
1053 DWORD sepLen;
1054
1055 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1056 {
1057 sep = crlf;
1058 sepLen = strlenW(crlf) * sizeof(WCHAR);
1059 }
1060 else
1061 {
1062 sep = commaSpace;
1063 sepLen = strlenW(commaSpace) * sizeof(WCHAR);
1064 }
1065
1066 if (!stringsLoaded)
1067 {
1068 LoadStringW(hInstance, IDS_SUBJECT_TYPE, subjectTypeHeader,
1069 sizeof(subjectTypeHeader) / sizeof(subjectTypeHeader[0]));
1070 LoadStringW(hInstance, IDS_SUBJECT_TYPE_CA, subjectTypeCA,
1071 sizeof(subjectTypeCA) / sizeof(subjectTypeCA[0]));
1072 LoadStringW(hInstance, IDS_SUBJECT_TYPE_END_CERT,
1073 subjectTypeEndCert,
1074 sizeof(subjectTypeEndCert) / sizeof(subjectTypeEndCert[0]));
1075 LoadStringW(hInstance, IDS_PATH_LENGTH, pathLengthHeader,
1076 sizeof(pathLengthHeader) / sizeof(pathLengthHeader[0]));
1077 stringsLoaded = TRUE;
1078 }
1079 bytesNeeded += strlenW(subjectTypeHeader) * sizeof(WCHAR);
1080 if (info->fCA)
1081 subjectType = subjectTypeCA;
1082 else
1083 subjectType = subjectTypeEndCert;
1084 bytesNeeded += strlenW(subjectType) * sizeof(WCHAR);
1085 bytesNeeded += sepLen;
1086 bytesNeeded += strlenW(pathLengthHeader) * sizeof(WCHAR);
1087 if (info->fPathLenConstraint)
1088 sprintfW(pathLength, pathFmt, info->dwPathLenConstraint);
1089 else
1090 LoadStringW(hInstance, IDS_PATH_LENGTH_NONE, pathLength,
1091 sizeof(pathLength) / sizeof(pathLength[0]));
1092 bytesNeeded += strlenW(pathLength) * sizeof(WCHAR);
1093 if (!pbFormat)
1094 *pcbFormat = bytesNeeded;
1095 else if (*pcbFormat < bytesNeeded)
1096 {
1097 *pcbFormat = bytesNeeded;
1098 SetLastError(ERROR_MORE_DATA);
1099 ret = FALSE;
1100 }
1101 else
1102 {
1103 LPWSTR str = pbFormat;
1104
1105 *pcbFormat = bytesNeeded;
1106 strcpyW(str, subjectTypeHeader);
1107 str += strlenW(subjectTypeHeader);
1108 strcpyW(str, subjectType);
1109 str += strlenW(subjectType);
1110 strcpyW(str, sep);
1111 str += sepLen / sizeof(WCHAR);
1112 strcpyW(str, pathLengthHeader);
1113 str += strlenW(pathLengthHeader);
1114 strcpyW(str, pathLength);
1115 str += strlenW(pathLength);
1116 }
1117 LocalFree(info);
1118 }
1119 return ret;
1120 }
1121
1122 static BOOL CRYPT_FormatHexStringWithPrefix(const CRYPT_DATA_BLOB *blob, int id,
1123 LPWSTR str, DWORD *pcbStr)
1124 {
1125 WCHAR buf[MAX_STRING_RESOURCE_LEN];
1126 DWORD bytesNeeded;
1127 BOOL ret;
1128
1129 LoadStringW(hInstance, id, buf, sizeof(buf) / sizeof(buf[0]));
1130 CRYPT_FormatHexString(X509_ASN_ENCODING, 0, 0, NULL, NULL,
1131 blob->pbData, blob->cbData, NULL, &bytesNeeded);
1132 bytesNeeded += strlenW(buf) * sizeof(WCHAR);
1133 if (!str)
1134 {
1135 *pcbStr = bytesNeeded;
1136 ret = TRUE;
1137 }
1138 else if (*pcbStr < bytesNeeded)
1139 {
1140 *pcbStr = bytesNeeded;
1141 SetLastError(ERROR_MORE_DATA);
1142 ret = FALSE;
1143 }
1144 else
1145 {
1146 *pcbStr = bytesNeeded;
1147 strcpyW(str, buf);
1148 str += strlenW(str);
1149 bytesNeeded -= strlenW(str) * sizeof(WCHAR);
1150 ret = CRYPT_FormatHexString(X509_ASN_ENCODING, 0, 0, NULL, NULL,
1151 blob->pbData, blob->cbData, str, &bytesNeeded);
1152 }
1153 return ret;
1154 }
1155
1156 static BOOL CRYPT_FormatKeyId(const CRYPT_DATA_BLOB *keyId, LPWSTR str,
1157 DWORD *pcbStr)
1158 {
1159 return CRYPT_FormatHexStringWithPrefix(keyId, IDS_KEY_ID, str, pcbStr);
1160 }
1161
1162 static BOOL CRYPT_FormatCertSerialNumber(const CRYPT_DATA_BLOB *serialNum, LPWSTR str,
1163 DWORD *pcbStr)
1164 {
1165 return CRYPT_FormatHexStringWithPrefix(serialNum, IDS_CERT_SERIAL_NUMBER,
1166 str, pcbStr);
1167 }
1168
1169 static const WCHAR indent[] = { ' ',' ',' ',' ',' ',0 };
1170 static const WCHAR colonCrlf[] = { ':','\r','\n',0 };
1171
1172 static BOOL CRYPT_FormatAltNameEntry(DWORD dwFormatStrType, DWORD indentLevel,
1173 CERT_ALT_NAME_ENTRY *entry, LPWSTR str, DWORD *pcbStr)
1174 {
1175 BOOL ret;
1176 WCHAR buf[MAX_STRING_RESOURCE_LEN];
1177 WCHAR mask[MAX_STRING_RESOURCE_LEN];
1178 WCHAR ipAddrBuf[32];
1179 WCHAR maskBuf[16];
1180 DWORD bytesNeeded = sizeof(WCHAR);
1181 DWORD strType = CERT_X500_NAME_STR | CERT_NAME_STR_REVERSE_FLAG;
1182
1183 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1184 bytesNeeded += indentLevel * strlenW(indent) * sizeof(WCHAR);
1185 switch (entry->dwAltNameChoice)
1186 {
1187 case CERT_ALT_NAME_RFC822_NAME:
1188 LoadStringW(hInstance, IDS_ALT_NAME_RFC822_NAME, buf,
1189 sizeof(buf) / sizeof(buf[0]));
1190 bytesNeeded += strlenW(entry->u.pwszRfc822Name) * sizeof(WCHAR);
1191 ret = TRUE;
1192 break;
1193 case CERT_ALT_NAME_DNS_NAME:
1194 LoadStringW(hInstance, IDS_ALT_NAME_DNS_NAME, buf,
1195 sizeof(buf) / sizeof(buf[0]));
1196 bytesNeeded += strlenW(entry->u.pwszDNSName) * sizeof(WCHAR);
1197 ret = TRUE;
1198 break;
1199 case CERT_ALT_NAME_DIRECTORY_NAME:
1200 {
1201 DWORD directoryNameLen;
1202
1203 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1204 strType |= CERT_NAME_STR_CRLF_FLAG;
1205 directoryNameLen = cert_name_to_str_with_indent(X509_ASN_ENCODING,
1206 indentLevel + 1, &entry->u.DirectoryName, strType, NULL, 0);
1207 LoadStringW(hInstance, IDS_ALT_NAME_DIRECTORY_NAME, buf,
1208 sizeof(buf) / sizeof(buf[0]));
1209 bytesNeeded += (directoryNameLen - 1) * sizeof(WCHAR);
1210 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1211 bytesNeeded += strlenW(colonCrlf) * sizeof(WCHAR);
1212 else
1213 bytesNeeded += sizeof(WCHAR); /* '=' */
1214 ret = TRUE;
1215 break;
1216 }
1217 case CERT_ALT_NAME_URL:
1218 LoadStringW(hInstance, IDS_ALT_NAME_URL, buf,
1219 sizeof(buf) / sizeof(buf[0]));
1220 bytesNeeded += strlenW(entry->u.pwszURL) * sizeof(WCHAR);
1221 ret = TRUE;
1222 break;
1223 case CERT_ALT_NAME_IP_ADDRESS:
1224 {
1225 static const WCHAR ipAddrWithMaskFmt[] = { '%','d','.','%','d','.',
1226 '%','d','.','%','d','/','%','d','.','%','d','.','%','d','.','%','d',0
1227 };
1228 static const WCHAR ipAddrFmt[] = { '%','d','.','%','d','.','%','d',
1229 '.','%','d',0 };
1230
1231 LoadStringW(hInstance, IDS_ALT_NAME_IP_ADDRESS, buf,
1232 sizeof(buf) / sizeof(buf[0]));
1233 if (entry->u.IPAddress.cbData == 8)
1234 {
1235 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1236 {
1237 LoadStringW(hInstance, IDS_ALT_NAME_MASK, mask,
1238 sizeof(mask) / sizeof(mask[0]));
1239 bytesNeeded += strlenW(mask) * sizeof(WCHAR);
1240 sprintfW(ipAddrBuf, ipAddrFmt,
1241 entry->u.IPAddress.pbData[0],
1242 entry->u.IPAddress.pbData[1],
1243 entry->u.IPAddress.pbData[2],
1244 entry->u.IPAddress.pbData[3]);
1245 bytesNeeded += strlenW(ipAddrBuf) * sizeof(WCHAR);
1246 /* indent again, for the mask line */
1247 bytesNeeded += indentLevel * strlenW(indent) * sizeof(WCHAR);
1248 sprintfW(maskBuf, ipAddrFmt,
1249 entry->u.IPAddress.pbData[4],
1250 entry->u.IPAddress.pbData[5],
1251 entry->u.IPAddress.pbData[6],
1252 entry->u.IPAddress.pbData[7]);
1253 bytesNeeded += strlenW(maskBuf) * sizeof(WCHAR);
1254 bytesNeeded += strlenW(crlf) * sizeof(WCHAR);
1255 }
1256 else
1257 {
1258 sprintfW(ipAddrBuf, ipAddrWithMaskFmt,
1259 entry->u.IPAddress.pbData[0],
1260 entry->u.IPAddress.pbData[1],
1261 entry->u.IPAddress.pbData[2],
1262 entry->u.IPAddress.pbData[3],
1263 entry->u.IPAddress.pbData[4],
1264 entry->u.IPAddress.pbData[5],
1265 entry->u.IPAddress.pbData[6],
1266 entry->u.IPAddress.pbData[7]);
1267 bytesNeeded += (strlenW(ipAddrBuf) + 1) * sizeof(WCHAR);
1268 }
1269 ret = TRUE;
1270 }
1271 else
1272 {
1273 FIXME("unknown IP address format (%d bytes)\n",
1274 entry->u.IPAddress.cbData);
1275 ret = FALSE;
1276 }
1277 break;
1278 }
1279 default:
1280 FIXME("unimplemented for %d\n", entry->dwAltNameChoice);
1281 ret = FALSE;
1282 }
1283 if (ret)
1284 {
1285 bytesNeeded += strlenW(buf) * sizeof(WCHAR);
1286 if (!str)
1287 *pcbStr = bytesNeeded;
1288 else if (*pcbStr < bytesNeeded)
1289 {
1290 *pcbStr = bytesNeeded;
1291 SetLastError(ERROR_MORE_DATA);
1292 ret = FALSE;
1293 }
1294 else
1295 {
1296 DWORD i;
1297
1298 *pcbStr = bytesNeeded;
1299 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1300 {
1301 for (i = 0; i < indentLevel; i++)
1302 {
1303 strcpyW(str, indent);
1304 str += strlenW(indent);
1305 }
1306 }
1307 strcpyW(str, buf);
1308 str += strlenW(str);
1309 switch (entry->dwAltNameChoice)
1310 {
1311 case CERT_ALT_NAME_RFC822_NAME:
1312 case CERT_ALT_NAME_DNS_NAME:
1313 case CERT_ALT_NAME_URL:
1314 strcpyW(str, entry->u.pwszURL);
1315 break;
1316 case CERT_ALT_NAME_DIRECTORY_NAME:
1317 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1318 {
1319 strcpyW(str, colonCrlf);
1320 str += strlenW(colonCrlf);
1321 }
1322 else
1323 *str++ = '=';
1324 cert_name_to_str_with_indent(X509_ASN_ENCODING,
1325 indentLevel + 1, &entry->u.DirectoryName, strType, str,
1326 bytesNeeded / sizeof(WCHAR));
1327 break;
1328 case CERT_ALT_NAME_IP_ADDRESS:
1329 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1330 {
1331 strcpyW(str, ipAddrBuf);
1332 str += strlenW(ipAddrBuf);
1333 strcpyW(str, crlf);
1334 str += strlenW(crlf);
1335 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1336 {
1337 for (i = 0; i < indentLevel; i++)
1338 {
1339 strcpyW(str, indent);
1340 str += strlenW(indent);
1341 }
1342 }
1343 strcpyW(str, mask);
1344 str += strlenW(mask);
1345 strcpyW(str, maskBuf);
1346 }
1347 else
1348 strcpyW(str, ipAddrBuf);
1349 break;
1350 }
1351 }
1352 }
1353 return ret;
1354 }
1355
1356 static BOOL CRYPT_FormatAltNameInfo(DWORD dwFormatStrType, DWORD indentLevel,
1357 CERT_ALT_NAME_INFO *name, LPWSTR str, DWORD *pcbStr)
1358 {
1359 DWORD i, size, bytesNeeded = 0;
1360 BOOL ret = TRUE;
1361 LPCWSTR sep;
1362 DWORD sepLen;
1363
1364 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1365 {
1366 sep = crlf;
1367 sepLen = strlenW(crlf) * sizeof(WCHAR);
1368 }
1369 else
1370 {
1371 sep = commaSpace;
1372 sepLen = strlenW(commaSpace) * sizeof(WCHAR);
1373 }
1374
1375 for (i = 0; ret && i < name->cAltEntry; i++)
1376 {
1377 ret = CRYPT_FormatAltNameEntry(dwFormatStrType, indentLevel,
1378 &name->rgAltEntry[i], NULL, &size);
1379 if (ret)
1380 {
1381 bytesNeeded += size - sizeof(WCHAR);
1382 if (i < name->cAltEntry - 1)
1383 bytesNeeded += sepLen;
1384 }
1385 }
1386 if (ret)
1387 {
1388 bytesNeeded += sizeof(WCHAR);
1389 if (!str)
1390 *pcbStr = bytesNeeded;
1391 else if (*pcbStr < bytesNeeded)
1392 {
1393 *pcbStr = bytesNeeded;
1394 SetLastError(ERROR_MORE_DATA);
1395 ret = FALSE;
1396 }
1397 else
1398 {
1399 *pcbStr = bytesNeeded;
1400 for (i = 0; ret && i < name->cAltEntry; i++)
1401 {
1402 ret = CRYPT_FormatAltNameEntry(dwFormatStrType, indentLevel,
1403 &name->rgAltEntry[i], str, &size);
1404 if (ret)
1405 {
1406 str += size / sizeof(WCHAR) - 1;
1407 if (i < name->cAltEntry - 1)
1408 {
1409 strcpyW(str, sep);
1410 str += sepLen / sizeof(WCHAR);
1411 }
1412 }
1413 }
1414 }
1415 }
1416 return ret;
1417 }
1418
1419 static const WCHAR colonSep[] = { ':',' ',0 };
1420
1421 static BOOL WINAPI CRYPT_FormatAltName(DWORD dwCertEncodingType,
1422 DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
1423 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
1424 DWORD *pcbFormat)
1425 {
1426 BOOL ret;
1427 CERT_ALT_NAME_INFO *info;
1428 DWORD size;
1429
1430 if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_ALTERNATE_NAME,
1431 pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)))
1432 {
1433 ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 0, info, pbFormat, pcbFormat);
1434 LocalFree(info);
1435 }
1436 return ret;
1437 }
1438
1439 static BOOL CRYPT_FormatCertIssuer(DWORD dwFormatStrType,
1440 CERT_ALT_NAME_INFO *issuer, LPWSTR str, DWORD *pcbStr)
1441 {
1442 WCHAR buf[MAX_STRING_RESOURCE_LEN];
1443 DWORD bytesNeeded, sepLen;
1444 LPCWSTR sep;
1445 BOOL ret;
1446
1447 LoadStringW(hInstance, IDS_CERT_ISSUER, buf, sizeof(buf) / sizeof(buf[0]));
1448 ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 1, issuer, NULL,
1449 &bytesNeeded);
1450 bytesNeeded += strlenW(buf) * sizeof(WCHAR);
1451 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1452 {
1453 sep = colonCrlf;
1454 sepLen = strlenW(colonCrlf) * sizeof(WCHAR);
1455 }
1456 else
1457 {
1458 sep = colonSep;
1459 sepLen = strlenW(colonSep) * sizeof(WCHAR);
1460 }
1461 bytesNeeded += sepLen;
1462 if (ret)
1463 {
1464 if (!str)
1465 *pcbStr = bytesNeeded;
1466 else if (*pcbStr < bytesNeeded)
1467 {
1468 *pcbStr = bytesNeeded;
1469 SetLastError(ERROR_MORE_DATA);
1470 ret = FALSE;
1471 }
1472 else
1473 {
1474 *pcbStr = bytesNeeded;
1475 strcpyW(str, buf);
1476 bytesNeeded -= strlenW(str) * sizeof(WCHAR);
1477 str += strlenW(str);
1478 strcpyW(str, sep);
1479 str += sepLen / sizeof(WCHAR);
1480 ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 1, issuer, str,
1481 &bytesNeeded);
1482 }
1483 }
1484 return ret;
1485 }
1486
1487 static BOOL WINAPI CRYPT_FormatAuthorityKeyId2(DWORD dwCertEncodingType,
1488 DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
1489 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
1490 DWORD *pcbFormat)
1491 {
1492 CERT_AUTHORITY_KEY_ID2_INFO *info;
1493 DWORD size;
1494 BOOL ret = FALSE;
1495
1496 if (!cbEncoded)
1497 {
1498 SetLastError(E_INVALIDARG);
1499 return FALSE;
1500 }
1501 if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_AUTHORITY_KEY_ID2,
1502 pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)))
1503 {
1504 DWORD bytesNeeded = sizeof(WCHAR); /* space for the NULL terminator */
1505 LPCWSTR sep;
1506 DWORD sepLen;
1507 BOOL needSeparator = FALSE;
1508
1509 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1510 {
1511 sep = crlf;
1512 sepLen = strlenW(crlf) * sizeof(WCHAR);
1513 }
1514 else
1515 {
1516 sep = commaSpace;
1517 sepLen = strlenW(commaSpace) * sizeof(WCHAR);
1518 }
1519
1520 if (info->KeyId.cbData)
1521 {
1522 needSeparator = TRUE;
1523 ret = CRYPT_FormatKeyId(&info->KeyId, NULL, &size);
1524 if (ret)
1525 {
1526 /* don't include NULL-terminator more than once */
1527 bytesNeeded += size - sizeof(WCHAR);
1528 }
1529 }
1530 if (info->AuthorityCertIssuer.cAltEntry)
1531 {
1532 if (needSeparator)
1533 bytesNeeded += sepLen;
1534 needSeparator = TRUE;
1535 ret = CRYPT_FormatCertIssuer(dwFormatStrType,
1536 &info->AuthorityCertIssuer, NULL, &size);
1537 if (ret)
1538 {
1539 /* don't include NULL-terminator more than once */
1540 bytesNeeded += size - sizeof(WCHAR);
1541 }
1542 }
1543 if (info->AuthorityCertSerialNumber.cbData)
1544 {
1545 if (needSeparator)
1546 bytesNeeded += sepLen;
1547 ret = CRYPT_FormatCertSerialNumber(
1548 &info->AuthorityCertSerialNumber, NULL, &size);
1549 if (ret)
1550 {
1551 /* don't include NULL-terminator more than once */
1552 bytesNeeded += size - sizeof(WCHAR);
1553 }
1554 }
1555 if (ret)
1556 {
1557 if (!pbFormat)
1558 *pcbFormat = bytesNeeded;
1559 else if (*pcbFormat < bytesNeeded)
1560 {
1561 *pcbFormat = bytesNeeded;
1562 SetLastError(ERROR_MORE_DATA);
1563 ret = FALSE;
1564 }
1565 else
1566 {
1567 LPWSTR str = pbFormat;
1568
1569 *pcbFormat = bytesNeeded;
1570 needSeparator = FALSE;
1571 if (info->KeyId.cbData)
1572 {
1573 needSeparator = TRUE;
1574 /* Overestimate size available, it's already been checked
1575 * above.
1576 */
1577 size = bytesNeeded;
1578 ret = CRYPT_FormatKeyId(&info->KeyId, str, &size);
1579 if (ret)
1580 str += size / sizeof(WCHAR) - 1;
1581 }
1582 if (info->AuthorityCertIssuer.cAltEntry)
1583 {
1584 if (needSeparator)
1585 {
1586 strcpyW(str, sep);
1587 str += sepLen / sizeof(WCHAR);
1588 }
1589 needSeparator = TRUE;
1590 /* Overestimate size available, it's already been checked
1591 * above.
1592 */
1593 size = bytesNeeded;
1594 ret = CRYPT_FormatCertIssuer(dwFormatStrType,
1595 &info->AuthorityCertIssuer, str, &size);
1596 if (ret)
1597 str += size / sizeof(WCHAR) - 1;
1598 }
1599 if (info->AuthorityCertSerialNumber.cbData)
1600 {
1601 if (needSeparator)
1602 {
1603 strcpyW(str, sep);
1604 str += sepLen / sizeof(WCHAR);
1605 }
1606 /* Overestimate size available, it's already been checked
1607 * above.
1608 */
1609 size = bytesNeeded;
1610 ret = CRYPT_FormatCertSerialNumber(
1611 &info->AuthorityCertSerialNumber, str, &size);
1612 }
1613 }
1614 }
1615 LocalFree(info);
1616 }
1617 return ret;
1618 }
1619
1620 static WCHAR aia[MAX_STRING_RESOURCE_LEN];
1621 static WCHAR accessMethod[MAX_STRING_RESOURCE_LEN];
1622 static WCHAR ocsp[MAX_STRING_RESOURCE_LEN];
1623 static WCHAR caIssuers[MAX_STRING_RESOURCE_LEN];
1624 static WCHAR unknown[MAX_STRING_RESOURCE_LEN];
1625 static WCHAR accessLocation[MAX_STRING_RESOURCE_LEN];
1626
1627 static BOOL WINAPI CRYPT_FormatAuthorityInfoAccess(DWORD dwCertEncodingType,
1628 DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
1629 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
1630 DWORD *pcbFormat)
1631 {
1632 CERT_AUTHORITY_INFO_ACCESS *info;
1633 DWORD size;
1634 BOOL ret = FALSE;
1635
1636 if (!cbEncoded)
1637 {
1638 SetLastError(E_INVALIDARG);
1639 return FALSE;
1640 }
1641 if ((ret = CryptDecodeObjectEx(dwCertEncodingType,
1642 X509_AUTHORITY_INFO_ACCESS, pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG,
1643 NULL, &info, &size)))
1644 {
1645 DWORD bytesNeeded = sizeof(WCHAR);
1646
1647 if (!info->cAccDescr)
1648 {
1649 WCHAR infoNotAvailable[MAX_STRING_RESOURCE_LEN];
1650
1651 LoadStringW(hInstance, IDS_INFO_NOT_AVAILABLE, infoNotAvailable,
1652 sizeof(infoNotAvailable) / sizeof(infoNotAvailable[0]));
1653 bytesNeeded += strlenW(infoNotAvailable) * sizeof(WCHAR);
1654 if (!pbFormat)
1655 *pcbFormat = bytesNeeded;
1656 else if (*pcbFormat < bytesNeeded)
1657 {
1658 *pcbFormat = bytesNeeded;
1659 SetLastError(ERROR_MORE_DATA);
1660 ret = FALSE;
1661 }
1662 else
1663 {
1664 *pcbFormat = bytesNeeded;
1665 strcpyW(pbFormat, infoNotAvailable);
1666 }
1667 }
1668 else
1669 {
1670 static const WCHAR numFmt[] = { '%','d',0 };
1671 static const WCHAR equal[] = { '=',0 };
1672 static BOOL stringsLoaded = FALSE;
1673 DWORD i;
1674 LPCWSTR headingSep, accessMethodSep, locationSep;
1675 WCHAR accessDescrNum[11];
1676
1677 if (!stringsLoaded)
1678 {
1679 LoadStringW(hInstance, IDS_AIA, aia,
1680 sizeof(aia) / sizeof(aia[0]));
1681 LoadStringW(hInstance, IDS_ACCESS_METHOD, accessMethod,
1682 sizeof(accessMethod) / sizeof(accessMethod[0]));
1683 LoadStringW(hInstance, IDS_ACCESS_METHOD_OCSP, ocsp,
1684 sizeof(ocsp) / sizeof(ocsp[0]));
1685 LoadStringW(hInstance, IDS_ACCESS_METHOD_CA_ISSUERS, caIssuers,
1686 sizeof(caIssuers) / sizeof(caIssuers[0]));
1687 LoadStringW(hInstance, IDS_ACCESS_METHOD_UNKNOWN, unknown,
1688 sizeof(unknown) / sizeof(unknown[0]));
1689 LoadStringW(hInstance, IDS_ACCESS_LOCATION, accessLocation,
1690 sizeof(accessLocation) / sizeof(accessLocation[0]));
1691 stringsLoaded = TRUE;
1692 }
1693 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1694 {
1695 headingSep = crlf;
1696 accessMethodSep = crlf;
1697 locationSep = colonCrlf;
1698 }
1699 else
1700 {
1701 headingSep = colonSep;
1702 accessMethodSep = commaSpace;
1703 locationSep = equal;
1704 }
1705
1706 for (i = 0; ret && i < info->cAccDescr; i++)
1707 {
1708 /* Heading */
1709 bytesNeeded += sizeof(WCHAR); /* left bracket */
1710 sprintfW(accessDescrNum, numFmt, i + 1);
1711 bytesNeeded += strlenW(accessDescrNum) * sizeof(WCHAR);
1712 bytesNeeded += sizeof(WCHAR); /* right bracket */
1713 bytesNeeded += strlenW(aia) * sizeof(WCHAR);
1714 bytesNeeded += strlenW(headingSep) * sizeof(WCHAR);
1715 /* Access method */
1716 bytesNeeded += strlenW(accessMethod) * sizeof(WCHAR);
1717 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1718 bytesNeeded += strlenW(indent) * sizeof(WCHAR);
1719 if (!strcmp(info->rgAccDescr[i].pszAccessMethod,
1720 szOID_PKIX_OCSP))
1721 bytesNeeded += strlenW(ocsp) * sizeof(WCHAR);
1722 else if (!strcmp(info->rgAccDescr[i].pszAccessMethod,
1723 szOID_PKIX_CA_ISSUERS))
1724 bytesNeeded += strlenW(caIssuers) * sizeof(caIssuers);
1725 else
1726 bytesNeeded += strlenW(unknown) * sizeof(WCHAR);
1727 bytesNeeded += sizeof(WCHAR); /* space */
1728 bytesNeeded += sizeof(WCHAR); /* left paren */
1729 bytesNeeded += strlen(info->rgAccDescr[i].pszAccessMethod)
1730 * sizeof(WCHAR);
1731 bytesNeeded += sizeof(WCHAR); /* right paren */
1732 /* Delimiter between access method and location */
1733 bytesNeeded += strlenW(accessMethodSep) * sizeof(WCHAR);
1734 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1735 bytesNeeded += strlenW(indent) * sizeof(WCHAR);
1736 bytesNeeded += strlenW(accessLocation) * sizeof(WCHAR);
1737 bytesNeeded += strlenW(locationSep) * sizeof(WCHAR);
1738 ret = CRYPT_FormatAltNameEntry(dwFormatStrType, 2,
1739 &info->rgAccDescr[i].AccessLocation, NULL, &size);
1740 if (ret)
1741 bytesNeeded += size - sizeof(WCHAR);
1742 /* Need extra delimiter between access method entries */
1743 if (i < info->cAccDescr - 1)
1744 bytesNeeded += strlenW(accessMethodSep) * sizeof(WCHAR);
1745 }
1746 if (ret)
1747 {
1748 if (!pbFormat)
1749 *pcbFormat = bytesNeeded;
1750 else if (*pcbFormat < bytesNeeded)
1751 {
1752 *pcbFormat = bytesNeeded;
1753 SetLastError(ERROR_MORE_DATA);
1754 ret = FALSE;
1755 }
1756 else
1757 {
1758 LPWSTR str = pbFormat;
1759 DWORD altNameEntrySize;
1760
1761 *pcbFormat = bytesNeeded;
1762 for (i = 0; ret && i < info->cAccDescr; i++)
1763 {
1764 LPCSTR oidPtr;
1765
1766 *str++ = '[';
1767 sprintfW(accessDescrNum, numFmt, i + 1);
1768 strcpyW(str, accessDescrNum);
1769 str += strlenW(accessDescrNum);
1770 *str++ = ']';
1771 strcpyW(str, aia);
1772 str += strlenW(aia);
1773 strcpyW(str, headingSep);
1774 str += strlenW(headingSep);
1775 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1776 {
1777 strcpyW(str, indent);
1778 str += strlenW(indent);
1779 }
1780 strcpyW(str, accessMethod);
1781 str += strlenW(accessMethod);
1782 if (!strcmp(info->rgAccDescr[i].pszAccessMethod,
1783 szOID_PKIX_OCSP))
1784 {
1785 strcpyW(str, ocsp);
1786 str += strlenW(ocsp);
1787 }
1788 else if (!strcmp(info->rgAccDescr[i].pszAccessMethod,
1789 szOID_PKIX_CA_ISSUERS))
1790 {
1791 strcpyW(str, caIssuers);
1792 str += strlenW(caIssuers);
1793 }
1794 else
1795 {
1796 strcpyW(str, unknown);
1797 str += strlenW(unknown);
1798 }
1799 *str++ = ' ';
1800 *str++ = '(';
1801 for (oidPtr = info->rgAccDescr[i].pszAccessMethod;
1802 *oidPtr; oidPtr++, str++)
1803 *str = *oidPtr;
1804 *str++ = ')';
1805 strcpyW(str, accessMethodSep);
1806 str += strlenW(accessMethodSep);
1807 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1808 {
1809 strcpyW(str, indent);
1810 str += strlenW(indent);
1811 }
1812 strcpyW(str, accessLocation);
1813 str += strlenW(accessLocation);
1814 strcpyW(str, locationSep);
1815 str += strlenW(locationSep);
1816 /* This overestimates the size available, but that
1817 * won't matter since we checked earlier whether enough
1818 * space for the entire string was available.
1819 */
1820 altNameEntrySize = bytesNeeded;
1821 ret = CRYPT_FormatAltNameEntry(dwFormatStrType, 2,
1822 &info->rgAccDescr[i].AccessLocation, str,
1823 &altNameEntrySize);
1824 if (ret)
1825 str += altNameEntrySize / sizeof(WCHAR) - 1;
1826 if (i < info->cAccDescr - 1)
1827 {
1828 strcpyW(str, accessMethodSep);
1829 str += strlenW(accessMethodSep);
1830 }
1831 }
1832 }
1833 }
1834 }
1835 LocalFree(info);
1836 }
1837 return ret;
1838 }
1839
1840 static WCHAR keyCompromise[MAX_STRING_RESOURCE_LEN];
1841 static WCHAR caCompromise[MAX_STRING_RESOURCE_LEN];
1842 static WCHAR affiliationChanged[MAX_STRING_RESOURCE_LEN];
1843 static WCHAR superseded[MAX_STRING_RESOURCE_LEN];
1844 static WCHAR operationCeased[MAX_STRING_RESOURCE_LEN];
1845 static WCHAR certificateHold[MAX_STRING_RESOURCE_LEN];
1846
1847 struct reason_map_entry
1848 {
1849 BYTE reasonBit;
1850 LPWSTR reason;
1851 int id;
1852 };
1853 static struct reason_map_entry reason_map[] = {
1854 { CRL_REASON_KEY_COMPROMISE_FLAG, keyCompromise, IDS_REASON_KEY_COMPROMISE },
1855 { CRL_REASON_CA_COMPROMISE_FLAG, caCompromise, IDS_REASON_CA_COMPROMISE },
1856 { CRL_REASON_AFFILIATION_CHANGED_FLAG, affiliationChanged,
1857 IDS_REASON_AFFILIATION_CHANGED },
1858 { CRL_REASON_SUPERSEDED_FLAG, superseded, IDS_REASON_SUPERSEDED },
1859 { CRL_REASON_CESSATION_OF_OPERATION_FLAG, operationCeased,
1860 IDS_REASON_CESSATION_OF_OPERATION },
1861 { CRL_REASON_CERTIFICATE_HOLD_FLAG, certificateHold,
1862 IDS_REASON_CERTIFICATE_HOLD },
1863 };
1864
1865 static BOOL CRYPT_FormatReason(DWORD dwFormatStrType,
1866 const CRYPT_BIT_BLOB *reasonFlags, LPWSTR str, DWORD *pcbStr)
1867 {
1868 static const WCHAR sep[] = { ',',' ',0 };
1869 static const WCHAR bitsFmt[] = { ' ','(','%','0','2','x',')',0 };
1870 static BOOL stringsLoaded = FALSE;
1871 int i, numReasons = 0;
1872 BOOL ret = TRUE;
1873 DWORD bytesNeeded = sizeof(WCHAR);
1874 WCHAR bits[6];
1875
1876 if (!stringsLoaded)
1877 {
1878 for (i = 0; i < sizeof(reason_map) / sizeof(reason_map[0]); i++)
1879 LoadStringW(hInstance, reason_map[i].id, reason_map[i].reason,
1880 MAX_STRING_RESOURCE_LEN);
1881 stringsLoaded = TRUE;
1882 }
1883 /* No need to check reasonFlags->cbData, we already know it's positive.
1884 * Ignore any other bytes, as they're for undefined bits.
1885 */
1886 for (i = 0; i < sizeof(reason_map) / sizeof(reason_map[0]); i++)
1887 {
1888 if (reasonFlags->pbData[0] & reason_map[i].reasonBit)
1889 {
1890 bytesNeeded += strlenW(reason_map[i].reason) * sizeof(WCHAR);
1891 if (numReasons++)
1892 bytesNeeded += strlenW(sep) * sizeof(WCHAR);
1893 }
1894 }
1895 sprintfW(bits, bitsFmt, reasonFlags->pbData[0]);
1896 bytesNeeded += strlenW(bits);
1897 if (!str)
1898 *pcbStr = bytesNeeded;
1899 else if (*pcbStr < bytesNeeded)
1900 {
1901 *pcbStr = bytesNeeded;
1902 SetLastError(ERROR_MORE_DATA);
1903 ret = FALSE;
1904 }
1905 else
1906 {
1907 *pcbStr = bytesNeeded;
1908 for (i = 0; i < sizeof(reason_map) / sizeof(reason_map[0]); i++)
1909 {
1910 if (reasonFlags->pbData[0] & reason_map[i].reasonBit)
1911 {
1912 strcpyW(str, reason_map[i].reason);
1913 str += strlenW(reason_map[i].reason);
1914 if (i < sizeof(reason_map) / sizeof(reason_map[0]) - 1 &&
1915 numReasons)
1916 {
1917 strcpyW(str, sep);
1918 str += strlenW(sep);
1919 }
1920 }
1921 }
1922 strcpyW(str, bits);
1923 }
1924 return ret;
1925 }
1926
1927 static WCHAR crlDistPoint[MAX_STRING_RESOURCE_LEN];
1928 static WCHAR distPointName[MAX_STRING_RESOURCE_LEN];
1929 static WCHAR fullName[MAX_STRING_RESOURCE_LEN];
1930 static WCHAR rdnName[MAX_STRING_RESOURCE_LEN];
1931 static WCHAR reason[MAX_STRING_RESOURCE_LEN];
1932 static WCHAR issuer[MAX_STRING_RESOURCE_LEN];
1933
1934 static BOOL WINAPI CRYPT_FormatCRLDistPoints(DWORD dwCertEncodingType,
1935 DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
1936 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
1937 DWORD *pcbFormat)
1938 {
1939 CRL_DIST_POINTS_INFO *info;
1940 DWORD size;
1941 BOOL ret = FALSE;
1942
1943 if (!cbEncoded)
1944 {
1945 SetLastError(E_INVALIDARG);
1946 return FALSE;
1947 }
1948 if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_CRL_DIST_POINTS,
1949 pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)))
1950 {
1951 static const WCHAR numFmt[] = { '%','d',0 };
1952 static const WCHAR colon[] = { ':',0 };
1953 static BOOL stringsLoaded = FALSE;
1954 DWORD bytesNeeded = sizeof(WCHAR); /* space for NULL terminator */
1955 BOOL haveAnEntry = FALSE;
1956 LPCWSTR headingSep, nameSep;
1957 WCHAR distPointNum[11];
1958 DWORD i;
1959
1960 if (!stringsLoaded)
1961 {
1962 LoadStringW(hInstance, IDS_CRL_DIST_POINT, crlDistPoint,
1963 sizeof(crlDistPoint) / sizeof(crlDistPoint[0]));
1964 LoadStringW(hInstance, IDS_CRL_DIST_POINT_NAME, distPointName,
1965 sizeof(distPointName) / sizeof(distPointName[0]));
1966 LoadStringW(hInstance, IDS_CRL_DIST_POINT_FULL_NAME, fullName,
1967 sizeof(fullName) / sizeof(fullName[0]));
1968 LoadStringW(hInstance, IDS_CRL_DIST_POINT_RDN_NAME, rdnName,
1969 sizeof(rdnName) / sizeof(rdnName[0]));
1970 LoadStringW(hInstance, IDS_CRL_DIST_POINT_REASON, reason,
1971 sizeof(reason) / sizeof(reason[0]));
1972 LoadStringW(hInstance, IDS_CRL_DIST_POINT_ISSUER, issuer,
1973 sizeof(issuer) / sizeof(issuer[0]));
1974 stringsLoaded = TRUE;
1975 }
1976 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1977 {
1978 headingSep = crlf;
1979 nameSep = colonCrlf;
1980 }
1981 else
1982 {
1983 headingSep = colonSep;
1984 nameSep = colon;
1985 }
1986
1987 for (i = 0; ret && i < info->cDistPoint; i++)
1988 {
1989 CRL_DIST_POINT *distPoint = &info->rgDistPoint[i];
1990
1991 if (distPoint->DistPointName.dwDistPointNameChoice !=
1992 CRL_DIST_POINT_NO_NAME)
1993 {
1994 bytesNeeded += strlenW(distPointName) * sizeof(WCHAR);
1995 bytesNeeded += strlenW(nameSep) * sizeof(WCHAR);
1996 if (distPoint->DistPointName.dwDistPointNameChoice ==
1997 CRL_DIST_POINT_FULL_NAME)
1998 bytesNeeded += strlenW(fullName) * sizeof(WCHAR);
1999 else
2000 bytesNeeded += strlenW(rdnName) * sizeof(WCHAR);
2001 bytesNeeded += strlenW(nameSep) * sizeof(WCHAR);
2002 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
2003 bytesNeeded += 2 * strlenW(indent) * sizeof(WCHAR);
2004 /* The indent level (3) is higher than when used as the issuer,
2005 * because the name is subordinate to the name type (full vs.
2006 * RDN.)
2007 */
2008 ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 3,
2009 &distPoint->DistPointName.u.FullName, NULL, &size);
2010 if (ret)
2011 bytesNeeded += size - sizeof(WCHAR);
2012 haveAnEntry = TRUE;
2013 }
2014 else if (distPoint->ReasonFlags.cbData)
2015 {
2016 bytesNeeded += strlenW(reason) * sizeof(WCHAR);
2017 ret = CRYPT_FormatReason(dwFormatStrType,
2018 &distPoint->ReasonFlags, NULL, &size);
2019 if (ret)
2020 bytesNeeded += size - sizeof(WCHAR);
2021 haveAnEntry = TRUE;
2022 }
2023 else if (distPoint->CRLIssuer.cAltEntry)
2024 {
2025 bytesNeeded += strlenW(issuer) * sizeof(WCHAR);
2026 bytesNeeded += strlenW(nameSep) * sizeof(WCHAR);
2027 ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 2,
2028 &distPoint->CRLIssuer, NULL, &size);
2029 if (ret)
2030 bytesNeeded += size - sizeof(WCHAR);
2031 haveAnEntry = TRUE;
2032 }
2033 if (haveAnEntry)
2034 {
2035 bytesNeeded += sizeof(WCHAR); /* left bracket */
2036 sprintfW(distPointNum, numFmt, i + 1);
2037 bytesNeeded += strlenW(distPointNum) * sizeof(WCHAR);
2038 bytesNeeded += sizeof(WCHAR); /* right bracket */
2039 bytesNeeded += strlenW(crlDistPoint) * sizeof(WCHAR);
2040 bytesNeeded += strlenW(headingSep) * sizeof(WCHAR);
2041 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
2042 bytesNeeded += strlenW(indent) * sizeof(WCHAR);
2043 }
2044 }
2045 if (!haveAnEntry)
2046 {
2047 WCHAR infoNotAvailable[MAX_STRING_RESOURCE_LEN];
2048
2049 LoadStringW(hInstance, IDS_INFO_NOT_AVAILABLE, infoNotAvailable,
2050 sizeof(infoNotAvailable) / sizeof(infoNotAvailable[0]));
2051 bytesNeeded += strlenW(infoNotAvailable) * sizeof(WCHAR);
2052 if (!pbFormat)
2053 *pcbFormat = bytesNeeded;
2054 else if (*pcbFormat < bytesNeeded)
2055 {
2056 *pcbFormat = bytesNeeded;
2057 SetLastError(ERROR_MORE_DATA);
2058 ret = FALSE;
2059 }
2060 else
2061 {
2062 *pcbFormat = bytesNeeded;
2063 strcpyW(pbFormat, infoNotAvailable);
2064 }
2065 }
2066 else
2067 {
2068 if (!pbFormat)
2069 *pcbFormat = bytesNeeded;
2070 else if (*pcbFormat < bytesNeeded)
2071 {
2072 *pcbFormat = bytesNeeded;
2073 SetLastError(ERROR_MORE_DATA);
2074 ret = FALSE;
2075 }
2076 else
2077 {
2078 LPWSTR str = pbFormat;
2079
2080 *pcbFormat = bytesNeeded;
2081 for (i = 0; ret && i < info->cDistPoint; i++)
2082 {
2083 CRL_DIST_POINT *distPoint = &info->rgDistPoint[i];
2084
2085 *str++ = '[';
2086 sprintfW(distPointNum, numFmt, i + 1);
2087 strcpyW(str, distPointNum);
2088 str += strlenW(distPointNum);
2089 *str++ = ']';
2090 strcpyW(str, crlDistPoint);
2091 str += strlenW(crlDistPoint);
2092 strcpyW(str, headingSep);
2093 str += strlenW(headingSep);
2094 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
2095 {
2096 strcpyW(str, indent);
2097 str += strlenW(indent);
2098 }
2099 if (distPoint->DistPointName.dwDistPointNameChoice !=
2100 CRL_DIST_POINT_NO_NAME)
2101 {
2102 DWORD altNameSize = bytesNeeded;
2103
2104 strcpyW(str, distPointName);
2105 str += strlenW(distPointName);
2106 strcpyW(str, nameSep);
2107 str += strlenW(nameSep);
2108 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
2109 {
2110 strcpyW(str, indent);
2111 str += strlenW(indent);
2112 strcpyW(str, indent);
2113 str += strlenW(indent);
2114 }
2115 if (distPoint->DistPointName.dwDistPointNameChoice ==
2116 CRL_DIST_POINT_FULL_NAME)
2117 {
2118 strcpyW(str, fullName);
2119 str += strlenW(fullName);
2120 }
2121 else
2122 {
2123 strcpyW(str, rdnName);
2124 str += strlenW(rdnName);
2125 }
2126 strcpyW(str, nameSep);
2127 str += strlenW(nameSep);
2128 ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 3,
2129 &distPoint->DistPointName.u.FullName, str,
2130 &altNameSize);
2131 if (ret)
2132 str += altNameSize / sizeof(WCHAR) - 1;
2133 }
2134 else if (distPoint->ReasonFlags.cbData)
2135 {
2136 DWORD reasonSize = bytesNeeded;
2137
2138 strcpyW(str, reason);
2139 str += strlenW(reason);
2140 ret = CRYPT_FormatReason(dwFormatStrType,
2141 &distPoint->ReasonFlags, str, &reasonSize);
2142 if (ret)
2143 str += reasonSize / sizeof(WCHAR) - 1;
2144 }
2145 else if (distPoint->CRLIssuer.cAltEntry)
2146 {
2147 DWORD crlIssuerSize = bytesNeeded;
2148
2149 strcpyW(str, issuer);
2150 str += strlenW(issuer);
2151 strcpyW(str, nameSep);
2152 str += strlenW(nameSep);
2153 ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 2,
2154 &distPoint->CRLIssuer, str,
2155 &crlIssuerSize);
2156 if (ret)
2157 str += crlIssuerSize / sizeof(WCHAR) - 1;
2158 }
2159 }
2160 }
2161 }
2162 LocalFree(info);
2163 }
2164 return ret;
2165 }
2166
2167 static BOOL WINAPI CRYPT_FormatEnhancedKeyUsage(DWORD dwCertEncodingType,
2168 DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
2169 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
2170 DWORD *pcbFormat)
2171 {
2172 CERT_ENHKEY_USAGE *usage;
2173 DWORD size;
2174 BOOL ret = FALSE;
2175
2176 if (!cbEncoded)
2177 {
2178 SetLastError(E_INVALIDARG);
2179 return FALSE;
2180 }
2181 if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_ENHANCED_KEY_USAGE,
2182 pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &usage, &size)))
2183 {
2184 WCHAR unknown[MAX_STRING_RESOURCE_LEN];
2185 DWORD i;
2186 DWORD bytesNeeded = sizeof(WCHAR); /* space for the NULL terminator */
2187 LPCWSTR sep;
2188 DWORD sepLen;
2189
2190 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
2191 {
2192 sep = crlf;
2193 sepLen = strlenW(crlf) * sizeof(WCHAR);
2194 }
2195 else
2196 {
2197 sep = commaSpace;
2198 sepLen = strlenW(commaSpace) * sizeof(WCHAR);
2199 }
2200
2201 LoadStringW(hInstance, IDS_USAGE_UNKNOWN, unknown,
2202 sizeof(unknown) / sizeof(unknown[0]));
2203 for (i = 0; i < usage->cUsageIdentifier; i++)
2204 {
2205 PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
2206 usage->rgpszUsageIdentifier[i], CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
2207
2208 if (info)
2209 bytesNeeded += strlenW(info->pwszName) * sizeof(WCHAR);
2210 else
2211 bytesNeeded += strlenW(unknown) * sizeof(WCHAR);
2212 bytesNeeded += sizeof(WCHAR); /* space */
2213 bytesNeeded += sizeof(WCHAR); /* left paren */
2214 bytesNeeded += strlen(usage->rgpszUsageIdentifier[i]) *
2215 sizeof(WCHAR);
2216 bytesNeeded += sizeof(WCHAR); /* right paren */
2217 if (i < usage->cUsageIdentifier - 1)
2218 bytesNeeded += sepLen;
2219 }
2220 if (!pbFormat)
2221 *pcbFormat = bytesNeeded;
2222 else if (*pcbFormat < bytesNeeded)
2223 {
2224 *pcbFormat = bytesNeeded;
2225 SetLastError(ERROR_MORE_DATA);
2226 ret = FALSE;
2227 }
2228 else
2229 {
2230 LPWSTR str = pbFormat;
2231
2232 *pcbFormat = bytesNeeded;
2233 for (i = 0; i < usage->cUsageIdentifier; i++)
2234 {
2235 PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
2236 usage->rgpszUsageIdentifier[i],
2237 CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
2238 LPCSTR oidPtr;
2239
2240 if (info)
2241 {
2242 strcpyW(str, info->pwszName);
2243 str += strlenW(info->pwszName);
2244 }
2245 else
2246 {
2247 strcpyW(str, unknown);
2248 str += strlenW(unknown);
2249 }
2250 *str++ = ' ';
2251 *str++ = '(';
2252 for (oidPtr = usage->rgpszUsageIdentifier[i]; *oidPtr; oidPtr++)
2253 *str++ = *oidPtr;
2254 *str++ = ')';
2255 *str = 0;
2256 if (i < usage->cUsageIdentifier - 1)
2257 {
2258 strcpyW(str, sep);
2259 str += sepLen / sizeof(WCHAR);
2260 }
2261 }
2262 }
2263 LocalFree(usage);
2264 }
2265 return ret;
2266 }
2267
2268 static struct BitToString netscapeCertTypeMap[] = {
2269 { NETSCAPE_SSL_CLIENT_AUTH_CERT_TYPE, IDS_NETSCAPE_SSL_CLIENT, { 0 } },
2270 { NETSCAPE_SSL_SERVER_AUTH_CERT_TYPE, IDS_NETSCAPE_SSL_SERVER, { 0 } },
2271 { NETSCAPE_SMIME_CERT_TYPE, IDS_NETSCAPE_SMIME, { 0 } },
2272 { NETSCAPE_SIGN_CERT_TYPE, IDS_NETSCAPE_SIGN, { 0 } },
2273 { NETSCAPE_SSL_CA_CERT_TYPE, IDS_NETSCAPE_SSL_CA, { 0 } },
2274 { NETSCAPE_SMIME_CA_CERT_TYPE, IDS_NETSCAPE_SMIME_CA, { 0 } },
2275 { NETSCAPE_SIGN_CA_CERT_TYPE, IDS_NETSCAPE_SIGN_CA, { 0 } },
2276 };
2277
2278 static BOOL WINAPI CRYPT_FormatNetscapeCertType(DWORD dwCertEncodingType,
2279 DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
2280 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
2281 DWORD *pcbFormat)
2282 {
2283 DWORD size;
2284 CRYPT_BIT_BLOB *bits;
2285 BOOL ret;
2286
2287 if (!cbEncoded)
2288 {
2289 SetLastError(E_INVALIDARG);
2290 return FALSE;
2291 }
2292 if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_BITS,
2293 pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &bits, &size)))
2294 {
2295 WCHAR infoNotAvailable[MAX_STRING_RESOURCE_LEN];
2296 DWORD bytesNeeded = sizeof(WCHAR);
2297
2298 LoadStringW(hInstance, IDS_INFO_NOT_AVAILABLE, infoNotAvailable,
2299 sizeof(infoNotAvailable) / sizeof(infoNotAvailable[0]));
2300 if (!bits->cbData || bits->cbData > 1)
2301 {
2302 bytesNeeded += strlenW(infoNotAvailable) * sizeof(WCHAR);
2303 if (!pbFormat)
2304 *pcbFormat = bytesNeeded;
2305 else if (*pcbFormat < bytesNeeded)
2306 {
2307 *pcbFormat = bytesNeeded;
2308 SetLastError(ERROR_MORE_DATA);
2309 ret = FALSE;
2310 }
2311 else
2312 {
2313 LPWSTR str = pbFormat;
2314
2315 *pcbFormat = bytesNeeded;
2316 strcpyW(str, infoNotAvailable);
2317 }
2318 }
2319 else
2320 {
2321 static BOOL stringsLoaded = FALSE;
2322 int i;
2323 DWORD bitStringLen;
2324 BOOL first = TRUE;
2325
2326 if (!stringsLoaded)
2327 {
2328 for (i = 0; i < sizeof(netscapeCertTypeMap) /
2329 sizeof(netscapeCertTypeMap[0]); i++)
2330 LoadStringW(hInstance, netscapeCertTypeMap[i].id,
2331 netscapeCertTypeMap[i].str, MAX_STRING_RESOURCE_LEN);
2332 stringsLoaded = TRUE;
2333 }
2334 CRYPT_FormatBits(bits->pbData[0], netscapeCertTypeMap,
2335 sizeof(netscapeCertTypeMap) / sizeof(netscapeCertTypeMap[0]),
2336 NULL, &bitStringLen, &first);
2337 bytesNeeded += bitStringLen;
2338 bytesNeeded += 3 * sizeof(WCHAR); /* " (" + ")" */
2339 CRYPT_FormatHexString(0, 0, 0, NULL, NULL, bits->pbData,
2340 bits->cbData, NULL, &size);
2341 bytesNeeded += size;
2342 if (!pbFormat)
2343 *pcbFormat = bytesNeeded;
2344 else if (*pcbFormat < bytesNeeded)
2345 {
2346 *pcbFormat = bytesNeeded;
2347 SetLastError(ERROR_MORE_DATA);
2348 ret = FALSE;
2349 }
2350 else
2351 {
2352 LPWSTR str = pbFormat;
2353
2354 bitStringLen = bytesNeeded;
2355 first = TRUE;
2356 CRYPT_FormatBits(bits->pbData[0], netscapeCertTypeMap,
2357 sizeof(netscapeCertTypeMap) / sizeof(netscapeCertTypeMap[0]),
2358 str, &bitStringLen, &first);
2359 str += bitStringLen / sizeof(WCHAR) - 1;
2360 *str++ = ' ';
2361 *str++ = '(';
2362 CRYPT_FormatHexString(0, 0, 0, NULL, NULL, bits->pbData,
2363 bits->cbData, str, &size);
2364 str += size / sizeof(WCHAR) - 1;
2365 *str++ = ')';
2366 *str = 0;
2367 }
2368 }
2369 LocalFree(bits);
2370 }
2371 return ret;
2372 }
2373
2374 static WCHAR financialCriteria[MAX_STRING_RESOURCE_LEN];
2375 static WCHAR available[MAX_STRING_RESOURCE_LEN];
2376 static WCHAR notAvailable[MAX_STRING_RESOURCE_LEN];
2377 static WCHAR meetsCriteria[MAX_STRING_RESOURCE_LEN];
2378 static WCHAR yes[MAX_STRING_RESOURCE_LEN];
2379 static WCHAR no[MAX_STRING_RESOURCE_LEN];
2380
2381 static BOOL WINAPI CRYPT_FormatSpcFinancialCriteria(DWORD dwCertEncodingType,
2382 DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
2383 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
2384 DWORD *pcbFormat)
2385 {
2386 SPC_FINANCIAL_CRITERIA criteria;
2387 DWORD size = sizeof(criteria);
2388 BOOL ret = FALSE;
2389
2390 if (!cbEncoded)
2391 {
2392 SetLastError(E_INVALIDARG);
2393 return FALSE;
2394 }
2395 if ((ret = CryptDecodeObjectEx(dwCertEncodingType,
2396 SPC_FINANCIAL_CRITERIA_STRUCT, pbEncoded, cbEncoded, 0, NULL, &criteria,
2397 &size)))
2398 {
2399 static BOOL stringsLoaded = FALSE;
2400 DWORD bytesNeeded = sizeof(WCHAR);
2401 LPCWSTR sep;
2402 DWORD sepLen;
2403
2404 if (!stringsLoaded)
2405 {
2406 LoadStringW(hInstance, IDS_FINANCIAL_CRITERIA, financialCriteria,
2407 sizeof(financialCriteria) / sizeof(financialCriteria[0]));
2408 LoadStringW(hInstance, IDS_FINANCIAL_CRITERIA_AVAILABLE, available,
2409 sizeof(available) / sizeof(available[0]));
2410 LoadStringW(hInstance, IDS_FINANCIAL_CRITERIA_NOT_AVAILABLE,
2411 notAvailable, sizeof(notAvailable) / sizeof(notAvailable[0]));
2412 LoadStringW(hInstance, IDS_FINANCIAL_CRITERIA_MEETS_CRITERIA,
2413 meetsCriteria, sizeof(meetsCriteria) / sizeof(meetsCriteria[0]));
2414 LoadStringW(hInstance, IDS_YES, yes, sizeof(yes) / sizeof(yes[0]));
2415 LoadStringW(hInstance, IDS_NO, no, sizeof(no) / sizeof(no[0]));
2416 stringsLoaded = TRUE;
2417 }
2418 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
2419 {
2420 sep = crlf;
2421 sepLen = strlenW(crlf) * sizeof(WCHAR);
2422 }
2423 else
2424 {
2425 sep = commaSpace;
2426 sepLen = strlenW(commaSpace) * sizeof(WCHAR);
2427 }
2428 bytesNeeded += strlenW(financialCriteria) * sizeof(WCHAR);
2429 if (criteria.fFinancialInfoAvailable)
2430 {
2431 bytesNeeded += strlenW(available) * sizeof(WCHAR);
2432 bytesNeeded += sepLen;
2433 bytesNeeded += strlenW(meetsCriteria) * sizeof(WCHAR);
2434 if (criteria.fMeetsCriteria)
2435 bytesNeeded += strlenW(yes) * sizeof(WCHAR);
2436 else
2437 bytesNeeded += strlenW(no) * sizeof(WCHAR);
2438 }
2439 else
2440 bytesNeeded += strlenW(notAvailable) * sizeof(WCHAR);
2441 if (!pbFormat)
2442 *pcbFormat = bytesNeeded;
2443 else if (*pcbFormat < bytesNeeded)
2444 {
2445 *pcbFormat = bytesNeeded;
2446 SetLastError(ERROR_MORE_DATA);
2447 ret = FALSE;
2448 }
2449 else
2450 {
2451 LPWSTR str = pbFormat;
2452
2453 *pcbFormat = bytesNeeded;
2454 strcpyW(str, financialCriteria);
2455 str += strlenW(financialCriteria);
2456 if (criteria.fFinancialInfoAvailable)
2457 {
2458 strcpyW(str, available);
2459 str += strlenW(available);
2460 strcpyW(str, sep);
2461 str += sepLen / sizeof(WCHAR);
2462 strcpyW(str, meetsCriteria);
2463 str += strlenW(meetsCriteria);
2464 if (criteria.fMeetsCriteria)
2465 strcpyW(str, yes);
2466 else
2467 strcpyW(str, no);
2468 }
2469 else
2470 {
2471 strcpyW(str, notAvailable);
2472 str += strlenW(notAvailable);
2473 }
2474 }
2475 }
2476 return ret;
2477 }
2478
2479 static BOOL WINAPI CRYPT_FormatUnicodeString(DWORD dwCertEncodingType,
2480 DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
2481 LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
2482 DWORD *pcbFormat)
2483 {
2484 CERT_NAME_VALUE *value;
2485 DWORD size;
2486 BOOL ret;
2487
2488 if (!cbEncoded)
2489 {
2490 SetLastError(E_INVALIDARG);
2491 return FALSE;
2492 }
2493 if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_UNICODE_ANY_STRING,
2494 pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &value, &size)))
2495 {
2496 if (!pbFormat)
2497 *pcbFormat = value->Value.cbData;
2498 else if (*pcbFormat < value->Value.cbData)
2499 {
2500 *pcbFormat = value->Value.cbData;
2501 SetLastError(ERROR_MORE_DATA);
2502 ret = FALSE;
2503 }
2504 else
2505 {
2506 LPWSTR str = pbFormat;
2507
2508 *pcbFormat = value->Value.cbData;
2509 strcpyW(str, (LPWSTR)value->Value.pbData);
2510 }
2511 }
2512 return ret;
2513 }
2514
2515 typedef BOOL (WINAPI *CryptFormatObjectFunc)(DWORD, DWORD, DWORD, void *,
2516 LPCSTR, const BYTE *, DWORD, void *, DWORD *);
2517
2518 static CryptFormatObjectFunc CRYPT_GetBuiltinFormatFunction(DWORD encodingType,
2519 DWORD formatStrType, LPCSTR lpszStructType)
2520 {
2521 CryptFormatObjectFunc format = NULL;
2522
2523 if ((encodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING)
2524 {
2525 SetLastError(ERROR_FILE_NOT_FOUND);
2526 return NULL;
2527 }
2528 if (IS_INTOID(lpszStructType))
2529 {
2530 switch (LOWORD(lpszStructType))
2531 {
2532 case LOWORD(X509_KEY_USAGE):
2533 format = CRYPT_FormatKeyUsage;
2534 break;
2535 case LOWORD(X509_ALTERNATE_NAME):
2536 format = CRYPT_FormatAltName;
2537 break;
2538 case LOWORD(X509_BASIC_CONSTRAINTS2):
2539 format = CRYPT_FormatBasicConstraints2;
2540 break;
2541 case LOWORD(X509_AUTHORITY_KEY_ID2):
2542 format = CRYPT_FormatAuthorityKeyId2;
2543 break;
2544 case LOWORD(X509_AUTHORITY_INFO_ACCESS):
2545 format = CRYPT_FormatAuthorityInfoAccess;
2546 break;
2547 case LOWORD(X509_CRL_DIST_POINTS):
2548 format = CRYPT_FormatCRLDistPoints;
2549 break;
2550 case LOWORD(X509_ENHANCED_KEY_USAGE):
2551 format = CRYPT_FormatEnhancedKeyUsage;
2552 break;
2553 case LOWORD(SPC_FINANCIAL_CRITERIA_STRUCT):
2554 format = CRYPT_FormatSpcFinancialCriteria;
2555 break;
2556 }
2557 }
2558 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME))
2559 format = CRYPT_FormatAltName;
2560 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME))
2561 format = CRYPT_FormatAltName;
2562 else if (!strcmp(lpszStructType, szOID_KEY_USAGE))
2563 format = CRYPT_FormatKeyUsage;
2564 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME2))
2565 format = CRYPT_FormatAltName;
2566 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME2))
2567 format = CRYPT_FormatAltName;
2568 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS2))
2569 format = CRYPT_FormatBasicConstraints2;
2570 else if (!strcmp(lpszStructType, szOID_AUTHORITY_INFO_ACCESS))
2571 format = CRYPT_FormatAuthorityInfoAccess;
2572 else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER2))
2573 format = CRYPT_FormatAuthorityKeyId2;
2574 else if (!strcmp(lpszStructType, szOID_CRL_DIST_POINTS))
2575 format = CRYPT_FormatCRLDistPoints;
2576 else if (!strcmp(lpszStructType, szOID_ENHANCED_KEY_USAGE))
2577 format = CRYPT_FormatEnhancedKeyUsage;
2578 else if (!strcmp(lpszStructType, szOID_NETSCAPE_CERT_TYPE))
2579 format = CRYPT_FormatNetscapeCertType;
2580 else if (!strcmp(lpszStructType, szOID_NETSCAPE_BASE_URL) ||
2581 !strcmp(lpszStructType, szOID_NETSCAPE_REVOCATION_URL) ||
2582 !strcmp(lpszStructType, szOID_NETSCAPE_CA_REVOCATION_URL) ||
2583 !strcmp(lpszStructType, szOID_NETSCAPE_CERT_RENEWAL_URL) ||
2584 !strcmp(lpszStructType, szOID_NETSCAPE_CA_POLICY_URL) ||
2585 !strcmp(lpszStructType, szOID_NETSCAPE_SSL_SERVER_NAME) ||
2586 !strcmp(lpszStructType, szOID_NETSCAPE_COMMENT))
2587 format = CRYPT_FormatUnicodeString;
2588 else if (!strcmp(lpszStructType, SPC_FINANCIAL_CRITERIA_OBJID))
2589 format = CRYPT_FormatSpcFinancialCriteria;
2590 return format;
2591 }
2592
2593 BOOL WINAPI CryptFormatObject(DWORD dwCertEncodingType, DWORD dwFormatType,
2594 DWORD dwFormatStrType, void *pFormatStruct, LPCSTR lpszStructType,
2595 const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, DWORD *pcbFormat)
2596 {
2597 CryptFormatObjectFunc format = NULL;
2598 HCRYPTOIDFUNCADDR hFunc = NULL;
2599 BOOL ret = FALSE;
2600
2601 TRACE("(%08x, %d, %08x, %p, %s, %p, %d, %p, %p)\n", dwCertEncodingType,
2602 dwFormatType, dwFormatStrType, pFormatStruct, debugstr_a(lpszStructType),
2603 pbEncoded, cbEncoded, pbFormat, pcbFormat);
2604
2605 if (!(format = CRYPT_GetBuiltinFormatFunction(dwCertEncodingType,
2606 dwFormatStrType, lpszStructType)))
2607 {
2608 static HCRYPTOIDFUNCSET set = NULL;
2609
2610 if (!set)
2611 set = CryptInitOIDFunctionSet(CRYPT_OID_FORMAT_OBJECT_FUNC, 0);
2612 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
2613 (void **)&format, &hFunc);
2614 }
2615 if (!format && (dwCertEncodingType & CERT_ENCODING_TYPE_MASK) ==
2616 X509_ASN_ENCODING && !(dwFormatStrType & CRYPT_FORMAT_STR_NO_HEX))
2617 format = CRYPT_FormatHexString;
2618 if (format)
2619 ret = format(dwCertEncodingType, dwFormatType, dwFormatStrType,
2620 pFormatStruct, lpszStructType, pbEncoded, cbEncoded, pbFormat,
2621 pcbFormat);
2622 if (hFunc)
2623 CryptFreeOIDFunctionAddress(hFunc, 0);
2624 return ret;
2625 }
Maarten's multimedia branch