ReactOS  0.4.13-dev-99-g7e18b6d
main.c
Go to the documentation of this file.
1 /*
2  * Copyright 2008 Maarten Lankhorst
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18 
19 #define NONAMELESSUNION
20 
21 #include "config.h"
22 
23 #include <stdarg.h>
24 
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winnls.h"
28 #include "winreg.h"
29 #include "wincrypt.h"
30 #include "wintrust.h"
31 #include "winuser.h"
32 #include "objbase.h"
33 #include "cryptdlg.h"
34 #include "cryptuiapi.h"
35 #include "cryptres.h"
36 #include "wine/unicode.h"
37 #include "wine/debug.h"
38 
40 
42 
44 {
45  TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
46 
47  switch (fdwReason)
48  {
49  case DLL_WINE_PREATTACH:
50  return FALSE; /* prefer native version */
51  case DLL_PROCESS_ATTACH:
52  DisableThreadLibraryCalls(hinstDLL);
53  hInstance = hinstDLL;
54  break;
55  }
56  return TRUE;
57 }
58 
59 /***********************************************************************
60  * GetFriendlyNameOfCertA (CRYPTDLG.@)
61  */
64 {
66  pchBuffer, cchBuffer);
67 }
68 
69 /***********************************************************************
70  * GetFriendlyNameOfCertW (CRYPTDLG.@)
71  */
74 {
76  pchBuffer, cchBuffer);
77 }
78 
79 /***********************************************************************
80  * CertTrustInit (CRYPTDLG.@)
81  */
83 {
85 
86  TRACE("(%p)\n", pProvData);
87 
88  if (pProvData->padwTrustStepErrors &&
90  ret = S_OK;
91  TRACE("returning %08x\n", ret);
92  return ret;
93 }
94 
95 /***********************************************************************
96  * CertTrustCertPolicy (CRYPTDLG.@)
97  */
98 BOOL WINAPI CertTrustCertPolicy(CRYPT_PROVIDER_DATA *pProvData, DWORD idxSigner, BOOL fCounterSignerChain, DWORD idxCounterSigner)
99 {
100  FIXME("(%p, %d, %s, %d)\n", pProvData, idxSigner, fCounterSignerChain ? "TRUE" : "FALSE", idxCounterSigner);
101  return FALSE;
102 }
103 
104 /***********************************************************************
105  * CertTrustCleanup (CRYPTDLG.@)
106  */
108 {
109  FIXME("(%p)\n", pProvData);
110  return E_NOTIMPL;
111 }
112 
114 {
115  static const WCHAR policyFlagsKey[] = { 'S','o','f','t','w','a','r','e',
116  '\\','M','i','c','r','o','s','o','f','t','\\','C','r','y','p','t','o','g',
117  'r','a','p','h','y','\\','{','7','8','0','1','e','b','d','0','-','c','f',
118  '4','b','-','1','1','d','0','-','8','5','1','f','-','0','0','6','0','9',
119  '7','9','3','8','7','e','a','}',0 };
120  static const WCHAR policyFlags[] = { 'P','o','l','i','c','y','F','l','a',
121  'g','s',0 };
122  HKEY key;
123  BOOL ret = FALSE;
124 
125  if (!RegOpenKeyExW(HKEY_LOCAL_MACHINE, policyFlagsKey, 0, KEY_READ, &key))
126  {
127  DWORD type, flags, size = sizeof(flags);
128 
129  if (!RegQueryValueExW(key, policyFlags, NULL, &type, (BYTE *)&flags,
130  &size) && type == REG_DWORD)
131  {
132  /* The flag values aren't defined in any header I'm aware of, but
133  * this value is well documented on the net.
134  */
135  if (flags & 0x00010000)
136  ret = TRUE;
137  }
138  RegCloseKey(key);
139  }
140  return ret;
141 }
142 
143 /* Returns TRUE if pCert is not in the Disallowed system store, or FALSE if it
144  * is.
145  */
147 {
148  BOOL ret;
149  BYTE hash[20];
150  DWORD size = sizeof(hash);
151 
154  {
155  static const WCHAR disallowedW[] =
156  { 'D','i','s','a','l','l','o','w','e','d',0 };
159 
160  if (disallowed)
161  {
164 
165  if (found)
166  {
167  ret = FALSE;
169  }
171  }
172  }
173  return ret;
174 }
175 
177 {
178  DWORD confidence = 0;
179 
180  confidence = 0;
181  if (!(errorStatus & CERT_TRUST_IS_NOT_SIGNATURE_VALID))
182  confidence |= CERT_CONFIDENCE_SIG;
183  if (!(errorStatus & CERT_TRUST_IS_NOT_TIME_VALID))
184  confidence |= CERT_CONFIDENCE_TIME;
185  if (!(errorStatus & CERT_TRUST_IS_NOT_TIME_NESTED))
186  confidence |= CERT_CONFIDENCE_TIMENEST;
187  return confidence;
188 }
189 
192 {
193  BOOL ret;
194  CRYPT_PROVIDER_SGNR signer;
195  PCERT_SIMPLE_CHAIN simpleChain = chain->rgpChain[0];
196  DWORD i;
197 
198  memset(&signer, 0, sizeof(signer));
199  signer.cbStruct = sizeof(signer);
200  ret = data->psPfns->pfnAddSgnr2Chain(data, FALSE, 0, &signer);
201  if (ret)
202  {
204  FALSE, 0);
205 
206  if (sgnr)
207  {
208  sgnr->dwError = simpleChain->TrustStatus.dwErrorStatus;
210  }
211  else
212  ret = FALSE;
213  for (i = 0; ret && i < simpleChain->cElement; i++)
214  {
215  ret = data->psPfns->pfnAddCert2Chain(data, 0, FALSE, 0,
216  simpleChain->rgpElement[i]->pCertContext);
217  if (ret)
218  {
220 
221  if ((cert = WTHelperGetProvCertFromChain(sgnr, i)))
222  {
223  CERT_CHAIN_ELEMENT *element = simpleChain->rgpElement[i];
224 
225  cert->dwConfidence = CRYPTDLG_TrustStatusToConfidence(
226  element->TrustStatus.dwErrorStatus);
227  cert->dwError = element->TrustStatus.dwErrorStatus;
228  cert->pChainElement = element;
229  }
230  else
231  ret = FALSE;
232  }
233  }
234  }
235  return ret;
236 }
237 
240 {
242 
243  /* This should always be true, but just in case the calling function is
244  * called directly:
245  */
246  if (data->pWintrustData->dwUnionChoice == WTD_CHOICE_BLOB &&
247  data->pWintrustData->u.pBlob && data->pWintrustData->u.pBlob->cbMemObject ==
249  data->pWintrustData->u.pBlob->pbMemObject)
251  data->pWintrustData->u.pBlob->pbMemObject;
252  return pCert;
253 }
254 
256 {
257  HCERTCHAINENGINE engine = NULL;
258  HCERTSTORE root = NULL, trust = NULL;
259  DWORD i;
260 
261  if (cert->cRootStores)
262  {
265  if (root)
266  {
267  for (i = 0; i < cert->cRootStores; i++)
268  CertAddStoreToCollection(root, cert->rghstoreRoots[i], 0, 0);
269  }
270  }
271  if (cert->cTrustStores)
272  {
275  if (trust)
276  {
277  for (i = 0; i < cert->cTrustStores; i++)
278  CertAddStoreToCollection(trust, cert->rghstoreTrust[i], 0, 0);
279  }
280  }
281  if (cert->cRootStores || cert->cStores || cert->cTrustStores)
282  {
284 
285  memset(&config, 0, sizeof(config));
286  config.cbSize = sizeof(config);
287  config.hRestrictedRoot = root;
288  config.hRestrictedTrust = trust;
289  config.cAdditionalStore = cert->cStores;
290  config.rghAdditionalStore = cert->rghstoreCAs;
291  config.hRestrictedRoot = root;
293  CertCloseStore(root, 0);
294  CertCloseStore(trust, 0);
295  }
296  return engine;
297 }
298 
299 /***********************************************************************
300  * CertTrustFinalPolicy (CRYPTDLG.@)
301  */
303 {
304  BOOL ret;
305  DWORD err = S_OK;
307 
308  TRACE("(%p)\n", data);
309 
310  if (data->pWintrustData->dwUIChoice != WTD_UI_NONE)
311  FIXME("unimplemented for UI choice %d\n",
312  data->pWintrustData->dwUIChoice);
313  if (pCert)
314  {
315  DWORD flags = 0;
316  CERT_CHAIN_PARA chainPara;
317  HCERTCHAINENGINE engine;
318 
319  memset(&chainPara, 0, sizeof(chainPara));
320  chainPara.cbSize = sizeof(chainPara);
323  engine = CRYPTDLG_MakeEngine(pCert);
324  GetSystemTimeAsFileTime(&data->sftSystemTime);
326  if (ret)
327  {
329 
330  ret = CertGetCertificateChain(engine, pCert->pccert,
331  &data->sftSystemTime, NULL, &chainPara, flags, NULL, &chain);
332  if (ret)
333  {
334  if (chain->cChain != 1)
335  {
336  FIXME("unimplemented for more than 1 simple chain\n");
338  ret = FALSE;
339  }
340  else if ((ret = CRYPTDLG_CopyChain(data, chain)))
341  {
342  if (CertVerifyTimeValidity(&data->sftSystemTime,
343  pCert->pccert->pCertInfo))
344  {
345  ret = FALSE;
347  }
348  }
349  else
352  }
353  else
355  }
357  }
358  else
359  {
360  ret = FALSE;
362  }
363  /* Oddly, native doesn't set the error in the trust step error location,
364  * probably because this action is more advisory than anything else.
365  * Instead it stores it as the final error, but the function "succeeds" in
366  * any case.
367  */
368  if (!ret)
369  data->dwFinalError = err;
370  TRACE("returning %d (%08x)\n", S_OK, data->dwFinalError);
371  return S_OK;
372 }
373 
374 /***********************************************************************
375  * CertViewPropertiesA (CRYPTDLG.@)
376  */
378 {
380  LPWSTR title = NULL;
381  BOOL ret;
382 
383  TRACE("(%p)\n", info);
384 
385  memcpy(&infoW, info, sizeof(infoW));
386  if (info->szTitle)
387  {
388  int len = MultiByteToWideChar(CP_ACP, 0, info->szTitle, -1, NULL, 0);
389 
390  title = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
391  if (title)
392  {
393  MultiByteToWideChar(CP_ACP, 0, info->szTitle, -1, title, len);
394  infoW.szTitle = title;
395  }
396  else
397  {
398  ret = FALSE;
399  goto error;
400  }
401  }
404 error:
405  return ret;
406 }
407 
408 /***********************************************************************
409  * CertViewPropertiesW (CRYPTDLG.@)
410  */
412 {
413  static GUID cert_action_verify = CERT_CERTIFICATE_ACTION_VERIFY;
416  WINTRUST_DATA wtd;
417  LONG err;
418  BOOL ret;
419 
420  TRACE("(%p)\n", info);
421 
422  memset(&trust, 0, sizeof(trust));
423  trust.cbSize = sizeof(trust);
424  trust.pccert = info->pCertContext;
425  trust.cRootStores = info->cRootStores;
426  trust.rghstoreRoots = info->rghstoreRoots;
427  trust.cStores = info->cStores;
428  trust.rghstoreCAs = info->rghstoreCAs;
429  trust.cTrustStores = info->cTrustStores;
430  trust.rghstoreTrust = info->rghstoreTrust;
431  memset(&blob, 0, sizeof(blob));
432  blob.cbStruct = sizeof(blob);
433  blob.cbMemObject = sizeof(trust);
434  blob.pbMemObject = (BYTE *)&trust;
435  memset(&wtd, 0, sizeof(wtd));
436  wtd.cbStruct = sizeof(wtd);
437  wtd.dwUIChoice = WTD_UI_NONE;
439  wtd.u.pBlob = &blob;
441  err = WinVerifyTrust(NULL, &cert_action_verify, &wtd);
442  if (err == ERROR_SUCCESS)
443  {
445  BOOL propsChanged = FALSE;
446 
447  memset(&uiInfo, 0, sizeof(uiInfo));
448  uiInfo.dwSize = sizeof(uiInfo);
449  uiInfo.hwndParent = info->hwndParent;
450  uiInfo.dwFlags =
452  uiInfo.szTitle = info->szTitle;
453  uiInfo.pCertContext = info->pCertContext;
454  uiInfo.cPurposes = info->cArrayPurposes;
455  uiInfo.rgszPurposes = (LPCSTR *)info->arrayPurposes;
456  uiInfo.u.hWVTStateData = wtd.hWVTStateData;
458  uiInfo.cPropSheetPages = info->cArrayPropSheetPages;
459  uiInfo.rgPropSheetPages = info->arrayPropSheetPages;
460  uiInfo.nStartPage = info->nStartPage;
461  ret = CryptUIDlgViewCertificateW(&uiInfo, &propsChanged);
463  WinVerifyTrust(NULL, &cert_action_verify, &wtd);
464  }
465  else
466  ret = FALSE;
467  return ret;
468 }
469 
470 static BOOL CRYPT_FormatHexString(const BYTE *pbEncoded, DWORD cbEncoded,
471  WCHAR *str, DWORD *pcchStr)
472 {
473  BOOL ret;
474  DWORD charsNeeded;
475 
476  if (cbEncoded)
477  charsNeeded = (cbEncoded * 3);
478  else
479  charsNeeded = 1;
480  if (!str)
481  {
482  *pcchStr = charsNeeded;
483  ret = TRUE;
484  }
485  else if (*pcchStr < charsNeeded)
486  {
487  *pcchStr = charsNeeded;
489  ret = FALSE;
490  }
491  else
492  {
493  static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
494  static const WCHAR endFmt[] = { '%','0','2','x',0 };
495  DWORD i;
496  LPWSTR ptr = str;
497 
498  *pcchStr = charsNeeded;
499  if (cbEncoded)
500  {
501  for (i = 0; i < cbEncoded; i++)
502  {
503  if (i < cbEncoded - 1)
504  ptr += sprintfW(ptr, fmt, pbEncoded[i]);
505  else
506  ptr += sprintfW(ptr, endFmt, pbEncoded[i]);
507  }
508  }
509  else
510  *ptr = 0;
511  ret = TRUE;
512  }
513  return ret;
514 }
515 
516 static const WCHAR indent[] = { ' ',' ',' ',' ',' ',0 };
517 static const WCHAR colonCrlf[] = { ':','\r','\n',0 };
518 static const WCHAR colonSpace[] = { ':',' ',0 };
519 static const WCHAR crlf[] = { '\r','\n',0 };
520 static const WCHAR commaSep[] = { ',',' ',0 };
521 
523  DWORD dwFormatStrType, const BYTE *pbEncoded, DWORD cbEncoded,
524  WCHAR *str, DWORD *pcchStr)
525 {
526  BOOL ret;
527  DWORD size, charsNeeded = 1;
528  CERT_NAME_VALUE *cpsValue;
529 
531  pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &cpsValue, &size)))
532  {
533  LPCWSTR sep;
534  DWORD sepLen;
535 
536  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
537  sep = crlf;
538  else
539  sep = commaSep;
540 
541  sepLen = strlenW(sep);
542 
543  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
544  {
545  charsNeeded += 3 * strlenW(indent);
546  if (str && *pcchStr >= charsNeeded)
547  {
548  strcpyW(str, indent);
549  str += strlenW(indent);
550  strcpyW(str, indent);
551  str += strlenW(indent);
552  strcpyW(str, indent);
553  str += strlenW(indent);
554  }
555  }
556  charsNeeded += cpsValue->Value.cbData / sizeof(WCHAR);
557  if (str && *pcchStr >= charsNeeded)
558  {
559  strcpyW(str, (LPWSTR)cpsValue->Value.pbData);
560  str += cpsValue->Value.cbData / sizeof(WCHAR);
561  }
562  charsNeeded += sepLen;
563  if (str && *pcchStr >= charsNeeded)
564  {
565  strcpyW(str, sep);
566  str += sepLen;
567  }
568  LocalFree(cpsValue);
569  if (!str)
570  *pcchStr = charsNeeded;
571  else if (*pcchStr < charsNeeded)
572  {
573  *pcchStr = charsNeeded;
575  ret = FALSE;
576  }
577  else
578  *pcchStr = charsNeeded;
579  }
580  return ret;
581 }
582 
584  DWORD dwFormatStrType, const BYTE *pbEncoded, DWORD cbEncoded,
585  WCHAR *str, DWORD *pcchStr)
586 {
587  BOOL ret;
588  DWORD size, charsNeeded = 1;
590 
594  {
595  static const WCHAR numFmt[] = { '%','d',0 };
597  notice->pNoticeReference;
598  LPCWSTR headingSep, sep;
599  DWORD headingSepLen, sepLen;
600  LPWSTR noticeRef, organization, noticeNum, noticeText;
601  DWORD noticeRefLen, organizationLen, noticeNumLen, noticeTextLen;
602  WCHAR noticeNumStr[11];
603 
604  noticeRefLen = LoadStringW(hInstance, IDS_NOTICE_REF,
605  (LPWSTR)&noticeRef, 0);
606  organizationLen = LoadStringW(hInstance, IDS_ORGANIZATION,
607  (LPWSTR)&organization, 0);
608  noticeNumLen = LoadStringW(hInstance, IDS_NOTICE_NUM,
609  (LPWSTR)&noticeNum, 0);
610  noticeTextLen = LoadStringW(hInstance, IDS_NOTICE_TEXT,
611  (LPWSTR)&noticeText, 0);
612  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
613  {
614  headingSep = colonCrlf;
615  sep = crlf;
616  }
617  else
618  {
619  headingSep = colonSpace;
620  sep = commaSep;
621  }
622  sepLen = strlenW(sep);
623  headingSepLen = strlenW(headingSep);
624 
625  if (pNoticeRef)
626  {
627  DWORD k;
628  LPCSTR src;
629 
630  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
631  {
632  charsNeeded += 3 * strlenW(indent);
633  if (str && *pcchStr >= charsNeeded)
634  {
635  strcpyW(str, indent);
636  str += strlenW(indent);
637  strcpyW(str, indent);
638  str += strlenW(indent);
639  strcpyW(str, indent);
640  str += strlenW(indent);
641  }
642  }
643  charsNeeded += noticeRefLen;
644  if (str && *pcchStr >= charsNeeded)
645  {
646  memcpy(str, noticeRef, noticeRefLen * sizeof(WCHAR));
647  str += noticeRefLen;
648  }
649  charsNeeded += headingSepLen;
650  if (str && *pcchStr >= charsNeeded)
651  {
652  strcpyW(str, headingSep);
653  str += headingSepLen;
654  }
655  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
656  {
657  charsNeeded += 4 * strlenW(indent);
658  if (str && *pcchStr >= charsNeeded)
659  {
660  strcpyW(str, indent);
661  str += strlenW(indent);
662  strcpyW(str, indent);
663  str += strlenW(indent);
664  strcpyW(str, indent);
665  str += strlenW(indent);
666  strcpyW(str, indent);
667  str += strlenW(indent);
668  }
669  }
670  charsNeeded += organizationLen;
671  if (str && *pcchStr >= charsNeeded)
672  {
673  memcpy(str, organization, organizationLen * sizeof(WCHAR));
674  str += organizationLen;
675  }
676  charsNeeded += strlen(pNoticeRef->pszOrganization);
677  if (str && *pcchStr >= charsNeeded)
678  for (src = pNoticeRef->pszOrganization; src && *src;
679  src++, str++)
680  *str = *src;
681  charsNeeded += sepLen;
682  if (str && *pcchStr >= charsNeeded)
683  {
684  strcpyW(str, sep);
685  str += sepLen;
686  }
687  for (k = 0; k < pNoticeRef->cNoticeNumbers; k++)
688  {
689  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
690  {
691  charsNeeded += 4 * strlenW(indent);
692  if (str && *pcchStr >= charsNeeded)
693  {
694  strcpyW(str, indent);
695  str += strlenW(indent);
696  strcpyW(str, indent);
697  str += strlenW(indent);
698  strcpyW(str, indent);
699  str += strlenW(indent);
700  strcpyW(str, indent);
701  str += strlenW(indent);
702  }
703  }
704  charsNeeded += noticeNumLen;
705  if (str && *pcchStr >= charsNeeded)
706  {
707  memcpy(str, noticeNum, noticeNumLen * sizeof(WCHAR));
708  str += noticeNumLen;
709  }
710  sprintfW(noticeNumStr, numFmt, k + 1);
711  charsNeeded += strlenW(noticeNumStr);
712  if (str && *pcchStr >= charsNeeded)
713  {
714  strcpyW(str, noticeNumStr);
715  str += strlenW(noticeNumStr);
716  }
717  charsNeeded += sepLen;
718  if (str && *pcchStr >= charsNeeded)
719  {
720  strcpyW(str, sep);
721  str += sepLen;
722  }
723  }
724  }
725  if (notice->pszDisplayText)
726  {
727  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
728  {
729  charsNeeded += 3 * strlenW(indent);
730  if (str && *pcchStr >= charsNeeded)
731  {
732  strcpyW(str, indent);
733  str += strlenW(indent);
734  strcpyW(str, indent);
735  str += strlenW(indent);
736  strcpyW(str, indent);
737  str += strlenW(indent);
738  }
739  }
740  charsNeeded += noticeTextLen;
741  if (str && *pcchStr >= charsNeeded)
742  {
743  memcpy(str, noticeText, noticeTextLen * sizeof(WCHAR));
744  str += noticeTextLen;
745  }
746  charsNeeded += strlenW(notice->pszDisplayText);
747  if (str && *pcchStr >= charsNeeded)
748  {
749  strcpyW(str, notice->pszDisplayText);
750  str += strlenW(notice->pszDisplayText);
751  }
752  charsNeeded += sepLen;
753  if (str && *pcchStr >= charsNeeded)
754  {
755  strcpyW(str, sep);
756  str += sepLen;
757  }
758  }
759  LocalFree(notice);
760  if (!str)
761  *pcchStr = charsNeeded;
762  else if (*pcchStr < charsNeeded)
763  {
764  *pcchStr = charsNeeded;
766  ret = FALSE;
767  }
768  else
769  *pcchStr = charsNeeded;
770  }
771  return ret;
772 }
773 
774 /***********************************************************************
775  * FormatVerisignExtension (CRYPTDLG.@)
776  */
778  DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
779  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
780  DWORD *pcbFormat)
781 {
782  CERT_POLICIES_INFO *policies;
783  DWORD size;
784  BOOL ret = FALSE;
785 
786  if (!cbEncoded)
787  {
789  return FALSE;
790  }
792  pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size)))
793  {
794  static const WCHAR numFmt[] = { '%','d',0 };
795  DWORD charsNeeded = 1; /* space for NULL terminator */
796  LPCWSTR headingSep, sep;
797  DWORD headingSepLen, sepLen;
798  WCHAR policyNum[11], policyQualifierNum[11];
799  LPWSTR certPolicy, policyId, policyQualifierInfo, policyQualifierId;
800  LPWSTR cps, userNotice, qualifier;
801  DWORD certPolicyLen, policyIdLen, policyQualifierInfoLen;
802  DWORD policyQualifierIdLen, cpsLen, userNoticeLen, qualifierLen;
803  DWORD i;
804  LPWSTR str = pbFormat;
805 
806  certPolicyLen = LoadStringW(hInstance, IDS_CERT_POLICY,
807  (LPWSTR)&certPolicy, 0);
808  policyIdLen = LoadStringW(hInstance, IDS_POLICY_ID, (LPWSTR)&policyId,
809  0);
810  policyQualifierInfoLen = LoadStringW(hInstance,
811  IDS_POLICY_QUALIFIER_INFO, (LPWSTR)&policyQualifierInfo, 0);
812  policyQualifierIdLen = LoadStringW(hInstance, IDS_POLICY_QUALIFIER_ID,
813  (LPWSTR)&policyQualifierId, 0);
814  cpsLen = LoadStringW(hInstance, IDS_CPS, (LPWSTR)&cps, 0);
815  userNoticeLen = LoadStringW(hInstance, IDS_USER_NOTICE,
816  (LPWSTR)&userNotice, 0);
817  qualifierLen = LoadStringW(hInstance, IDS_QUALIFIER,
818  (LPWSTR)&qualifier, 0);
819  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
820  {
821  headingSep = colonCrlf;
822  sep = crlf;
823  }
824  else
825  {
826  headingSep = colonSpace;
827  sep = commaSep;
828  }
829  sepLen = strlenW(sep);
830  headingSepLen = strlenW(headingSep);
831 
832  for (i = 0; ret && i < policies->cPolicyInfo; i++)
833  {
834  CERT_POLICY_INFO *policy = &policies->rgPolicyInfo[i];
835  DWORD j;
836  LPCSTR src;
837 
838  charsNeeded += 1; /* '['*/
839  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
840  *str++ = '[';
841  sprintfW(policyNum, numFmt, i + 1);
842  charsNeeded += strlenW(policyNum);
843  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
844  {
845  strcpyW(str, policyNum);
846  str += strlenW(policyNum);
847  }
848  charsNeeded += 1; /* ']'*/
849  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
850  *str++ = ']';
851  charsNeeded += certPolicyLen;
852  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
853  {
854  memcpy(str, certPolicy, certPolicyLen * sizeof(WCHAR));
855  str += certPolicyLen;
856  }
857  charsNeeded += headingSepLen;
858  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
859  {
860  strcpyW(str, headingSep);
861  str += headingSepLen;
862  }
863  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
864  {
865  charsNeeded += strlenW(indent);
866  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
867  {
868  strcpyW(str, indent);
869  str += strlenW(indent);
870  }
871  }
872  charsNeeded += policyIdLen;
873  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
874  {
875  memcpy(str, policyId, policyIdLen * sizeof(WCHAR));
876  str += policyIdLen;
877  }
878  charsNeeded += strlen(policy->pszPolicyIdentifier);
879  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
880  {
881  for (src = policy->pszPolicyIdentifier; src && *src;
882  src++, str++)
883  *str = *src;
884  }
885  charsNeeded += sepLen;
886  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
887  {
888  strcpyW(str, sep);
889  str += sepLen;
890  }
891  for (j = 0; j < policy->cPolicyQualifier; j++)
892  {
893  CERT_POLICY_QUALIFIER_INFO *qualifierInfo =
894  &policy->rgPolicyQualifier[j];
895  DWORD sizeRemaining;
896 
897  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
898  {
899  charsNeeded += strlenW(indent);
900  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
901  {
902  strcpyW(str, indent);
903  str += strlenW(indent);
904  }
905  }
906  charsNeeded += 1; /* '['*/
907  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
908  *str++ = '[';
909  charsNeeded += strlenW(policyNum);
910  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
911  {
912  strcpyW(str, policyNum);
913  str += strlenW(policyNum);
914  }
915  charsNeeded += 1; /* ','*/
916  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
917  *str++ = ',';
918  sprintfW(policyQualifierNum, numFmt, j + 1);
919  charsNeeded += strlenW(policyQualifierNum);
920  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
921  {
922  strcpyW(str, policyQualifierNum);
923  str += strlenW(policyQualifierNum);
924  }
925  charsNeeded += 1; /* ']'*/
926  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
927  *str++ = ']';
928  charsNeeded += policyQualifierInfoLen;
929  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
930  {
931  memcpy(str, policyQualifierInfo,
932  policyQualifierInfoLen * sizeof(WCHAR));
933  str += policyQualifierInfoLen;
934  }
935  charsNeeded += headingSepLen;
936  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
937  {
938  strcpyW(str, headingSep);
939  str += headingSepLen;
940  }
941  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
942  {
943  charsNeeded += 2 * strlenW(indent);
944  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
945  {
946  strcpyW(str, indent);
947  str += strlenW(indent);
948  strcpyW(str, indent);
949  str += strlenW(indent);
950  }
951  }
952  charsNeeded += policyQualifierIdLen;
953  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
954  {
955  memcpy(str, policyQualifierId,
956  policyQualifierIdLen * sizeof(WCHAR));
957  str += policyQualifierIdLen;
958  }
959  if (!strcmp(qualifierInfo->pszPolicyQualifierId,
961  {
962  charsNeeded += cpsLen;
963  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
964  {
965  memcpy(str, cps, cpsLen * sizeof(WCHAR));
966  str += cpsLen;
967  }
968  }
969  else if (!strcmp(qualifierInfo->pszPolicyQualifierId,
971  {
972  charsNeeded += userNoticeLen;
973  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
974  {
975  memcpy(str, userNotice, userNoticeLen * sizeof(WCHAR));
976  str += userNoticeLen;
977  }
978  }
979  else
980  {
981  charsNeeded += strlen(qualifierInfo->pszPolicyQualifierId);
982  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
983  {
984  for (src = qualifierInfo->pszPolicyQualifierId;
985  src && *src; src++, str++)
986  *str = *src;
987  }
988  }
989  charsNeeded += sepLen;
990  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
991  {
992  strcpyW(str, sep);
993  str += sepLen;
994  }
995  if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
996  {
997  charsNeeded += 2 * strlenW(indent);
998  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
999  {
1000  strcpyW(str, indent);
1001  str += strlenW(indent);
1002  strcpyW(str, indent);
1003  str += strlenW(indent);
1004  }
1005  }
1006  charsNeeded += qualifierLen;
1007  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
1008  {
1009  memcpy(str, qualifier, qualifierLen * sizeof(WCHAR));
1010  str += qualifierLen;
1011  }
1012  charsNeeded += headingSepLen;
1013  if (str && *pcbFormat >= charsNeeded * sizeof(WCHAR))
1014  {
1015  strcpyW(str, headingSep);
1016  str += headingSepLen;
1017  }
1018  /* This if block is deliberately redundant with the same if
1019  * block above, in order to keep the code more readable (the
1020  * code flow follows the order in which the strings are output.)
1021  */
1022  if (!strcmp(qualifierInfo->pszPolicyQualifierId,
1024  {
1025  if (!str || *pcbFormat < charsNeeded * sizeof(WCHAR))
1026  {
1027  /* Insufficient space, determine how much is needed. */
1029  dwFormatStrType, qualifierInfo->Qualifier.pbData,
1030  qualifierInfo->Qualifier.cbData, NULL, &size);
1031  if (ret)
1032  charsNeeded += size - 1;
1033  }
1034  else
1035  {
1036  sizeRemaining = *pcbFormat / sizeof(WCHAR);
1037  sizeRemaining -= str - (LPWSTR)pbFormat;
1039  dwFormatStrType, qualifierInfo->Qualifier.pbData,
1040  qualifierInfo->Qualifier.cbData, str, &sizeRemaining);
1041  if (ret || GetLastError() == ERROR_MORE_DATA)
1042  {
1043  charsNeeded += sizeRemaining - 1;
1044  str += sizeRemaining - 1;
1045  }
1046  }
1047  }
1048  else if (!strcmp(qualifierInfo->pszPolicyQualifierId,
1050  {
1051  if (!str || *pcbFormat < charsNeeded * sizeof(WCHAR))
1052  {
1053  /* Insufficient space, determine how much is needed. */
1055  dwFormatStrType, qualifierInfo->Qualifier.pbData,
1056  qualifierInfo->Qualifier.cbData, NULL, &size);
1057  if (ret)
1058  charsNeeded += size - 1;
1059  }
1060  else
1061  {
1062  sizeRemaining = *pcbFormat / sizeof(WCHAR);
1063  sizeRemaining -= str - (LPWSTR)pbFormat;
1065  dwFormatStrType, qualifierInfo->Qualifier.pbData,
1066  qualifierInfo->Qualifier.cbData, str, &sizeRemaining);
1067  if (ret || GetLastError() == ERROR_MORE_DATA)
1068  {
1069  charsNeeded += sizeRemaining - 1;
1070  str += sizeRemaining - 1;
1071  }
1072  }
1073  }
1074  else
1075  {
1076  if (!str || *pcbFormat < charsNeeded * sizeof(WCHAR))
1077  {
1078  /* Insufficient space, determine how much is needed. */
1080  qualifierInfo->Qualifier.pbData,
1081  qualifierInfo->Qualifier.cbData, NULL, &size);
1082  if (ret)
1083  charsNeeded += size - 1;
1084  }
1085  else
1086  {
1087  sizeRemaining = *pcbFormat / sizeof(WCHAR);
1088  sizeRemaining -= str - (LPWSTR)pbFormat;
1090  qualifierInfo->Qualifier.pbData,
1091  qualifierInfo->Qualifier.cbData, str, &sizeRemaining);
1092  if (ret || GetLastError() == ERROR_MORE_DATA)
1093  {
1094  charsNeeded += sizeRemaining - 1;
1095  str += sizeRemaining - 1;
1096  }
1097  }
1098  }
1099  }
1100  }
1101  LocalFree(policies);
1102  if (ret)
1103  {
1104  if (!pbFormat)
1105  *pcbFormat = charsNeeded * sizeof(WCHAR);
1106  else if (*pcbFormat < charsNeeded * sizeof(WCHAR))
1107  {
1108  *pcbFormat = charsNeeded * sizeof(WCHAR);
1110  ret = FALSE;
1111  }
1112  else
1113  *pcbFormat = charsNeeded * sizeof(WCHAR);
1114  }
1115  }
1116  return ret;
1117 }
1118 
1119 #define szOID_MICROSOFT_Encryption_Key_Preference "1.3.6.1.4.1.311.16.4"
1120 
1121 /***********************************************************************
1122  * DllRegisterServer (CRYPTDLG.@)
1123  */
1125 {
1126  static WCHAR cryptdlg[] = { 'c','r','y','p','t','d','l','g','.',
1127  'd','l','l',0 };
1128  static WCHAR wintrust[] = { 'w','i','n','t','r','u','s','t','.',
1129  'd','l','l',0 };
1130  static WCHAR certTrustInit[] = { 'C','e','r','t','T','r','u','s','t',
1131  'I','n','i','t',0 };
1132  static WCHAR wintrustCertificateTrust[] = { 'W','i','n','t','r','u','s','t',
1133  'C','e','r','t','i','f','i','c','a','t','e','T','r','u','s','t',0 };
1134  static WCHAR certTrustCertPolicy[] = { 'C','e','r','t','T','r','u','s','t',
1135  'C','e','r','t','P','o','l','i','c','y',0 };
1136  static WCHAR certTrustFinalPolicy[] = { 'C','e','r','t','T','r','u','s','t',
1137  'F','i','n','a','l','P','o','l','i','c','y',0 };
1138  static WCHAR certTrustCleanup[] = { 'C','e','r','t','T','r','u','s','t',
1139  'C','l','e','a','n','u','p',0 };
1140  static const WCHAR cryptDlg[] = { 'c','r','y','p','t','d','l','g','.',
1141  'd','l','l',0 };
1144  HRESULT hr = S_OK;
1145 
1146  memset(&reg, 0, sizeof(reg));
1147  reg.cbStruct = sizeof(reg);
1148  reg.sInitProvider.cbStruct = sizeof(CRYPT_TRUST_REG_ENTRY);
1149  reg.sInitProvider.pwszDLLName = cryptdlg;
1150  reg.sInitProvider.pwszFunctionName = certTrustInit;
1151  reg.sCertificateProvider.cbStruct = sizeof(CRYPT_TRUST_REG_ENTRY);
1152  reg.sCertificateProvider.pwszDLLName = wintrust;
1153  reg.sCertificateProvider.pwszFunctionName = wintrustCertificateTrust;
1154  reg.sCertificatePolicyProvider.cbStruct = sizeof(CRYPT_TRUST_REG_ENTRY);
1155  reg.sCertificatePolicyProvider.pwszDLLName = cryptdlg;
1156  reg.sCertificatePolicyProvider.pwszFunctionName = certTrustCertPolicy;
1157  reg.sFinalPolicyProvider.cbStruct = sizeof(CRYPT_TRUST_REG_ENTRY);
1158  reg.sFinalPolicyProvider.pwszDLLName = cryptdlg;
1159  reg.sFinalPolicyProvider.pwszFunctionName = certTrustFinalPolicy;
1160  reg.sCleanupProvider.cbStruct = sizeof(CRYPT_TRUST_REG_ENTRY);
1161  reg.sCleanupProvider.pwszDLLName = cryptdlg;
1162  reg.sCleanupProvider.pwszFunctionName = certTrustCleanup;
1164  hr = GetLastError();
1166  "1.3.6.1.4.1.311.16.1.1", cryptDlg, "EncodeAttrSequence");
1168  szOID_MICROSOFT_Encryption_Key_Preference, cryptDlg, "EncodeRecipientID");
1170  "1.3.6.1.4.1.311.16.1.1", cryptDlg, "DecodeAttrSequence");
1172  szOID_MICROSOFT_Encryption_Key_Preference, cryptDlg, "DecodeRecipientID");
1174  szOID_PKIX_KP_EMAIL_PROTECTION, cryptDlg, "FormatPKIXEmailProtection");
1176  szOID_CERT_POLICIES, cryptDlg, "FormatVerisignExtension");
1177  return hr;
1178 }
1179 
1180 /***********************************************************************
1181  * DllUnregisterServer (CRYPTDLG.@)
1182  */
1184 {
1186 
1189  "1.3.6.1.4.1.311.16.1.1");
1193  "1.3.6.1.4.1.311.16.1.1");
1200  return S_OK;
1201 }
BOOL WINAPI CertGetCertificateChain(HCERTCHAINENGINE hChainEngine, PCCERT_CONTEXT pCertContext, LPFILETIME pTime, HCERTSTORE hAdditionalStore, PCERT_CHAIN_PARA pChainPara, DWORD dwFlags, LPVOID pvReserved, PCCERT_CHAIN_CONTEXT *ppChainContext)
Definition: chain.c:2879
#define WTD_STATEACTION_VERIFY
Definition: wintrust.h:123
PCCERT_CONTEXT WINAPI CertFindCertificateInStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, DWORD dwFlags, DWORD dwType, const void *pvPara, PCCERT_CONTEXT pPrevCertContext)
Definition: cert.c:1765
#define CERT_NAME_FRIENDLY_DISPLAY_TYPE
Definition: wincrypt.h:3501
#define szOID_PKIX_KP_EMAIL_PROTECTION
Definition: wincrypt.h:3297
#define IDS_POLICY_QUALIFIER_INFO
Definition: cryptres.h:25
#define IDS_NOTICE_TEXT
Definition: cryptres.h:33
static const WCHAR crlf[]
Definition: main.c:519
#define szOID_CERT_POLICIES
Definition: wincrypt.h:3197
BOOL WINAPI CertTrustCertPolicy(CRYPT_PROVIDER_DATA *pProvData, DWORD idxSigner, BOOL fCounterSignerChain, DWORD idxCounterSigner)
Definition: main.c:98
VOID WINAPI GetSystemTimeAsFileTime(OUT PFILETIME lpFileTime)
Definition: time.c:128
#define TRUE
Definition: types.h:120
int hash
Definition: main.c:58
static BOOL CRYPT_FormatCPS(DWORD dwCertEncodingType, DWORD dwFormatStrType, const BYTE *pbEncoded, DWORD cbEncoded, WCHAR *str, DWORD *pcchStr)
Definition: main.c:522
#define CERT_CHAIN_REVOCATION_CHECK_END_CERT
Definition: wincrypt.h:1056
#define CERT_TRUST_IS_NOT_TIME_VALID
Definition: wincrypt.h:870
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
struct config_s config
#define ERROR_SUCCESS
Definition: deptool.c:10
LPSTR pszPolicyIdentifier
Definition: wincrypt.h:393
BOOL WINAPI CryptDecodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:6286
HRESULT hr
Definition: shlfolder.c:183
#define error(str)
Definition: mkdosfs.c:1605
BOOL WINAPI CryptRegisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID, LPCWSTR pwszDll, LPCSTR pszOverrideFuncName)
Definition: oid.c:647
LPCPROPSHEETPAGEW rgPropSheetPages
Definition: cryptuiapi.h:140
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
Definition: image.c:133
static const WCHAR root[]
Definition: main.c:458
WINE_DEFAULT_DEBUG_CHANNEL(wmic)
DWORD cbStruct
Definition: wintrust.h:99
BOOL WINAPI CertViewPropertiesA(CERT_VIEWPROPERTIES_STRUCT_A *info)
Definition: main.c:377
CERT_POLICY_QUALIFIER_INFO * rgPolicyQualifier
Definition: wincrypt.h:395
CERT_POLICY_INFO * rgPolicyInfo
Definition: wincrypt.h:400
#define IDS_CPS
Definition: cryptres.h:49
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define KEY_READ
Definition: nt_native.h:1023
#define CP_ACP
Definition: compat.h:99
PCCERT_CHAIN_CONTEXT WINAPI CertDuplicateCertificateChain(PCCERT_CHAIN_CONTEXT pChainContext)
Definition: chain.c:2948
BOOL WINAPI CertFreeCertificateContext(PCCERT_CONTEXT pCertContext)
Definition: cert.c:371
BOOL WINAPI CertCreateCertificateChainEngine(PCERT_CHAIN_ENGINE_CONFIG pConfig, HCERTCHAINENGINE *phChainEngine)
Definition: chain.c:225
#define CRYPT_OID_FORMAT_OBJECT_FUNC
Definition: wincrypt.h:2499
static const WCHAR commaSep[]
Definition: main.c:520
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
DWORD cPolicyQualifier
Definition: wincrypt.h:394
#define DLL_PROCESS_ATTACH
Definition: compat.h:120
struct WINTRUST_BLOB_INFO_ * pBlob
Definition: wintrust.h:109
HRESULT WINAPI CertTrustFinalPolicy(CRYPT_PROVIDER_DATA *data)
Definition: main.c:302
#define CERT_FIND_SIGNATURE_HASH
Definition: wincrypt.h:2869
BOOL WINAPI CertAddStoreToCollection(HCERTSTORE hCollectionStore, HCERTSTORE hSiblingStore, DWORD dwUpdateFlags, DWORD dwPriority)
char * LPSTR
Definition: xmlstorage.h:182
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
VOID WINAPI CertFreeCertificateChain(PCCERT_CHAIN_CONTEXT pChainContext)
Definition: chain.c:2960
#define CERT_STORE_PROV_COLLECTION
Definition: wincrypt.h:2261
static WCHAR noticeText[]
Definition: encode.c:7449
static IN DWORD IN LPVOID lpvReserved
DWORD WINAPI GetFriendlyNameOfCertW(PCCERT_CONTEXT pccert, LPWSTR pchBuffer, DWORD cchBuffer)
Definition: main.c:72
#define CERT_CONFIDENCE_SIG
Definition: wintrust.h:224
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
static BOOL CRYPT_FormatUserNotice(DWORD dwCertEncodingType, DWORD dwFormatStrType, const BYTE *pbEncoded, DWORD cbEncoded, WCHAR *str, DWORD *pcchStr)
Definition: main.c:583
LONG WINAPI CertVerifyTimeValidity(LPFILETIME pTimeToVerify, PCERT_INFO pCertInfo)
Definition: cert.c:2158
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
const GUID * guid
BOOL WINAPI CertGetCertificateContextProperty(PCCERT_CONTEXT pCertContext, DWORD dwPropId, void *pvData, DWORD *pcbData)
Definition: cert.c:551
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
HRESULT WINAPI DllRegisterServer(void)
Definition: main.c:212
#define CERT_STORE_CREATE_NEW_FLAG
Definition: wincrypt.h:2464
static BOOL CRYPTDLG_CopyChain(CRYPT_PROVIDER_DATA *data, PCCERT_CHAIN_CONTEXT chain)
Definition: main.c:190
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
HRESULT WINAPI DllUnregisterServer(void)
Definition: main.c:220
CRYPT_PROVIDER_SGNR *WINAPI WTHelperGetProvSignerFromChain(CRYPT_PROVIDER_DATA *pProvData, DWORD idxSigner, BOOL fCounterSigner, DWORD idxCounterSigner)
PCCERT_CONTEXT pCertContext
Definition: wincrypt.h:916
static DWORD cchBuffer
Definition: fusion.c:83
#define FIXME(fmt,...)
Definition: debug.h:110
#define X509_CERT_POLICIES
Definition: wincrypt.h:3381
static PVOID ptr
Definition: dispmode.c:27
#define S_FALSE
Definition: winerror.h:2357
static HCERTCHAINENGINE CRYPTDLG_MakeEngine(CERT_VERIFY_CERTIFICATE_TRUST *cert)
Definition: main.c:255
#define E_INVALIDARG
Definition: ddrawi.h:101
const WCHAR * str
#define X509_UNICODE_ANY_STRING
Definition: wincrypt.h:3390
DWORD dwStateAction
Definition: wintrust.h:114
smooth NULL
Definition: ftsmooth.c:416
static APTTYPEQUALIFIER * qualifier
Definition: compobj.c:74
BOOL WINAPI CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
Definition: store.c:1127
struct sock * chain
Definition: tcpcore.h:1164
static BYTE cert[]
Definition: msg.c:1437
#define IDS_QUALIFIER
Definition: cryptres.h:29
#define TRUSTERROR_STEP_FINAL_WVTINIT
Definition: wintrust.h:273
const char * LPCSTR
Definition: xmlstorage.h:183
#define CRYPTUI_DISABLE_ADDTOSTORE
Definition: cryptuiapi.h:77
static BOOL CRYPTDLG_CheckOnlineCRL(void)
Definition: main.c:113
#define IDS_POLICY_ID
Definition: cryptres.h:24
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define szOID_PKIX_POLICY_QUALIFIER_USERNOTICE
Definition: wincrypt.h:3292
#define CRYPT_OID_DECODE_OBJECT_FUNC
Definition: wincrypt.h:2493
static BOOL CRYPT_FormatHexString(const BYTE *pbEncoded, DWORD cbEncoded, WCHAR *str, DWORD *pcchStr)
Definition: main.c:470
#define CERT_CONFIDENCE_TIME
Definition: wintrust.h:225
static BOOL CRYPTDLG_IsCertAllowed(PCCERT_CONTEXT pCert)
Definition: main.c:146
#define TRACE(s)
Definition: solgame.cpp:4
PCERT_INFO pCertInfo
Definition: wincrypt.h:482
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
static const SecPkgInfoW infoW
Definition: kerberos.c:293
#define CRYPT_FORMAT_STR_MULTI_LINE
Definition: wincrypt.h:3510
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4134
#define CRYPTUI_ENABLE_EDITPROPERTIES
Definition: cryptuiapi.h:76
void WINAPI CertFreeCertificateChainEngine(HCERTCHAINENGINE hChainEngine)
Definition: chain.c:249
BOOL WINAPI CryptUnregisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID)
Definition: oid.c:831
#define CERT_SIGNATURE_HASH_PROP_ID
Definition: wincrypt.h:2701
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define IDS_ORGANIZATION
Definition: cryptres.h:65
#define TRUST_E_NOSIGNATURE
Definition: winerror.h:3116
LONG HRESULT
Definition: typedefs.h:77
static LPCSTR DWORD void BYTE * pbEncoded
Definition: str.c:196
LONG WINAPI WinVerifyTrust(HWND hwnd, GUID *ActionID, LPVOID ActionData)
#define CERT_CONFIDENCE_TIMENEST
Definition: wintrust.h:226
CRYPT_PROVIDER_CERT *WINAPI WTHelperGetProvCertFromChain(CRYPT_PROVIDER_SGNR *pSgnr, DWORD idxCert)
#define TRUST_E_SUBJECT_NOT_TRUSTED
Definition: winerror.h:3115
#define WINAPI
Definition: msvc.h:8
#define TRUST_E_SYSTEM_ERROR
Definition: winerror.h:3104
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:409
#define CERT_TRUST_IS_NOT_SIGNATURE_VALID
Definition: wincrypt.h:873
HINSTANCE hInstance
Definition: main.c:36
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLbitfield flags
Definition: glext.h:7161
BOOL WINAPI WintrustRemoveActionID(GUID *pgActionID)
Definition: register.c:337
#define CERT_CERTIFICATE_ACTION_VERIFY
Definition: cryptdlg.h:236
static DWORD CRYPTDLG_TrustStatusToConfidence(DWORD errorStatus)
Definition: main.c:176
DWORD WINAPI CertGetNameStringA(PCCERT_CONTEXT pCertContext, DWORD dwType, DWORD dwFlags, void *pvTypePara, LPSTR pszNameString, DWORD cchNameString)
Definition: str.c:1127
int ret
BYTE * pbData
Definition: wincrypt.h:103
DWORD WINAPI GetFriendlyNameOfCertA(PCCERT_CONTEXT pccert, LPSTR pchBuffer, DWORD cchBuffer)
Definition: main.c:62
HKEY key
Definition: reg.c:42
#define X509_PKIX_POLICY_QUALIFIER_USERNOTICE
Definition: wincrypt.h:3414
#define IDS_USER_NOTICE
Definition: cryptres.h:50
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
unsigned char BYTE
Definition: mem.h:68
CERT_RDN_VALUE_BLOB Value
Definition: wincrypt.h:273
static const WCHAR disallowed[]
Definition: main.c:461
struct _CRYPT_TRUST_REG_ENTRY CRYPT_TRUST_REG_ENTRY
DWORD * padwTrustStepErrors
Definition: wintrust.h:358
GLenum src
Definition: glext.h:6340
#define err(...)
static const WCHAR indent[]
Definition: main.c:516
#define ERROR_MORE_DATA
Definition: dderror.h:13
_In_ DWORD dwCertEncodingType
Definition: wincrypt.h:5041
#define CERT_TRUST_IS_NOT_TIME_NESTED
Definition: wincrypt.h:871
static CERT_VERIFY_CERTIFICATE_TRUST * CRYPTDLG_GetVerifyData(CRYPT_PROVIDER_DATA *data)
Definition: main.c:238
BOOL WINAPI CertViewPropertiesW(CERT_VIEWPROPERTIES_STRUCT_W *info)
Definition: main.c:411
#define S_OK
Definition: intsafe.h:59
WINE_UNICODE_INLINE WCHAR * strcpyW(WCHAR *dst, const WCHAR *src)
Definition: unicode.h:219
notice
Definition: t1tokens.h:26
#define CERT_STORE_PROV_SYSTEM_W
Definition: wincrypt.h:2259
int type
Definition: main.c:85
PCERT_CHAIN_ELEMENT * rgpElement
Definition: wincrypt.h:928
#define TRUST_E_SUBJECT_FORM_UNKNOWN
Definition: winerror.h:3114
#define WT_ADD_ACTION_ID_RET_RESULT_FLAG
Definition: wintrust.h:448
static const WCHAR colonSpace[]
Definition: main.c:518
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
#define CERT_SYSTEM_STORE_CURRENT_USER
Definition: wincrypt.h:2324
#define WTD_STATEACTION_CLOSE
Definition: wintrust.h:124
#define E_NOTIMPL
Definition: ddrawi.h:99
HANDLE hWVTStateData
Definition: wintrust.h:115
#define sprintfW
Definition: unicode.h:58
BOOL WINAPI CryptUIDlgViewCertificateW(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, BOOL *pfPropertiesChanged)
Definition: main.c:4397
static int reg
Definition: i386-dis.c:1275
#define MultiByteToWideChar
Definition: compat.h:100
CRYPT_OBJID_BLOB Qualifier
Definition: wincrypt.h:389
#define IDS_NOTICE_NUM
Definition: cryptres.h:32
HCERTSTORE WINAPI CertOpenStore(LPCSTR lpszStoreProvider, DWORD dwMsgAndCertEncodingType, HCRYPTPROV_LEGACY hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:815
BOOL WINAPI WintrustAddActionID(GUID *pgActionID, DWORD fdwFlags, CRYPT_REGISTER_ACTIONID *psProvInfo)
Definition: register.c:238
HRESULT WINAPI CertTrustInit(CRYPT_PROVIDER_DATA *pProvData)
Definition: main.c:82
static const WCHAR colonCrlf[]
Definition: main.c:517
#define IDS_POLICY_QUALIFIER_ID
Definition: cryptres.h:26
DWORD WINAPI CertGetNameStringW(PCCERT_CONTEXT pCertContext, DWORD dwType, DWORD dwFlags, void *pvTypePara, LPWSTR pszNameString, DWORD cchNameString)
Definition: str.c:1228
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3454
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
PCCERT_CHAIN_CONTEXT pChainContext
Definition: wintrust.h:241
CERT_TRUST_STATUS TrustStatus
Definition: wincrypt.h:926
DWORD dwUIChoice
Definition: wintrust.h:102
#define IDS_NOTICE_REF
Definition: cryptres.h:30
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define WTD_UI_NONE
Definition: wintrust.h:84
BOOL WINAPI FormatVerisignExtension(DWORD dwCertEncodingType, DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, DWORD *pcbFormat)
Definition: main.c:777
#define szOID_MICROSOFT_Encryption_Key_Preference
Definition: main.c:1119
#define IDS_CERT_POLICY
Definition: cryptres.h:23
Definition: _hash_fun.h:40
#define memset(x, y, z)
Definition: compat.h:39
#define REG_DWORD
Definition: sdbapi.c:596
#define WTD_CHOICE_BLOB
Definition: wintrust.h:93
static char title[]
Definition: ps.c:92
int k
Definition: mpi.c:3369
Definition: dsound.c:943
#define szOID_PKIX_POLICY_QUALIFIER_CPS
Definition: wincrypt.h:3291
#define HeapFree(x, y, z)
Definition: compat.h:394
#define CRYPT_OID_ENCODE_OBJECT_FUNC
Definition: wincrypt.h:2492
HRESULT WINAPI CertTrustCleanup(CRYPT_PROVIDER_DATA *pProvData)
Definition: main.c:107
#define CERT_E_EXPIRED
Definition: winerror.h:3117
DWORD dwUnionChoice
Definition: wintrust.h:104
Definition: path.c:42
BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
Definition: main.c:26
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12