mmdevapi: Fix IsFormatSupported and initialization.
[wine] / dlls / crypt32 / object.c
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 }