2 * Copyright 2006 Juan Lang
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 #define NONAMELESSUNION
23 #define CERT_CHAIN_PARA_HAS_EXTRA_FIELDS
24 #define CERT_REVOCATION_PARA_HAS_EXTRA_FIELDS
26 #include "wine/debug.h"
27 #include "wine/unicode.h"
28 #include "crypt32_private.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(crypt
);
31 WINE_DECLARE_DEBUG_CHANNEL(chain
);
33 #define DEFAULT_CYCLE_MODULUS 7
35 static HCERTCHAINENGINE CRYPT_defaultChainEngine
;
37 /* This represents a subset of a certificate chain engine: it doesn't include
38 * the "hOther" store described by MSDN, because I'm not sure how that's used.
39 * It also doesn't include the "hTrust" store, because I don't yet implement
40 * CTLs or complex certificate chains.
42 typedef struct _CertificateChainEngine
48 DWORD dwUrlRetrievalTimeout
;
49 DWORD MaximumCachedCertificates
;
50 DWORD CycleDetectionModulus
;
51 } CertificateChainEngine
, *PCertificateChainEngine
;
53 static inline void CRYPT_AddStoresToCollection(HCERTSTORE collection
,
54 DWORD cStores
, HCERTSTORE
*stores
)
58 for (i
= 0; i
< cStores
; i
++)
59 CertAddStoreToCollection(collection
, stores
[i
], 0, 0);
62 static inline void CRYPT_CloseStores(DWORD cStores
, HCERTSTORE
*stores
)
66 for (i
= 0; i
< cStores
; i
++)
67 CertCloseStore(stores
[i
], 0);
70 static const WCHAR rootW
[] = { 'R','o','o','t',0 };
72 static BOOL
CRYPT_CheckRestrictedRoot(HCERTSTORE store
)
78 HCERTSTORE rootStore
= CertOpenSystemStoreW(0, rootW
);
79 PCCERT_CONTEXT cert
= NULL
, check
;
84 cert
= CertEnumCertificatesInStore(store
, cert
);
89 ret
= CertGetCertificateContextProperty(cert
, CERT_HASH_PROP_ID
,
93 CRYPT_HASH_BLOB blob
= { sizeof(hash
), hash
};
95 check
= CertFindCertificateInStore(rootStore
,
96 cert
->dwCertEncodingType
, 0, CERT_FIND_SHA1_HASH
, &blob
,
101 CertFreeCertificateContext(check
);
104 } while (ret
&& cert
);
106 CertFreeCertificateContext(cert
);
107 CertCloseStore(rootStore
, 0);
112 HCERTCHAINENGINE
CRYPT_CreateChainEngine(HCERTSTORE root
,
113 PCERT_CHAIN_ENGINE_CONFIG pConfig
)
115 static const WCHAR caW
[] = { 'C','A',0 };
116 static const WCHAR myW
[] = { 'M','y',0 };
117 static const WCHAR trustW
[] = { 'T','r','u','s','t',0 };
118 PCertificateChainEngine engine
=
119 CryptMemAlloc(sizeof(CertificateChainEngine
));
123 HCERTSTORE worldStores
[4];
126 engine
->hRoot
= root
;
127 engine
->hWorld
= CertOpenStore(CERT_STORE_PROV_COLLECTION
, 0, 0,
128 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
129 worldStores
[0] = CertDuplicateStore(engine
->hRoot
);
130 worldStores
[1] = CertOpenSystemStoreW(0, caW
);
131 worldStores
[2] = CertOpenSystemStoreW(0, myW
);
132 worldStores
[3] = CertOpenSystemStoreW(0, trustW
);
133 CRYPT_AddStoresToCollection(engine
->hWorld
,
134 sizeof(worldStores
) / sizeof(worldStores
[0]), worldStores
);
135 CRYPT_AddStoresToCollection(engine
->hWorld
,
136 pConfig
->cAdditionalStore
, pConfig
->rghAdditionalStore
);
137 CRYPT_CloseStores(sizeof(worldStores
) / sizeof(worldStores
[0]),
139 engine
->dwFlags
= pConfig
->dwFlags
;
140 engine
->dwUrlRetrievalTimeout
= pConfig
->dwUrlRetrievalTimeout
;
141 engine
->MaximumCachedCertificates
=
142 pConfig
->MaximumCachedCertificates
;
143 if (pConfig
->CycleDetectionModulus
)
144 engine
->CycleDetectionModulus
= pConfig
->CycleDetectionModulus
;
146 engine
->CycleDetectionModulus
= DEFAULT_CYCLE_MODULUS
;
151 BOOL WINAPI
CertCreateCertificateChainEngine(PCERT_CHAIN_ENGINE_CONFIG pConfig
,
152 HCERTCHAINENGINE
*phChainEngine
)
156 TRACE("(%p, %p)\n", pConfig
, phChainEngine
);
158 if (pConfig
->cbSize
!= sizeof(*pConfig
))
160 SetLastError(E_INVALIDARG
);
163 *phChainEngine
= NULL
;
164 ret
= CRYPT_CheckRestrictedRoot(pConfig
->hRestrictedRoot
);
168 HCERTCHAINENGINE engine
;
170 if (pConfig
->hRestrictedRoot
)
171 root
= CertDuplicateStore(pConfig
->hRestrictedRoot
);
173 root
= CertOpenSystemStoreW(0, rootW
);
174 engine
= CRYPT_CreateChainEngine(root
, pConfig
);
177 *phChainEngine
= engine
;
186 VOID WINAPI
CertFreeCertificateChainEngine(HCERTCHAINENGINE hChainEngine
)
188 PCertificateChainEngine engine
= (PCertificateChainEngine
)hChainEngine
;
190 TRACE("(%p)\n", hChainEngine
);
192 if (engine
&& InterlockedDecrement(&engine
->ref
) == 0)
194 CertCloseStore(engine
->hWorld
, 0);
195 CertCloseStore(engine
->hRoot
, 0);
196 CryptMemFree(engine
);
200 static HCERTCHAINENGINE
CRYPT_GetDefaultChainEngine(void)
202 if (!CRYPT_defaultChainEngine
)
204 CERT_CHAIN_ENGINE_CONFIG config
= { 0 };
205 HCERTCHAINENGINE engine
;
207 config
.cbSize
= sizeof(config
);
208 CertCreateCertificateChainEngine(&config
, &engine
);
209 InterlockedCompareExchangePointer(&CRYPT_defaultChainEngine
, engine
,
211 if (CRYPT_defaultChainEngine
!= engine
)
212 CertFreeCertificateChainEngine(engine
);
214 return CRYPT_defaultChainEngine
;
217 void default_chain_engine_free(void)
219 CertFreeCertificateChainEngine(CRYPT_defaultChainEngine
);
222 typedef struct _CertificateChain
224 CERT_CHAIN_CONTEXT context
;
227 } CertificateChain
, *PCertificateChain
;
229 static inline BOOL
CRYPT_IsCertificateSelfSigned(PCCERT_CONTEXT cert
)
231 return CertCompareCertificateName(cert
->dwCertEncodingType
,
232 &cert
->pCertInfo
->Subject
, &cert
->pCertInfo
->Issuer
);
235 static void CRYPT_FreeChainElement(PCERT_CHAIN_ELEMENT element
)
237 CertFreeCertificateContext(element
->pCertContext
);
238 CryptMemFree(element
);
241 static void CRYPT_CheckSimpleChainForCycles(PCERT_SIMPLE_CHAIN chain
)
243 DWORD i
, j
, cyclicCertIndex
= 0;
245 /* O(n^2) - I don't think there's a faster way */
246 for (i
= 0; !cyclicCertIndex
&& i
< chain
->cElement
; i
++)
247 for (j
= i
+ 1; !cyclicCertIndex
&& j
< chain
->cElement
; j
++)
248 if (CertCompareCertificate(X509_ASN_ENCODING
,
249 chain
->rgpElement
[i
]->pCertContext
->pCertInfo
,
250 chain
->rgpElement
[j
]->pCertContext
->pCertInfo
))
254 chain
->rgpElement
[cyclicCertIndex
]->TrustStatus
.dwErrorStatus
255 |= CERT_TRUST_IS_CYCLIC
| CERT_TRUST_INVALID_BASIC_CONSTRAINTS
;
256 /* Release remaining certs */
257 for (i
= cyclicCertIndex
+ 1; i
< chain
->cElement
; i
++)
258 CRYPT_FreeChainElement(chain
->rgpElement
[i
]);
260 chain
->cElement
= cyclicCertIndex
+ 1;
264 /* Checks whether the chain is cyclic by examining the last element's status */
265 static inline BOOL
CRYPT_IsSimpleChainCyclic(PCERT_SIMPLE_CHAIN chain
)
268 return chain
->rgpElement
[chain
->cElement
- 1]->TrustStatus
.dwErrorStatus
269 & CERT_TRUST_IS_CYCLIC
;
274 static inline void CRYPT_CombineTrustStatus(CERT_TRUST_STATUS
*chainStatus
,
275 CERT_TRUST_STATUS
*elementStatus
)
277 /* Any error that applies to an element also applies to a chain.. */
278 chainStatus
->dwErrorStatus
|= elementStatus
->dwErrorStatus
;
279 /* but the bottom nibble of an element's info status doesn't apply to the
282 chainStatus
->dwInfoStatus
|= (elementStatus
->dwInfoStatus
& 0xfffffff0);
285 static BOOL
CRYPT_AddCertToSimpleChain(PCertificateChainEngine engine
,
286 PCERT_SIMPLE_CHAIN chain
, PCCERT_CONTEXT cert
, DWORD subjectInfoStatus
)
289 PCERT_CHAIN_ELEMENT element
= CryptMemAlloc(sizeof(CERT_CHAIN_ELEMENT
));
293 if (!chain
->cElement
)
294 chain
->rgpElement
= CryptMemAlloc(sizeof(PCERT_CHAIN_ELEMENT
));
296 chain
->rgpElement
= CryptMemRealloc(chain
->rgpElement
,
297 (chain
->cElement
+ 1) * sizeof(PCERT_CHAIN_ELEMENT
));
298 if (chain
->rgpElement
)
300 chain
->rgpElement
[chain
->cElement
++] = element
;
301 memset(element
, 0, sizeof(CERT_CHAIN_ELEMENT
));
302 element
->cbSize
= sizeof(CERT_CHAIN_ELEMENT
);
303 element
->pCertContext
= CertDuplicateCertificateContext(cert
);
304 if (chain
->cElement
> 1)
305 chain
->rgpElement
[chain
->cElement
- 2]->TrustStatus
.dwInfoStatus
307 /* FIXME: initialize the rest of element */
308 if (!(chain
->cElement
% engine
->CycleDetectionModulus
))
310 CRYPT_CheckSimpleChainForCycles(chain
);
311 /* Reinitialize the element pointer in case the chain is
312 * cyclic, in which case the chain is truncated.
314 element
= chain
->rgpElement
[chain
->cElement
- 1];
316 CRYPT_CombineTrustStatus(&chain
->TrustStatus
,
317 &element
->TrustStatus
);
321 CryptMemFree(element
);
326 static void CRYPT_FreeSimpleChain(PCERT_SIMPLE_CHAIN chain
)
330 for (i
= 0; i
< chain
->cElement
; i
++)
331 CRYPT_FreeChainElement(chain
->rgpElement
[i
]);
332 CryptMemFree(chain
->rgpElement
);
336 static void CRYPT_CheckTrustedStatus(HCERTSTORE hRoot
,
337 PCERT_CHAIN_ELEMENT rootElement
)
340 DWORD size
= sizeof(hash
);
341 CRYPT_HASH_BLOB blob
= { sizeof(hash
), hash
};
342 PCCERT_CONTEXT trustedRoot
;
344 CertGetCertificateContextProperty(rootElement
->pCertContext
,
345 CERT_HASH_PROP_ID
, hash
, &size
);
346 trustedRoot
= CertFindCertificateInStore(hRoot
,
347 rootElement
->pCertContext
->dwCertEncodingType
, 0, CERT_FIND_SHA1_HASH
,
350 rootElement
->TrustStatus
.dwErrorStatus
|=
351 CERT_TRUST_IS_UNTRUSTED_ROOT
;
353 CertFreeCertificateContext(trustedRoot
);
356 static void CRYPT_CheckRootCert(HCERTCHAINENGINE hRoot
,
357 PCERT_CHAIN_ELEMENT rootElement
)
359 PCCERT_CONTEXT root
= rootElement
->pCertContext
;
361 if (!CryptVerifyCertificateSignatureEx(0, root
->dwCertEncodingType
,
362 CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT
, (void *)root
,
363 CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT
, (void *)root
, 0, NULL
))
365 TRACE_(chain
)("Last certificate's signature is invalid\n");
366 rootElement
->TrustStatus
.dwErrorStatus
|=
367 CERT_TRUST_IS_NOT_SIGNATURE_VALID
;
369 CRYPT_CheckTrustedStatus(hRoot
, rootElement
);
372 /* Decodes a cert's basic constraints extension (either szOID_BASIC_CONSTRAINTS
373 * or szOID_BASIC_CONSTRAINTS2, whichever is present) into a
374 * CERT_BASIC_CONSTRAINTS2_INFO. If it neither extension is present, sets
375 * constraints->fCA to defaultIfNotSpecified.
376 * Returns FALSE if the extension is present but couldn't be decoded.
378 static BOOL
CRYPT_DecodeBasicConstraints(PCCERT_CONTEXT cert
,
379 CERT_BASIC_CONSTRAINTS2_INFO
*constraints
, BOOL defaultIfNotSpecified
)
382 PCERT_EXTENSION ext
= CertFindExtension(szOID_BASIC_CONSTRAINTS
,
383 cert
->pCertInfo
->cExtension
, cert
->pCertInfo
->rgExtension
);
385 constraints
->fPathLenConstraint
= FALSE
;
388 CERT_BASIC_CONSTRAINTS_INFO
*info
;
391 ret
= CryptDecodeObjectEx(X509_ASN_ENCODING
, szOID_BASIC_CONSTRAINTS
,
392 ext
->Value
.pbData
, ext
->Value
.cbData
, CRYPT_DECODE_ALLOC_FLAG
,
396 if (info
->SubjectType
.cbData
== 1)
398 info
->SubjectType
.pbData
[0] & CERT_CA_SUBJECT_FLAG
;
404 ext
= CertFindExtension(szOID_BASIC_CONSTRAINTS2
,
405 cert
->pCertInfo
->cExtension
, cert
->pCertInfo
->rgExtension
);
408 DWORD size
= sizeof(CERT_BASIC_CONSTRAINTS2_INFO
);
410 ret
= CryptDecodeObjectEx(X509_ASN_ENCODING
,
411 szOID_BASIC_CONSTRAINTS2
, ext
->Value
.pbData
, ext
->Value
.cbData
,
412 0, NULL
, constraints
, &size
);
415 constraints
->fCA
= defaultIfNotSpecified
;
420 /* Checks element's basic constraints to see if it can act as a CA, with
421 * remainingCAs CAs left in this chain. A root certificate is assumed to be
422 * allowed to be a CA whether or not the basic constraints extension is present,
423 * whereas an intermediate CA cert is not. This matches the expected usage in
424 * RFC 3280: a conforming intermediate CA MUST contain the basic constraints
425 * extension. It also appears to match Microsoft's implementation.
426 * Updates chainConstraints with the element's constraints, if:
427 * 1. chainConstraints doesn't have a path length constraint, or
428 * 2. element's path length constraint is smaller than chainConstraints's
429 * Sets *pathLengthConstraintViolated to TRUE if a path length violation
431 * Returns TRUE if the element can be a CA, and the length of the remaining
434 static BOOL
CRYPT_CheckBasicConstraintsForCA(PCCERT_CONTEXT cert
,
435 CERT_BASIC_CONSTRAINTS2_INFO
*chainConstraints
, DWORD remainingCAs
,
436 BOOL isRoot
, BOOL
*pathLengthConstraintViolated
)
438 BOOL validBasicConstraints
;
439 CERT_BASIC_CONSTRAINTS2_INFO constraints
;
441 if ((validBasicConstraints
= CRYPT_DecodeBasicConstraints(cert
,
442 &constraints
, isRoot
)))
444 if (!constraints
.fCA
)
446 TRACE_(chain
)("chain element %d can't be a CA\n", remainingCAs
+ 1);
447 validBasicConstraints
= FALSE
;
449 else if (constraints
.fPathLenConstraint
)
451 /* If the element has path length constraints, they apply to the
452 * entire remaining chain.
454 if (!chainConstraints
->fPathLenConstraint
||
455 constraints
.dwPathLenConstraint
<
456 chainConstraints
->dwPathLenConstraint
)
458 TRACE_(chain
)("setting path length constraint to %d\n",
459 chainConstraints
->dwPathLenConstraint
);
460 chainConstraints
->fPathLenConstraint
= TRUE
;
461 chainConstraints
->dwPathLenConstraint
=
462 constraints
.dwPathLenConstraint
;
466 if (chainConstraints
->fPathLenConstraint
&&
467 remainingCAs
> chainConstraints
->dwPathLenConstraint
)
469 TRACE_(chain
)("remaining CAs %d exceed max path length %d\n",
470 remainingCAs
, chainConstraints
->dwPathLenConstraint
);
471 validBasicConstraints
= FALSE
;
472 *pathLengthConstraintViolated
= TRUE
;
474 return validBasicConstraints
;
477 static BOOL
url_matches(LPCWSTR constraint
, LPCWSTR name
,
478 DWORD
*trustErrorStatus
)
482 TRACE("%s, %s\n", debugstr_w(constraint
), debugstr_w(name
));
485 *trustErrorStatus
|= CERT_TRUST_INVALID_NAME_CONSTRAINTS
;
488 else if (constraint
[0] == '.')
490 if (lstrlenW(name
) > lstrlenW(constraint
))
491 match
= !lstrcmpiW(name
+ lstrlenW(name
) - lstrlenW(constraint
),
495 match
= !lstrcmpiW(constraint
, name
);
499 static BOOL
rfc822_name_matches(LPCWSTR constraint
, LPCWSTR name
,
500 DWORD
*trustErrorStatus
)
505 TRACE("%s, %s\n", debugstr_w(constraint
), debugstr_w(name
));
508 *trustErrorStatus
|= CERT_TRUST_INVALID_NAME_CONSTRAINTS
;
511 else if ((at
= strchrW(constraint
, '@')))
512 match
= !lstrcmpiW(constraint
, name
);
515 if ((at
= strchrW(name
, '@')))
516 match
= url_matches(constraint
, at
+ 1, trustErrorStatus
);
518 match
= !lstrcmpiW(constraint
, name
);
523 static BOOL
dns_name_matches(LPCWSTR constraint
, LPCWSTR name
,
524 DWORD
*trustErrorStatus
)
528 TRACE("%s, %s\n", debugstr_w(constraint
), debugstr_w(name
));
531 *trustErrorStatus
|= CERT_TRUST_INVALID_NAME_CONSTRAINTS
;
534 else if (lstrlenW(name
) >= lstrlenW(constraint
))
535 match
= !lstrcmpiW(name
+ lstrlenW(name
) - lstrlenW(constraint
),
537 /* else: name is too short, no match */
542 static BOOL
ip_address_matches(const CRYPT_DATA_BLOB
*constraint
,
543 const CRYPT_DATA_BLOB
*name
, DWORD
*trustErrorStatus
)
547 TRACE("(%d, %p), (%d, %p)\n", constraint
->cbData
, constraint
->pbData
,
548 name
->cbData
, name
->pbData
);
550 if (constraint
->cbData
!= sizeof(DWORD
) * 2)
551 *trustErrorStatus
|= CERT_TRUST_INVALID_NAME_CONSTRAINTS
;
552 else if (name
->cbData
== sizeof(DWORD
))
554 DWORD subnet
, mask
, addr
;
556 memcpy(&subnet
, constraint
->pbData
, sizeof(subnet
));
557 memcpy(&mask
, constraint
->pbData
+ sizeof(subnet
), sizeof(mask
));
558 memcpy(&addr
, name
->pbData
, sizeof(addr
));
559 /* These are really in big-endian order, but for equality matching we
560 * don't need to swap to host order
562 match
= (subnet
& mask
) == (addr
& mask
);
564 /* else: name is wrong size, no match */
569 static void CRYPT_FindMatchingNameEntry(const CERT_ALT_NAME_ENTRY
*constraint
,
570 const CERT_ALT_NAME_INFO
*subjectName
, DWORD
*trustErrorStatus
,
571 DWORD errorIfFound
, DWORD errorIfNotFound
)
576 for (i
= 0; i
< subjectName
->cAltEntry
; i
++)
578 if (subjectName
->rgAltEntry
[i
].dwAltNameChoice
==
579 constraint
->dwAltNameChoice
)
581 switch (constraint
->dwAltNameChoice
)
583 case CERT_ALT_NAME_RFC822_NAME
:
584 match
= rfc822_name_matches(constraint
->u
.pwszURL
,
585 subjectName
->rgAltEntry
[i
].u
.pwszURL
, trustErrorStatus
);
587 case CERT_ALT_NAME_DNS_NAME
:
588 match
= dns_name_matches(constraint
->u
.pwszURL
,
589 subjectName
->rgAltEntry
[i
].u
.pwszURL
, trustErrorStatus
);
591 case CERT_ALT_NAME_URL
:
592 match
= url_matches(constraint
->u
.pwszURL
,
593 subjectName
->rgAltEntry
[i
].u
.pwszURL
, trustErrorStatus
);
595 case CERT_ALT_NAME_IP_ADDRESS
:
596 match
= ip_address_matches(&constraint
->u
.IPAddress
,
597 &subjectName
->rgAltEntry
[i
].u
.IPAddress
, trustErrorStatus
);
599 case CERT_ALT_NAME_DIRECTORY_NAME
:
601 ERR("name choice %d unsupported in this context\n",
602 constraint
->dwAltNameChoice
);
604 CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT
;
608 *trustErrorStatus
|= match
? errorIfFound
: errorIfNotFound
;
611 static void CRYPT_CheckNameConstraints(
612 const CERT_NAME_CONSTRAINTS_INFO
*nameConstraints
, const CERT_INFO
*cert
,
613 DWORD
*trustErrorStatus
)
615 /* If there aren't any existing constraints, don't bother checking */
616 if (nameConstraints
->cPermittedSubtree
|| nameConstraints
->cExcludedSubtree
)
620 if ((ext
= CertFindExtension(szOID_SUBJECT_ALT_NAME
, cert
->cExtension
,
623 CERT_ALT_NAME_INFO
*subjectName
;
626 if (CryptDecodeObjectEx(X509_ASN_ENCODING
, X509_ALTERNATE_NAME
,
627 ext
->Value
.pbData
, ext
->Value
.cbData
,
628 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_NOCOPY_FLAG
, NULL
,
629 &subjectName
, &size
))
633 for (i
= 0; i
< nameConstraints
->cExcludedSubtree
; i
++)
634 CRYPT_FindMatchingNameEntry(
635 &nameConstraints
->rgExcludedSubtree
[i
].Base
, subjectName
,
637 CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT
, 0);
638 for (i
= 0; i
< nameConstraints
->cPermittedSubtree
; i
++)
639 CRYPT_FindMatchingNameEntry(
640 &nameConstraints
->rgPermittedSubtree
[i
].Base
, subjectName
,
642 0, CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT
);
643 LocalFree(subjectName
);
648 if (nameConstraints
->cPermittedSubtree
)
650 CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT
;
651 if (nameConstraints
->cExcludedSubtree
)
653 CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT
;
658 /* Gets cert's name constraints, if any. Free with LocalFree. */
659 static CERT_NAME_CONSTRAINTS_INFO
*CRYPT_GetNameConstraints(CERT_INFO
*cert
)
661 CERT_NAME_CONSTRAINTS_INFO
*info
= NULL
;
665 if ((ext
= CertFindExtension(szOID_NAME_CONSTRAINTS
, cert
->cExtension
,
670 CryptDecodeObjectEx(X509_ASN_ENCODING
, X509_NAME_CONSTRAINTS
,
671 ext
->Value
.pbData
, ext
->Value
.cbData
,
672 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_NOCOPY_FLAG
, NULL
, &info
,
678 static void CRYPT_CheckChainNameConstraints(PCERT_SIMPLE_CHAIN chain
)
682 /* Microsoft's implementation appears to violate RFC 3280: according to
683 * MSDN, the various CERT_TRUST_*_NAME_CONSTRAINT errors are set if a CA's
684 * name constraint is violated in the end cert. According to RFC 3280,
685 * the constraints should be checked against every subsequent certificate
686 * in the chain, not just the end cert.
687 * Microsoft's implementation also sets the name constraint errors on the
688 * certs whose constraints were violated, not on the certs that violated
690 * In order to be error-compatible with Microsoft's implementation, while
691 * still adhering to RFC 3280, I use a O(n ^ 2) algorithm to check name
694 for (i
= chain
->cElement
- 1; i
> 0; i
--)
696 CERT_NAME_CONSTRAINTS_INFO
*nameConstraints
;
698 if ((nameConstraints
= CRYPT_GetNameConstraints(
699 chain
->rgpElement
[i
]->pCertContext
->pCertInfo
)))
701 for (j
= i
- 1; j
>= 0; j
--)
703 DWORD errorStatus
= 0;
705 /* According to RFC 3280, self-signed certs don't have name
706 * constraints checked unless they're the end cert.
708 if (j
== 0 || !CRYPT_IsCertificateSelfSigned(
709 chain
->rgpElement
[j
]->pCertContext
))
711 CRYPT_CheckNameConstraints(nameConstraints
,
712 chain
->rgpElement
[i
]->pCertContext
->pCertInfo
,
714 chain
->rgpElement
[i
]->TrustStatus
.dwErrorStatus
|=
718 LocalFree(nameConstraints
);
723 static void dump_basic_constraints(PCERT_EXTENSION ext
)
725 CERT_BASIC_CONSTRAINTS_INFO
*info
;
728 if (CryptDecodeObjectEx(X509_ASN_ENCODING
, szOID_BASIC_CONSTRAINTS
,
729 ext
->Value
.pbData
, ext
->Value
.cbData
, CRYPT_DECODE_ALLOC_FLAG
,
732 TRACE_(chain
)("SubjectType: %02x\n", info
->SubjectType
.pbData
[0]);
733 TRACE_(chain
)("%s path length constraint\n",
734 info
->fPathLenConstraint
? "has" : "doesn't have");
735 TRACE_(chain
)("path length=%d\n", info
->dwPathLenConstraint
);
740 static void dump_basic_constraints2(PCERT_EXTENSION ext
)
742 CERT_BASIC_CONSTRAINTS2_INFO constraints
;
743 DWORD size
= sizeof(CERT_BASIC_CONSTRAINTS2_INFO
);
745 if (CryptDecodeObjectEx(X509_ASN_ENCODING
,
746 szOID_BASIC_CONSTRAINTS2
, ext
->Value
.pbData
, ext
->Value
.cbData
,
747 0, NULL
, &constraints
, &size
))
749 TRACE_(chain
)("basic constraints:\n");
750 TRACE_(chain
)("can%s be a CA\n", constraints
.fCA
? "" : "not");
751 TRACE_(chain
)("%s path length constraint\n",
752 constraints
.fPathLenConstraint
? "has" : "doesn't have");
753 TRACE_(chain
)("path length=%d\n", constraints
.dwPathLenConstraint
);
757 static void dump_extension(PCERT_EXTENSION ext
)
759 TRACE_(chain
)("%s (%scritical)\n", debugstr_a(ext
->pszObjId
),
760 ext
->fCritical
? "" : "not ");
761 if (!strcmp(ext
->pszObjId
, szOID_BASIC_CONSTRAINTS
))
762 dump_basic_constraints(ext
);
763 else if (!strcmp(ext
->pszObjId
, szOID_BASIC_CONSTRAINTS2
))
764 dump_basic_constraints2(ext
);
767 static LPCWSTR
filetime_to_str(const FILETIME
*time
)
769 static WCHAR date
[80];
770 WCHAR dateFmt
[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
773 if (!time
) return NULL
;
775 GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT
, LOCALE_SSHORTDATE
, dateFmt
,
776 sizeof(dateFmt
) / sizeof(dateFmt
[0]));
777 FileTimeToSystemTime(time
, &sysTime
);
778 GetDateFormatW(LOCALE_SYSTEM_DEFAULT
, 0, &sysTime
, dateFmt
, date
,
779 sizeof(date
) / sizeof(date
[0]));
783 static void dump_element(PCCERT_CONTEXT cert
)
788 TRACE_(chain
)("%p\n", cert
);
789 len
= CertGetNameStringW(cert
, CERT_NAME_SIMPLE_DISPLAY_TYPE
,
790 CERT_NAME_ISSUER_FLAG
, NULL
, NULL
, 0);
791 name
= CryptMemAlloc(len
* sizeof(WCHAR
));
794 CertGetNameStringW(cert
, CERT_NAME_SIMPLE_DISPLAY_TYPE
,
795 CERT_NAME_ISSUER_FLAG
, NULL
, name
, len
);
796 TRACE_(chain
)("issued by %s\n", debugstr_w(name
));
799 len
= CertGetNameStringW(cert
, CERT_NAME_SIMPLE_DISPLAY_TYPE
, 0, NULL
,
801 name
= CryptMemAlloc(len
* sizeof(WCHAR
));
804 CertGetNameStringW(cert
, CERT_NAME_SIMPLE_DISPLAY_TYPE
, 0, NULL
,
806 TRACE_(chain
)("issued to %s\n", debugstr_w(name
));
809 TRACE_(chain
)("valid from %s to %s\n",
810 debugstr_w(filetime_to_str(&cert
->pCertInfo
->NotBefore
)),
811 debugstr_w(filetime_to_str(&cert
->pCertInfo
->NotAfter
)));
812 TRACE_(chain
)("%d extensions\n", cert
->pCertInfo
->cExtension
);
813 for (i
= 0; i
< cert
->pCertInfo
->cExtension
; i
++)
814 dump_extension(&cert
->pCertInfo
->rgExtension
[i
]);
817 static void CRYPT_CheckSimpleChain(PCertificateChainEngine engine
,
818 PCERT_SIMPLE_CHAIN chain
, LPFILETIME time
)
820 PCERT_CHAIN_ELEMENT rootElement
= chain
->rgpElement
[chain
->cElement
- 1];
822 BOOL pathLengthConstraintViolated
= FALSE
;
823 CERT_BASIC_CONSTRAINTS2_INFO constraints
= { TRUE
, FALSE
, 0 };
825 TRACE_(chain
)("checking chain with %d elements for time %s\n",
826 chain
->cElement
, debugstr_w(filetime_to_str(time
)));
827 for (i
= chain
->cElement
- 1; i
>= 0; i
--)
830 dump_element(chain
->rgpElement
[i
]->pCertContext
);
831 if (CertVerifyTimeValidity(time
,
832 chain
->rgpElement
[i
]->pCertContext
->pCertInfo
) != 0)
833 chain
->rgpElement
[i
]->TrustStatus
.dwErrorStatus
|=
834 CERT_TRUST_IS_NOT_TIME_VALID
;
839 if (i
== chain
->cElement
- 1)
840 isRoot
= CRYPT_IsCertificateSelfSigned(
841 chain
->rgpElement
[i
]->pCertContext
);
844 /* Check the signature of the cert this issued */
845 if (!CryptVerifyCertificateSignatureEx(0, X509_ASN_ENCODING
,
846 CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT
,
847 (void *)chain
->rgpElement
[i
- 1]->pCertContext
,
848 CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT
,
849 (void *)chain
->rgpElement
[i
]->pCertContext
, 0, NULL
))
850 chain
->rgpElement
[i
- 1]->TrustStatus
.dwErrorStatus
|=
851 CERT_TRUST_IS_NOT_SIGNATURE_VALID
;
852 /* Once a path length constraint has been violated, every remaining
853 * CA cert's basic constraints is considered invalid.
855 if (pathLengthConstraintViolated
)
856 chain
->rgpElement
[i
]->TrustStatus
.dwErrorStatus
|=
857 CERT_TRUST_INVALID_BASIC_CONSTRAINTS
;
858 else if (!CRYPT_CheckBasicConstraintsForCA(
859 chain
->rgpElement
[i
]->pCertContext
, &constraints
, i
- 1,
860 isRoot
, &pathLengthConstraintViolated
))
861 chain
->rgpElement
[i
]->TrustStatus
.dwErrorStatus
|=
862 CERT_TRUST_INVALID_BASIC_CONSTRAINTS
;
863 else if (constraints
.fPathLenConstraint
&&
864 constraints
.dwPathLenConstraint
)
866 /* This one's valid - decrement max length */
867 constraints
.dwPathLenConstraint
--;
870 if (CRYPT_IsSimpleChainCyclic(chain
))
872 /* If the chain is cyclic, then the path length constraints
873 * are violated, because the chain is infinitely long.
875 pathLengthConstraintViolated
= TRUE
;
876 chain
->TrustStatus
.dwErrorStatus
|=
877 CERT_TRUST_IS_PARTIAL_CHAIN
|
878 CERT_TRUST_INVALID_BASIC_CONSTRAINTS
;
880 /* FIXME: check valid usages */
881 CRYPT_CombineTrustStatus(&chain
->TrustStatus
,
882 &chain
->rgpElement
[i
]->TrustStatus
);
884 CRYPT_CheckChainNameConstraints(chain
);
885 if (CRYPT_IsCertificateSelfSigned(rootElement
->pCertContext
))
887 rootElement
->TrustStatus
.dwInfoStatus
|=
888 CERT_TRUST_IS_SELF_SIGNED
| CERT_TRUST_HAS_NAME_MATCH_ISSUER
;
889 CRYPT_CheckRootCert(engine
->hRoot
, rootElement
);
891 CRYPT_CombineTrustStatus(&chain
->TrustStatus
, &rootElement
->TrustStatus
);
894 static PCCERT_CONTEXT
CRYPT_GetIssuer(HCERTSTORE store
, PCCERT_CONTEXT subject
,
895 PCCERT_CONTEXT prevIssuer
, DWORD
*infoStatus
)
897 PCCERT_CONTEXT issuer
= NULL
;
902 if ((ext
= CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER
,
903 subject
->pCertInfo
->cExtension
, subject
->pCertInfo
->rgExtension
)))
905 CERT_AUTHORITY_KEY_ID_INFO
*info
;
908 ret
= CryptDecodeObjectEx(subject
->dwCertEncodingType
,
909 X509_AUTHORITY_KEY_ID
, ext
->Value
.pbData
, ext
->Value
.cbData
,
910 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_NOCOPY_FLAG
, NULL
,
916 if (info
->CertIssuer
.cbData
&& info
->CertSerialNumber
.cbData
)
918 id
.dwIdChoice
= CERT_ID_ISSUER_SERIAL_NUMBER
;
919 memcpy(&id
.u
.IssuerSerialNumber
.Issuer
, &info
->CertIssuer
,
920 sizeof(CERT_NAME_BLOB
));
921 memcpy(&id
.u
.IssuerSerialNumber
.SerialNumber
,
922 &info
->CertSerialNumber
, sizeof(CRYPT_INTEGER_BLOB
));
923 issuer
= CertFindCertificateInStore(store
,
924 subject
->dwCertEncodingType
, 0, CERT_FIND_CERT_ID
, &id
,
927 *infoStatus
= CERT_TRUST_HAS_EXACT_MATCH_ISSUER
;
929 else if (info
->KeyId
.cbData
)
931 id
.dwIdChoice
= CERT_ID_KEY_IDENTIFIER
;
932 memcpy(&id
.u
.KeyId
, &info
->KeyId
, sizeof(CRYPT_HASH_BLOB
));
933 issuer
= CertFindCertificateInStore(store
,
934 subject
->dwCertEncodingType
, 0, CERT_FIND_CERT_ID
, &id
,
937 *infoStatus
= CERT_TRUST_HAS_KEY_MATCH_ISSUER
;
942 else if ((ext
= CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER2
,
943 subject
->pCertInfo
->cExtension
, subject
->pCertInfo
->rgExtension
)))
945 CERT_AUTHORITY_KEY_ID2_INFO
*info
;
948 ret
= CryptDecodeObjectEx(subject
->dwCertEncodingType
,
949 X509_AUTHORITY_KEY_ID2
, ext
->Value
.pbData
, ext
->Value
.cbData
,
950 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_NOCOPY_FLAG
, NULL
,
956 if (info
->AuthorityCertIssuer
.cAltEntry
&&
957 info
->AuthorityCertSerialNumber
.cbData
)
959 PCERT_ALT_NAME_ENTRY directoryName
= NULL
;
962 for (i
= 0; !directoryName
&&
963 i
< info
->AuthorityCertIssuer
.cAltEntry
; i
++)
964 if (info
->AuthorityCertIssuer
.rgAltEntry
[i
].dwAltNameChoice
965 == CERT_ALT_NAME_DIRECTORY_NAME
)
967 &info
->AuthorityCertIssuer
.rgAltEntry
[i
];
970 id
.dwIdChoice
= CERT_ID_ISSUER_SERIAL_NUMBER
;
971 memcpy(&id
.u
.IssuerSerialNumber
.Issuer
,
972 &directoryName
->u
.DirectoryName
, sizeof(CERT_NAME_BLOB
));
973 memcpy(&id
.u
.IssuerSerialNumber
.SerialNumber
,
974 &info
->AuthorityCertSerialNumber
,
975 sizeof(CRYPT_INTEGER_BLOB
));
976 issuer
= CertFindCertificateInStore(store
,
977 subject
->dwCertEncodingType
, 0, CERT_FIND_CERT_ID
, &id
,
980 *infoStatus
= CERT_TRUST_HAS_EXACT_MATCH_ISSUER
;
983 FIXME("no supported name type in authority key id2\n");
985 else if (info
->KeyId
.cbData
)
987 id
.dwIdChoice
= CERT_ID_KEY_IDENTIFIER
;
988 memcpy(&id
.u
.KeyId
, &info
->KeyId
, sizeof(CRYPT_HASH_BLOB
));
989 issuer
= CertFindCertificateInStore(store
,
990 subject
->dwCertEncodingType
, 0, CERT_FIND_CERT_ID
, &id
,
993 *infoStatus
= CERT_TRUST_HAS_KEY_MATCH_ISSUER
;
1000 issuer
= CertFindCertificateInStore(store
,
1001 subject
->dwCertEncodingType
, 0, CERT_FIND_SUBJECT_NAME
,
1002 &subject
->pCertInfo
->Issuer
, prevIssuer
);
1003 *infoStatus
= CERT_TRUST_HAS_NAME_MATCH_ISSUER
;
1008 /* Builds a simple chain by finding an issuer for the last cert in the chain,
1009 * until reaching a self-signed cert, or until no issuer can be found.
1011 static BOOL
CRYPT_BuildSimpleChain(PCertificateChainEngine engine
,
1012 HCERTSTORE world
, PCERT_SIMPLE_CHAIN chain
)
1015 PCCERT_CONTEXT cert
= chain
->rgpElement
[chain
->cElement
- 1]->pCertContext
;
1017 while (ret
&& !CRYPT_IsSimpleChainCyclic(chain
) &&
1018 !CRYPT_IsCertificateSelfSigned(cert
))
1020 PCCERT_CONTEXT issuer
= CRYPT_GetIssuer(world
, cert
, NULL
,
1021 &chain
->rgpElement
[chain
->cElement
- 1]->TrustStatus
.dwInfoStatus
);
1025 ret
= CRYPT_AddCertToSimpleChain(engine
, chain
, issuer
,
1026 chain
->rgpElement
[chain
->cElement
- 1]->TrustStatus
.dwInfoStatus
);
1027 /* CRYPT_AddCertToSimpleChain add-ref's the issuer, so free it to
1028 * close the enumeration that found it
1030 CertFreeCertificateContext(issuer
);
1035 TRACE_(chain
)("Couldn't find issuer, halting chain creation\n");
1036 chain
->TrustStatus
.dwErrorStatus
|= CERT_TRUST_IS_PARTIAL_CHAIN
;
1043 static BOOL
CRYPT_GetSimpleChainForCert(PCertificateChainEngine engine
,
1044 HCERTSTORE world
, PCCERT_CONTEXT cert
, LPFILETIME pTime
,
1045 PCERT_SIMPLE_CHAIN
*ppChain
)
1048 PCERT_SIMPLE_CHAIN chain
;
1050 TRACE("(%p, %p, %p, %p)\n", engine
, world
, cert
, pTime
);
1052 chain
= CryptMemAlloc(sizeof(CERT_SIMPLE_CHAIN
));
1055 memset(chain
, 0, sizeof(CERT_SIMPLE_CHAIN
));
1056 chain
->cbSize
= sizeof(CERT_SIMPLE_CHAIN
);
1057 ret
= CRYPT_AddCertToSimpleChain(engine
, chain
, cert
, 0);
1060 ret
= CRYPT_BuildSimpleChain(engine
, world
, chain
);
1062 CRYPT_CheckSimpleChain(engine
, chain
, pTime
);
1066 CRYPT_FreeSimpleChain(chain
);
1074 static BOOL
CRYPT_BuildCandidateChainFromCert(HCERTCHAINENGINE hChainEngine
,
1075 PCCERT_CONTEXT cert
, LPFILETIME pTime
, HCERTSTORE hAdditionalStore
,
1076 PCertificateChain
*ppChain
)
1078 PCertificateChainEngine engine
= (PCertificateChainEngine
)hChainEngine
;
1079 PCERT_SIMPLE_CHAIN simpleChain
= NULL
;
1083 world
= CertOpenStore(CERT_STORE_PROV_COLLECTION
, 0, 0,
1084 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
1085 CertAddStoreToCollection(world
, engine
->hWorld
, 0, 0);
1086 if (hAdditionalStore
)
1087 CertAddStoreToCollection(world
, hAdditionalStore
, 0, 0);
1088 /* FIXME: only simple chains are supported for now, as CTLs aren't
1091 if ((ret
= CRYPT_GetSimpleChainForCert(engine
, world
, cert
, pTime
,
1094 PCertificateChain chain
= CryptMemAlloc(sizeof(CertificateChain
));
1099 chain
->world
= world
;
1100 chain
->context
.cbSize
= sizeof(CERT_CHAIN_CONTEXT
);
1101 chain
->context
.TrustStatus
= simpleChain
->TrustStatus
;
1102 chain
->context
.cChain
= 1;
1103 chain
->context
.rgpChain
= CryptMemAlloc(sizeof(PCERT_SIMPLE_CHAIN
));
1104 chain
->context
.rgpChain
[0] = simpleChain
;
1105 chain
->context
.cLowerQualityChainContext
= 0;
1106 chain
->context
.rgpLowerQualityChainContext
= NULL
;
1107 chain
->context
.fHasRevocationFreshnessTime
= FALSE
;
1108 chain
->context
.dwRevocationFreshnessTime
= 0;
1117 /* Makes and returns a copy of chain, up to and including element iElement. */
1118 static PCERT_SIMPLE_CHAIN
CRYPT_CopySimpleChainToElement(
1119 PCERT_SIMPLE_CHAIN chain
, DWORD iElement
)
1121 PCERT_SIMPLE_CHAIN copy
= CryptMemAlloc(sizeof(CERT_SIMPLE_CHAIN
));
1125 memset(copy
, 0, sizeof(CERT_SIMPLE_CHAIN
));
1126 copy
->cbSize
= sizeof(CERT_SIMPLE_CHAIN
);
1128 CryptMemAlloc((iElement
+ 1) * sizeof(PCERT_CHAIN_ELEMENT
));
1129 if (copy
->rgpElement
)
1134 memset(copy
->rgpElement
, 0,
1135 (iElement
+ 1) * sizeof(PCERT_CHAIN_ELEMENT
));
1136 for (i
= 0; ret
&& i
<= iElement
; i
++)
1138 PCERT_CHAIN_ELEMENT element
=
1139 CryptMemAlloc(sizeof(CERT_CHAIN_ELEMENT
));
1143 *element
= *chain
->rgpElement
[i
];
1144 element
->pCertContext
= CertDuplicateCertificateContext(
1145 chain
->rgpElement
[i
]->pCertContext
);
1146 /* Reset the trust status of the copied element, it'll get
1147 * rechecked after the new chain is done.
1149 memset(&element
->TrustStatus
, 0, sizeof(CERT_TRUST_STATUS
));
1150 copy
->rgpElement
[copy
->cElement
++] = element
;
1157 for (i
= 0; i
<= iElement
; i
++)
1158 CryptMemFree(copy
->rgpElement
[i
]);
1159 CryptMemFree(copy
->rgpElement
);
1173 static void CRYPT_FreeLowerQualityChains(PCertificateChain chain
)
1177 for (i
= 0; i
< chain
->context
.cLowerQualityChainContext
; i
++)
1178 CertFreeCertificateChain(chain
->context
.rgpLowerQualityChainContext
[i
]);
1179 CryptMemFree(chain
->context
.rgpLowerQualityChainContext
);
1180 chain
->context
.cLowerQualityChainContext
= 0;
1181 chain
->context
.rgpLowerQualityChainContext
= NULL
;
1184 static void CRYPT_FreeChainContext(PCertificateChain chain
)
1188 CRYPT_FreeLowerQualityChains(chain
);
1189 for (i
= 0; i
< chain
->context
.cChain
; i
++)
1190 CRYPT_FreeSimpleChain(chain
->context
.rgpChain
[i
]);
1191 CryptMemFree(chain
->context
.rgpChain
);
1192 CertCloseStore(chain
->world
, 0);
1193 CryptMemFree(chain
);
1196 /* Makes and returns a copy of chain, up to and including element iElement of
1197 * simple chain iChain.
1199 static PCertificateChain
CRYPT_CopyChainToElement(PCertificateChain chain
,
1200 DWORD iChain
, DWORD iElement
)
1202 PCertificateChain copy
= CryptMemAlloc(sizeof(CertificateChain
));
1207 copy
->world
= CertDuplicateStore(chain
->world
);
1208 copy
->context
.cbSize
= sizeof(CERT_CHAIN_CONTEXT
);
1209 /* Leave the trust status of the copied chain unset, it'll get
1210 * rechecked after the new chain is done.
1212 memset(©
->context
.TrustStatus
, 0, sizeof(CERT_TRUST_STATUS
));
1213 copy
->context
.cLowerQualityChainContext
= 0;
1214 copy
->context
.rgpLowerQualityChainContext
= NULL
;
1215 copy
->context
.fHasRevocationFreshnessTime
= FALSE
;
1216 copy
->context
.dwRevocationFreshnessTime
= 0;
1217 copy
->context
.rgpChain
= CryptMemAlloc(
1218 (iChain
+ 1) * sizeof(PCERT_SIMPLE_CHAIN
));
1219 if (copy
->context
.rgpChain
)
1224 memset(copy
->context
.rgpChain
, 0,
1225 (iChain
+ 1) * sizeof(PCERT_SIMPLE_CHAIN
));
1228 for (i
= 0; ret
&& iChain
&& i
< iChain
- 1; i
++)
1230 copy
->context
.rgpChain
[i
] =
1231 CRYPT_CopySimpleChainToElement(chain
->context
.rgpChain
[i
],
1232 chain
->context
.rgpChain
[i
]->cElement
- 1);
1233 if (!copy
->context
.rgpChain
[i
])
1241 copy
->context
.rgpChain
[i
] =
1242 CRYPT_CopySimpleChainToElement(chain
->context
.rgpChain
[i
],
1244 if (!copy
->context
.rgpChain
[i
])
1249 CRYPT_FreeChainContext(copy
);
1253 copy
->context
.cChain
= iChain
+ 1;
1264 static PCertificateChain
CRYPT_BuildAlternateContextFromChain(
1265 HCERTCHAINENGINE hChainEngine
, LPFILETIME pTime
, HCERTSTORE hAdditionalStore
,
1266 PCertificateChain chain
)
1268 PCertificateChainEngine engine
= (PCertificateChainEngine
)hChainEngine
;
1269 PCertificateChain alternate
;
1271 TRACE("(%p, %p, %p, %p)\n", hChainEngine
, pTime
, hAdditionalStore
, chain
);
1273 /* Always start with the last "lower quality" chain to ensure a consistent
1274 * order of alternate creation:
1276 if (chain
->context
.cLowerQualityChainContext
)
1277 chain
= (PCertificateChain
)chain
->context
.rgpLowerQualityChainContext
[
1278 chain
->context
.cLowerQualityChainContext
- 1];
1279 /* A chain with only one element can't have any alternates */
1280 if (chain
->context
.cChain
<= 1 && chain
->context
.rgpChain
[0]->cElement
<= 1)
1284 DWORD i
, j
, infoStatus
;
1285 PCCERT_CONTEXT alternateIssuer
= NULL
;
1288 for (i
= 0; !alternateIssuer
&& i
< chain
->context
.cChain
; i
++)
1289 for (j
= 0; !alternateIssuer
&&
1290 j
< chain
->context
.rgpChain
[i
]->cElement
- 1; j
++)
1292 PCCERT_CONTEXT subject
=
1293 chain
->context
.rgpChain
[i
]->rgpElement
[j
]->pCertContext
;
1294 PCCERT_CONTEXT prevIssuer
= CertDuplicateCertificateContext(
1295 chain
->context
.rgpChain
[i
]->rgpElement
[j
+ 1]->pCertContext
);
1297 alternateIssuer
= CRYPT_GetIssuer(prevIssuer
->hCertStore
,
1298 subject
, prevIssuer
, &infoStatus
);
1300 if (alternateIssuer
)
1304 alternate
= CRYPT_CopyChainToElement(chain
, i
, j
);
1307 BOOL ret
= CRYPT_AddCertToSimpleChain(engine
,
1308 alternate
->context
.rgpChain
[i
], alternateIssuer
, infoStatus
);
1310 /* CRYPT_AddCertToSimpleChain add-ref's the issuer, so free it
1311 * to close the enumeration that found it
1313 CertFreeCertificateContext(alternateIssuer
);
1316 ret
= CRYPT_BuildSimpleChain(engine
, alternate
->world
,
1317 alternate
->context
.rgpChain
[i
]);
1319 CRYPT_CheckSimpleChain(engine
,
1320 alternate
->context
.rgpChain
[i
], pTime
);
1321 CRYPT_CombineTrustStatus(&alternate
->context
.TrustStatus
,
1322 &alternate
->context
.rgpChain
[i
]->TrustStatus
);
1326 CRYPT_FreeChainContext(alternate
);
1332 TRACE("%p\n", alternate
);
1336 #define CHAIN_QUALITY_SIGNATURE_VALID 8
1337 #define CHAIN_QUALITY_TIME_VALID 4
1338 #define CHAIN_QUALITY_COMPLETE_CHAIN 2
1339 #define CHAIN_QUALITY_TRUSTED_ROOT 1
1341 #define CHAIN_QUALITY_HIGHEST \
1342 CHAIN_QUALITY_SIGNATURE_VALID | CHAIN_QUALITY_TIME_VALID | \
1343 CHAIN_QUALITY_COMPLETE_CHAIN | CHAIN_QUALITY_TRUSTED_ROOT
1345 #define IS_TRUST_ERROR_SET(TrustStatus, bits) \
1346 (TrustStatus)->dwErrorStatus & (bits)
1348 static DWORD
CRYPT_ChainQuality(PCertificateChain chain
)
1350 DWORD quality
= CHAIN_QUALITY_HIGHEST
;
1352 if (IS_TRUST_ERROR_SET(&chain
->context
.TrustStatus
,
1353 CERT_TRUST_IS_UNTRUSTED_ROOT
))
1354 quality
&= ~CHAIN_QUALITY_TRUSTED_ROOT
;
1355 if (IS_TRUST_ERROR_SET(&chain
->context
.TrustStatus
,
1356 CERT_TRUST_IS_PARTIAL_CHAIN
))
1357 if (chain
->context
.TrustStatus
.dwErrorStatus
& CERT_TRUST_IS_PARTIAL_CHAIN
)
1358 quality
&= ~CHAIN_QUALITY_COMPLETE_CHAIN
;
1359 if (IS_TRUST_ERROR_SET(&chain
->context
.TrustStatus
,
1360 CERT_TRUST_IS_NOT_TIME_VALID
| CERT_TRUST_IS_NOT_TIME_NESTED
))
1361 quality
&= ~CHAIN_QUALITY_TIME_VALID
;
1362 if (IS_TRUST_ERROR_SET(&chain
->context
.TrustStatus
,
1363 CERT_TRUST_IS_NOT_SIGNATURE_VALID
))
1364 quality
&= ~CHAIN_QUALITY_SIGNATURE_VALID
;
1368 /* Chooses the highest quality chain among chain and its "lower quality"
1369 * alternate chains. Returns the highest quality chain, with all other
1370 * chains as lower quality chains of it.
1372 static PCertificateChain
CRYPT_ChooseHighestQualityChain(
1373 PCertificateChain chain
)
1377 /* There are always only two chains being considered: chain, and an
1378 * alternate at chain->rgpLowerQualityChainContext[i]. If the alternate
1379 * has a higher quality than chain, the alternate gets assigned the lower
1380 * quality contexts, with chain taking the alternate's place among the
1381 * lower quality contexts.
1383 for (i
= 0; i
< chain
->context
.cLowerQualityChainContext
; i
++)
1385 PCertificateChain alternate
=
1386 (PCertificateChain
)chain
->context
.rgpLowerQualityChainContext
[i
];
1388 if (CRYPT_ChainQuality(alternate
) > CRYPT_ChainQuality(chain
))
1390 alternate
->context
.cLowerQualityChainContext
=
1391 chain
->context
.cLowerQualityChainContext
;
1392 alternate
->context
.rgpLowerQualityChainContext
=
1393 chain
->context
.rgpLowerQualityChainContext
;
1394 alternate
->context
.rgpLowerQualityChainContext
[i
] =
1395 (PCCERT_CHAIN_CONTEXT
)chain
;
1396 chain
->context
.cLowerQualityChainContext
= 0;
1397 chain
->context
.rgpLowerQualityChainContext
= NULL
;
1404 static BOOL
CRYPT_AddAlternateChainToChain(PCertificateChain chain
,
1405 PCertificateChain alternate
)
1409 if (chain
->context
.cLowerQualityChainContext
)
1410 chain
->context
.rgpLowerQualityChainContext
=
1411 CryptMemRealloc(chain
->context
.rgpLowerQualityChainContext
,
1412 (chain
->context
.cLowerQualityChainContext
+ 1) *
1413 sizeof(PCCERT_CHAIN_CONTEXT
));
1415 chain
->context
.rgpLowerQualityChainContext
=
1416 CryptMemAlloc(sizeof(PCCERT_CHAIN_CONTEXT
));
1417 if (chain
->context
.rgpLowerQualityChainContext
)
1419 chain
->context
.rgpLowerQualityChainContext
[
1420 chain
->context
.cLowerQualityChainContext
++] =
1421 (PCCERT_CHAIN_CONTEXT
)alternate
;
1429 static PCERT_CHAIN_ELEMENT
CRYPT_FindIthElementInChain(
1430 PCERT_CHAIN_CONTEXT chain
, DWORD i
)
1433 PCERT_CHAIN_ELEMENT element
= NULL
;
1435 for (j
= 0, iElement
= 0; !element
&& j
< chain
->cChain
; j
++)
1437 if (iElement
+ chain
->rgpChain
[j
]->cElement
< i
)
1438 iElement
+= chain
->rgpChain
[j
]->cElement
;
1440 element
= chain
->rgpChain
[j
]->rgpElement
[i
- iElement
];
1445 typedef struct _CERT_CHAIN_PARA_NO_EXTRA_FIELDS
{
1447 CERT_USAGE_MATCH RequestedUsage
;
1448 } CERT_CHAIN_PARA_NO_EXTRA_FIELDS
, *PCERT_CHAIN_PARA_NO_EXTRA_FIELDS
;
1450 static void CRYPT_VerifyChainRevocation(PCERT_CHAIN_CONTEXT chain
,
1451 LPFILETIME pTime
, PCERT_CHAIN_PARA pChainPara
, DWORD chainFlags
)
1455 if (chainFlags
& CERT_CHAIN_REVOCATION_CHECK_END_CERT
)
1457 else if ((chainFlags
& CERT_CHAIN_REVOCATION_CHECK_CHAIN
) ||
1458 (chainFlags
& CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT
))
1462 for (i
= 0, cContext
= 0; i
< chain
->cChain
; i
++)
1464 if (i
< chain
->cChain
- 1 ||
1465 chainFlags
& CERT_CHAIN_REVOCATION_CHECK_CHAIN
)
1466 cContext
+= chain
->rgpChain
[i
]->cElement
;
1468 cContext
+= chain
->rgpChain
[i
]->cElement
- 1;
1475 PCCERT_CONTEXT
*contexts
=
1476 CryptMemAlloc(cContext
* sizeof(PCCERT_CONTEXT
*));
1480 DWORD i
, j
, iContext
, revocationFlags
;
1481 CERT_REVOCATION_PARA revocationPara
= { sizeof(revocationPara
), 0 };
1482 CERT_REVOCATION_STATUS revocationStatus
=
1483 { sizeof(revocationStatus
), 0 };
1486 for (i
= 0, iContext
= 0; iContext
< cContext
&& i
< chain
->cChain
;
1489 for (j
= 0; iContext
< cContext
&&
1490 j
< chain
->rgpChain
[i
]->cElement
; j
++)
1491 contexts
[iContext
++] =
1492 chain
->rgpChain
[i
]->rgpElement
[j
]->pCertContext
;
1494 revocationFlags
= CERT_VERIFY_REV_CHAIN_FLAG
;
1495 if (chainFlags
& CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY
)
1496 revocationFlags
|= CERT_VERIFY_CACHE_ONLY_BASED_REVOCATION
;
1497 if (chainFlags
& CERT_CHAIN_REVOCATION_ACCUMULATIVE_TIMEOUT
)
1498 revocationFlags
|= CERT_VERIFY_REV_ACCUMULATIVE_TIMEOUT_FLAG
;
1499 revocationPara
.pftTimeToUse
= pTime
;
1500 if (pChainPara
->cbSize
== sizeof(CERT_CHAIN_PARA
))
1502 revocationPara
.dwUrlRetrievalTimeout
=
1503 pChainPara
->dwUrlRetrievalTimeout
;
1504 revocationPara
.fCheckFreshnessTime
=
1505 pChainPara
->fCheckRevocationFreshnessTime
;
1506 revocationPara
.dwFreshnessTime
=
1507 pChainPara
->dwRevocationFreshnessTime
;
1509 ret
= CertVerifyRevocation(X509_ASN_ENCODING
,
1510 CERT_CONTEXT_REVOCATION_TYPE
, cContext
, (void **)contexts
,
1511 revocationFlags
, &revocationPara
, &revocationStatus
);
1514 PCERT_CHAIN_ELEMENT element
=
1515 CRYPT_FindIthElementInChain(chain
, revocationStatus
.dwIndex
);
1518 switch (revocationStatus
.dwError
)
1520 case CRYPT_E_NO_REVOCATION_CHECK
:
1521 case CRYPT_E_NO_REVOCATION_DLL
:
1522 case CRYPT_E_NOT_IN_REVOCATION_DATABASE
:
1523 error
= CERT_TRUST_REVOCATION_STATUS_UNKNOWN
;
1525 case CRYPT_E_REVOCATION_OFFLINE
:
1526 error
= CERT_TRUST_IS_OFFLINE_REVOCATION
;
1528 case CRYPT_E_REVOKED
:
1529 error
= CERT_TRUST_IS_REVOKED
;
1532 WARN("unmapped error %08x\n", revocationStatus
.dwError
);
1537 /* FIXME: set element's pRevocationInfo member */
1538 element
->TrustStatus
.dwErrorStatus
|= error
;
1540 chain
->TrustStatus
.dwErrorStatus
|= error
;
1542 CryptMemFree(contexts
);
1547 BOOL WINAPI
CertGetCertificateChain(HCERTCHAINENGINE hChainEngine
,
1548 PCCERT_CONTEXT pCertContext
, LPFILETIME pTime
, HCERTSTORE hAdditionalStore
,
1549 PCERT_CHAIN_PARA pChainPara
, DWORD dwFlags
, LPVOID pvReserved
,
1550 PCCERT_CHAIN_CONTEXT
* ppChainContext
)
1553 PCertificateChain chain
= NULL
;
1555 TRACE("(%p, %p, %p, %p, %p, %08x, %p, %p)\n", hChainEngine
, pCertContext
,
1556 pTime
, hAdditionalStore
, pChainPara
, dwFlags
, pvReserved
, ppChainContext
);
1559 *ppChainContext
= NULL
;
1562 SetLastError(E_INVALIDARG
);
1565 if (!pCertContext
->pCertInfo
->SignatureAlgorithm
.pszObjId
)
1567 SetLastError(ERROR_INVALID_DATA
);
1570 if (pChainPara
->cbSize
!= sizeof(CERT_CHAIN_PARA_NO_EXTRA_FIELDS
) &&
1571 pChainPara
->cbSize
!= sizeof(CERT_CHAIN_PARA
))
1573 SetLastError(E_INVALIDARG
);
1577 hChainEngine
= CRYPT_GetDefaultChainEngine();
1578 /* FIXME: what about HCCE_LOCAL_MACHINE? */
1579 ret
= CRYPT_BuildCandidateChainFromCert(hChainEngine
, pCertContext
, pTime
,
1580 hAdditionalStore
, &chain
);
1583 PCertificateChain alternate
= NULL
;
1584 PCERT_CHAIN_CONTEXT pChain
;
1587 alternate
= CRYPT_BuildAlternateContextFromChain(hChainEngine
,
1588 pTime
, hAdditionalStore
, chain
);
1590 /* Alternate contexts are added as "lower quality" contexts of
1591 * chain, to avoid loops in alternate chain creation.
1592 * The highest-quality chain is chosen at the end.
1595 ret
= CRYPT_AddAlternateChainToChain(chain
, alternate
);
1596 } while (ret
&& alternate
);
1597 chain
= CRYPT_ChooseHighestQualityChain(chain
);
1598 if (!(dwFlags
& CERT_CHAIN_RETURN_LOWER_QUALITY_CONTEXTS
))
1599 CRYPT_FreeLowerQualityChains(chain
);
1600 pChain
= (PCERT_CHAIN_CONTEXT
)chain
;
1601 CRYPT_VerifyChainRevocation(pChain
, pTime
, pChainPara
, dwFlags
);
1603 *ppChainContext
= pChain
;
1605 CertFreeCertificateChain(pChain
);
1607 TRACE("returning %d\n", ret
);
1611 PCCERT_CHAIN_CONTEXT WINAPI
CertDuplicateCertificateChain(
1612 PCCERT_CHAIN_CONTEXT pChainContext
)
1614 PCertificateChain chain
= (PCertificateChain
)pChainContext
;
1616 TRACE("(%p)\n", pChainContext
);
1619 InterlockedIncrement(&chain
->ref
);
1620 return pChainContext
;
1623 VOID WINAPI
CertFreeCertificateChain(PCCERT_CHAIN_CONTEXT pChainContext
)
1625 PCertificateChain chain
= (PCertificateChain
)pChainContext
;
1627 TRACE("(%p)\n", pChainContext
);
1631 if (InterlockedDecrement(&chain
->ref
) == 0)
1632 CRYPT_FreeChainContext(chain
);
1636 static void find_element_with_error(PCCERT_CHAIN_CONTEXT chain
, DWORD error
,
1637 LONG
*iChain
, LONG
*iElement
)
1641 for (i
= 0; i
< chain
->cChain
; i
++)
1642 for (j
= 0; j
< chain
->rgpChain
[i
]->cElement
; j
++)
1643 if (chain
->rgpChain
[i
]->rgpElement
[j
]->TrustStatus
.dwErrorStatus
&
1652 static BOOL WINAPI
verify_base_policy(LPCSTR szPolicyOID
,
1653 PCCERT_CHAIN_CONTEXT pChainContext
, PCERT_CHAIN_POLICY_PARA pPolicyPara
,
1654 PCERT_CHAIN_POLICY_STATUS pPolicyStatus
)
1656 pPolicyStatus
->lChainIndex
= pPolicyStatus
->lElementIndex
= -1;
1657 if (pChainContext
->TrustStatus
.dwErrorStatus
&
1658 CERT_TRUST_IS_NOT_SIGNATURE_VALID
)
1660 pPolicyStatus
->dwError
= TRUST_E_CERT_SIGNATURE
;
1661 find_element_with_error(pChainContext
,
1662 CERT_TRUST_IS_NOT_SIGNATURE_VALID
, &pPolicyStatus
->lChainIndex
,
1663 &pPolicyStatus
->lElementIndex
);
1665 else if (pChainContext
->TrustStatus
.dwErrorStatus
&
1666 CERT_TRUST_IS_UNTRUSTED_ROOT
)
1668 pPolicyStatus
->dwError
= CERT_E_UNTRUSTEDROOT
;
1669 find_element_with_error(pChainContext
,
1670 CERT_TRUST_IS_UNTRUSTED_ROOT
, &pPolicyStatus
->lChainIndex
,
1671 &pPolicyStatus
->lElementIndex
);
1673 else if (pChainContext
->TrustStatus
.dwErrorStatus
& CERT_TRUST_IS_CYCLIC
)
1675 pPolicyStatus
->dwError
= CERT_E_CHAINING
;
1676 find_element_with_error(pChainContext
, CERT_TRUST_IS_CYCLIC
,
1677 &pPolicyStatus
->lChainIndex
, &pPolicyStatus
->lElementIndex
);
1678 /* For a cyclic chain, which element is a cycle isn't meaningful */
1679 pPolicyStatus
->lElementIndex
= -1;
1682 pPolicyStatus
->dwError
= NO_ERROR
;
1686 static BYTE msTestPubKey1
[] = {
1687 0x30,0x47,0x02,0x40,0x81,0x55,0x22,0xb9,0x8a,0xa4,0x6f,0xed,0xd6,0xe7,0xd9,
1688 0x66,0x0f,0x55,0xbc,0xd7,0xcd,0xd5,0xbc,0x4e,0x40,0x02,0x21,0xa2,0xb1,0xf7,
1689 0x87,0x30,0x85,0x5e,0xd2,0xf2,0x44,0xb9,0xdc,0x9b,0x75,0xb6,0xfb,0x46,0x5f,
1690 0x42,0xb6,0x9d,0x23,0x36,0x0b,0xde,0x54,0x0f,0xcd,0xbd,0x1f,0x99,0x2a,0x10,
1691 0x58,0x11,0xcb,0x40,0xcb,0xb5,0xa7,0x41,0x02,0x03,0x01,0x00,0x01 };
1692 static BYTE msTestPubKey2
[] = {
1693 0x30,0x47,0x02,0x40,0x9c,0x50,0x05,0x1d,0xe2,0x0e,0x4c,0x53,0xd8,0xd9,0xb5,
1694 0xe5,0xfd,0xe9,0xe3,0xad,0x83,0x4b,0x80,0x08,0xd9,0xdc,0xe8,0xe8,0x35,0xf8,
1695 0x11,0xf1,0xe9,0x9b,0x03,0x7a,0x65,0x64,0x76,0x35,0xce,0x38,0x2c,0xf2,0xb6,
1696 0x71,0x9e,0x06,0xd9,0xbf,0xbb,0x31,0x69,0xa3,0xf6,0x30,0xa0,0x78,0x7b,0x18,
1697 0xdd,0x50,0x4d,0x79,0x1e,0xeb,0x61,0xc1,0x02,0x03,0x01,0x00,0x01 };
1699 static BOOL WINAPI
verify_authenticode_policy(LPCSTR szPolicyOID
,
1700 PCCERT_CHAIN_CONTEXT pChainContext
, PCERT_CHAIN_POLICY_PARA pPolicyPara
,
1701 PCERT_CHAIN_POLICY_STATUS pPolicyStatus
)
1703 BOOL ret
= verify_base_policy(szPolicyOID
, pChainContext
, pPolicyPara
,
1706 if (ret
&& pPolicyStatus
->dwError
== CERT_E_UNTRUSTEDROOT
)
1708 CERT_PUBLIC_KEY_INFO msPubKey
= { { 0 } };
1709 BOOL isMSTestRoot
= FALSE
;
1710 PCCERT_CONTEXT failingCert
=
1711 pChainContext
->rgpChain
[pPolicyStatus
->lChainIndex
]->
1712 rgpElement
[pPolicyStatus
->lElementIndex
]->pCertContext
;
1714 CRYPT_DATA_BLOB keyBlobs
[] = {
1715 { sizeof(msTestPubKey1
), msTestPubKey1
},
1716 { sizeof(msTestPubKey2
), msTestPubKey2
},
1719 /* Check whether the root is an MS test root */
1720 for (i
= 0; !isMSTestRoot
&& i
< sizeof(keyBlobs
) / sizeof(keyBlobs
[0]);
1723 msPubKey
.PublicKey
.cbData
= keyBlobs
[i
].cbData
;
1724 msPubKey
.PublicKey
.pbData
= keyBlobs
[i
].pbData
;
1725 if (CertComparePublicKeyInfo(
1726 X509_ASN_ENCODING
| PKCS_7_ASN_ENCODING
,
1727 &failingCert
->pCertInfo
->SubjectPublicKeyInfo
, &msPubKey
))
1728 isMSTestRoot
= TRUE
;
1731 pPolicyStatus
->dwError
= CERT_E_UNTRUSTEDTESTROOT
;
1736 static BOOL WINAPI
verify_basic_constraints_policy(LPCSTR szPolicyOID
,
1737 PCCERT_CHAIN_CONTEXT pChainContext
, PCERT_CHAIN_POLICY_PARA pPolicyPara
,
1738 PCERT_CHAIN_POLICY_STATUS pPolicyStatus
)
1740 pPolicyStatus
->lChainIndex
= pPolicyStatus
->lElementIndex
= -1;
1741 if (pChainContext
->TrustStatus
.dwErrorStatus
&
1742 CERT_TRUST_INVALID_BASIC_CONSTRAINTS
)
1744 pPolicyStatus
->dwError
= TRUST_E_BASIC_CONSTRAINTS
;
1745 find_element_with_error(pChainContext
,
1746 CERT_TRUST_INVALID_BASIC_CONSTRAINTS
, &pPolicyStatus
->lChainIndex
,
1747 &pPolicyStatus
->lElementIndex
);
1750 pPolicyStatus
->dwError
= NO_ERROR
;
1754 static BYTE msPubKey1
[] = {
1755 0x30,0x82,0x01,0x0a,0x02,0x82,0x01,0x01,0x00,0xdf,0x08,0xba,0xe3,0x3f,0x6e,
1756 0x64,0x9b,0xf5,0x89,0xaf,0x28,0x96,0x4a,0x07,0x8f,0x1b,0x2e,0x8b,0x3e,0x1d,
1757 0xfc,0xb8,0x80,0x69,0xa3,0xa1,0xce,0xdb,0xdf,0xb0,0x8e,0x6c,0x89,0x76,0x29,
1758 0x4f,0xca,0x60,0x35,0x39,0xad,0x72,0x32,0xe0,0x0b,0xae,0x29,0x3d,0x4c,0x16,
1759 0xd9,0x4b,0x3c,0x9d,0xda,0xc5,0xd3,0xd1,0x09,0xc9,0x2c,0x6f,0xa6,0xc2,0x60,
1760 0x53,0x45,0xdd,0x4b,0xd1,0x55,0xcd,0x03,0x1c,0xd2,0x59,0x56,0x24,0xf3,0xe5,
1761 0x78,0xd8,0x07,0xcc,0xd8,0xb3,0x1f,0x90,0x3f,0xc0,0x1a,0x71,0x50,0x1d,0x2d,
1762 0xa7,0x12,0x08,0x6d,0x7c,0xb0,0x86,0x6c,0xc7,0xba,0x85,0x32,0x07,0xe1,0x61,
1763 0x6f,0xaf,0x03,0xc5,0x6d,0xe5,0xd6,0xa1,0x8f,0x36,0xf6,0xc1,0x0b,0xd1,0x3e,
1764 0x69,0x97,0x48,0x72,0xc9,0x7f,0xa4,0xc8,0xc2,0x4a,0x4c,0x7e,0xa1,0xd1,0x94,
1765 0xa6,0xd7,0xdc,0xeb,0x05,0x46,0x2e,0xb8,0x18,0xb4,0x57,0x1d,0x86,0x49,0xdb,
1766 0x69,0x4a,0x2c,0x21,0xf5,0x5e,0x0f,0x54,0x2d,0x5a,0x43,0xa9,0x7a,0x7e,0x6a,
1767 0x8e,0x50,0x4d,0x25,0x57,0xa1,0xbf,0x1b,0x15,0x05,0x43,0x7b,0x2c,0x05,0x8d,
1768 0xbd,0x3d,0x03,0x8c,0x93,0x22,0x7d,0x63,0xea,0x0a,0x57,0x05,0x06,0x0a,0xdb,
1769 0x61,0x98,0x65,0x2d,0x47,0x49,0xa8,0xe7,0xe6,0x56,0x75,0x5c,0xb8,0x64,0x08,
1770 0x63,0xa9,0x30,0x40,0x66,0xb2,0xf9,0xb6,0xe3,0x34,0xe8,0x67,0x30,0xe1,0x43,
1771 0x0b,0x87,0xff,0xc9,0xbe,0x72,0x10,0x5e,0x23,0xf0,0x9b,0xa7,0x48,0x65,0xbf,
1772 0x09,0x88,0x7b,0xcd,0x72,0xbc,0x2e,0x79,0x9b,0x7b,0x02,0x03,0x01,0x00,0x01 };
1773 static BYTE msPubKey2
[] = {
1774 0x30,0x82,0x01,0x0a,0x02,0x82,0x01,0x01,0x00,0xa9,0x02,0xbd,0xc1,0x70,0xe6,
1775 0x3b,0xf2,0x4e,0x1b,0x28,0x9f,0x97,0x78,0x5e,0x30,0xea,0xa2,0xa9,0x8d,0x25,
1776 0x5f,0xf8,0xfe,0x95,0x4c,0xa3,0xb7,0xfe,0x9d,0xa2,0x20,0x3e,0x7c,0x51,0xa2,
1777 0x9b,0xa2,0x8f,0x60,0x32,0x6b,0xd1,0x42,0x64,0x79,0xee,0xac,0x76,0xc9,0x54,
1778 0xda,0xf2,0xeb,0x9c,0x86,0x1c,0x8f,0x9f,0x84,0x66,0xb3,0xc5,0x6b,0x7a,0x62,
1779 0x23,0xd6,0x1d,0x3c,0xde,0x0f,0x01,0x92,0xe8,0x96,0xc4,0xbf,0x2d,0x66,0x9a,
1780 0x9a,0x68,0x26,0x99,0xd0,0x3a,0x2c,0xbf,0x0c,0xb5,0x58,0x26,0xc1,0x46,0xe7,
1781 0x0a,0x3e,0x38,0x96,0x2c,0xa9,0x28,0x39,0xa8,0xec,0x49,0x83,0x42,0xe3,0x84,
1782 0x0f,0xbb,0x9a,0x6c,0x55,0x61,0xac,0x82,0x7c,0xa1,0x60,0x2d,0x77,0x4c,0xe9,
1783 0x99,0xb4,0x64,0x3b,0x9a,0x50,0x1c,0x31,0x08,0x24,0x14,0x9f,0xa9,0xe7,0x91,
1784 0x2b,0x18,0xe6,0x3d,0x98,0x63,0x14,0x60,0x58,0x05,0x65,0x9f,0x1d,0x37,0x52,
1785 0x87,0xf7,0xa7,0xef,0x94,0x02,0xc6,0x1b,0xd3,0xbf,0x55,0x45,0xb3,0x89,0x80,
1786 0xbf,0x3a,0xec,0x54,0x94,0x4e,0xae,0xfd,0xa7,0x7a,0x6d,0x74,0x4e,0xaf,0x18,
1787 0xcc,0x96,0x09,0x28,0x21,0x00,0x57,0x90,0x60,0x69,0x37,0xbb,0x4b,0x12,0x07,
1788 0x3c,0x56,0xff,0x5b,0xfb,0xa4,0x66,0x0a,0x08,0xa6,0xd2,0x81,0x56,0x57,0xef,
1789 0xb6,0x3b,0x5e,0x16,0x81,0x77,0x04,0xda,0xf6,0xbe,0xae,0x80,0x95,0xfe,0xb0,
1790 0xcd,0x7f,0xd6,0xa7,0x1a,0x72,0x5c,0x3c,0xca,0xbc,0xf0,0x08,0xa3,0x22,0x30,
1791 0xb3,0x06,0x85,0xc9,0xb3,0x20,0x77,0x13,0x85,0xdf,0x02,0x03,0x01,0x00,0x01 };
1792 static BYTE msPubKey3
[] = {
1793 0x30,0x82,0x02,0x0a,0x02,0x82,0x02,0x01,0x00,0xf3,0x5d,0xfa,0x80,0x67,0xd4,
1794 0x5a,0xa7,0xa9,0x0c,0x2c,0x90,0x20,0xd0,0x35,0x08,0x3c,0x75,0x84,0xcd,0xb7,
1795 0x07,0x89,0x9c,0x89,0xda,0xde,0xce,0xc3,0x60,0xfa,0x91,0x68,0x5a,0x9e,0x94,
1796 0x71,0x29,0x18,0x76,0x7c,0xc2,0xe0,0xc8,0x25,0x76,0x94,0x0e,0x58,0xfa,0x04,
1797 0x34,0x36,0xe6,0xdf,0xaf,0xf7,0x80,0xba,0xe9,0x58,0x0b,0x2b,0x93,0xe5,0x9d,
1798 0x05,0xe3,0x77,0x22,0x91,0xf7,0x34,0x64,0x3c,0x22,0x91,0x1d,0x5e,0xe1,0x09,
1799 0x90,0xbc,0x14,0xfe,0xfc,0x75,0x58,0x19,0xe1,0x79,0xb7,0x07,0x92,0xa3,0xae,
1800 0x88,0x59,0x08,0xd8,0x9f,0x07,0xca,0x03,0x58,0xfc,0x68,0x29,0x6d,0x32,0xd7,
1801 0xd2,0xa8,0xcb,0x4b,0xfc,0xe1,0x0b,0x48,0x32,0x4f,0xe6,0xeb,0xb8,0xad,0x4f,
1802 0xe4,0x5c,0x6f,0x13,0x94,0x99,0xdb,0x95,0xd5,0x75,0xdb,0xa8,0x1a,0xb7,0x94,
1803 0x91,0xb4,0x77,0x5b,0xf5,0x48,0x0c,0x8f,0x6a,0x79,0x7d,0x14,0x70,0x04,0x7d,
1804 0x6d,0xaf,0x90,0xf5,0xda,0x70,0xd8,0x47,0xb7,0xbf,0x9b,0x2f,0x6c,0xe7,0x05,
1805 0xb7,0xe1,0x11,0x60,0xac,0x79,0x91,0x14,0x7c,0xc5,0xd6,0xa6,0xe4,0xe1,0x7e,
1806 0xd5,0xc3,0x7e,0xe5,0x92,0xd2,0x3c,0x00,0xb5,0x36,0x82,0xde,0x79,0xe1,0x6d,
1807 0xf3,0xb5,0x6e,0xf8,0x9f,0x33,0xc9,0xcb,0x52,0x7d,0x73,0x98,0x36,0xdb,0x8b,
1808 0xa1,0x6b,0xa2,0x95,0x97,0x9b,0xa3,0xde,0xc2,0x4d,0x26,0xff,0x06,0x96,0x67,
1809 0x25,0x06,0xc8,0xe7,0xac,0xe4,0xee,0x12,0x33,0x95,0x31,0x99,0xc8,0x35,0x08,
1810 0x4e,0x34,0xca,0x79,0x53,0xd5,0xb5,0xbe,0x63,0x32,0x59,0x40,0x36,0xc0,0xa5,
1811 0x4e,0x04,0x4d,0x3d,0xdb,0x5b,0x07,0x33,0xe4,0x58,0xbf,0xef,0x3f,0x53,0x64,
1812 0xd8,0x42,0x59,0x35,0x57,0xfd,0x0f,0x45,0x7c,0x24,0x04,0x4d,0x9e,0xd6,0x38,
1813 0x74,0x11,0x97,0x22,0x90,0xce,0x68,0x44,0x74,0x92,0x6f,0xd5,0x4b,0x6f,0xb0,
1814 0x86,0xe3,0xc7,0x36,0x42,0xa0,0xd0,0xfc,0xc1,0xc0,0x5a,0xf9,0xa3,0x61,0xb9,
1815 0x30,0x47,0x71,0x96,0x0a,0x16,0xb0,0x91,0xc0,0x42,0x95,0xef,0x10,0x7f,0x28,
1816 0x6a,0xe3,0x2a,0x1f,0xb1,0xe4,0xcd,0x03,0x3f,0x77,0x71,0x04,0xc7,0x20,0xfc,
1817 0x49,0x0f,0x1d,0x45,0x88,0xa4,0xd7,0xcb,0x7e,0x88,0xad,0x8e,0x2d,0xec,0x45,
1818 0xdb,0xc4,0x51,0x04,0xc9,0x2a,0xfc,0xec,0x86,0x9e,0x9a,0x11,0x97,0x5b,0xde,
1819 0xce,0x53,0x88,0xe6,0xe2,0xb7,0xfd,0xac,0x95,0xc2,0x28,0x40,0xdb,0xef,0x04,
1820 0x90,0xdf,0x81,0x33,0x39,0xd9,0xb2,0x45,0xa5,0x23,0x87,0x06,0xa5,0x55,0x89,
1821 0x31,0xbb,0x06,0x2d,0x60,0x0e,0x41,0x18,0x7d,0x1f,0x2e,0xb5,0x97,0xcb,0x11,
1822 0xeb,0x15,0xd5,0x24,0xa5,0x94,0xef,0x15,0x14,0x89,0xfd,0x4b,0x73,0xfa,0x32,
1823 0x5b,0xfc,0xd1,0x33,0x00,0xf9,0x59,0x62,0x70,0x07,0x32,0xea,0x2e,0xab,0x40,
1824 0x2d,0x7b,0xca,0xdd,0x21,0x67,0x1b,0x30,0x99,0x8f,0x16,0xaa,0x23,0xa8,0x41,
1825 0xd1,0xb0,0x6e,0x11,0x9b,0x36,0xc4,0xde,0x40,0x74,0x9c,0xe1,0x58,0x65,0xc1,
1826 0x60,0x1e,0x7a,0x5b,0x38,0xc8,0x8f,0xbb,0x04,0x26,0x7c,0xd4,0x16,0x40,0xe5,
1827 0xb6,0x6b,0x6c,0xaa,0x86,0xfd,0x00,0xbf,0xce,0xc1,0x35,0x02,0x03,0x01,0x00,
1830 static BOOL WINAPI
verify_ms_root_policy(LPCSTR szPolicyOID
,
1831 PCCERT_CHAIN_CONTEXT pChainContext
, PCERT_CHAIN_POLICY_PARA pPolicyPara
,
1832 PCERT_CHAIN_POLICY_STATUS pPolicyStatus
)
1834 BOOL ret
= verify_base_policy(szPolicyOID
, pChainContext
, pPolicyPara
,
1837 if (ret
&& !pPolicyStatus
->dwError
)
1839 CERT_PUBLIC_KEY_INFO msPubKey
= { { 0 } };
1840 BOOL isMSRoot
= FALSE
;
1842 CRYPT_DATA_BLOB keyBlobs
[] = {
1843 { sizeof(msPubKey1
), msPubKey1
},
1844 { sizeof(msPubKey2
), msPubKey2
},
1845 { sizeof(msPubKey3
), msPubKey3
},
1847 PCERT_SIMPLE_CHAIN rootChain
=
1848 pChainContext
->rgpChain
[pChainContext
->cChain
-1 ];
1849 PCCERT_CONTEXT root
=
1850 rootChain
->rgpElement
[rootChain
->cElement
- 1]->pCertContext
;
1852 for (i
= 0; !isMSRoot
&& i
< sizeof(keyBlobs
) / sizeof(keyBlobs
[0]);
1855 msPubKey
.PublicKey
.cbData
= keyBlobs
[i
].cbData
;
1856 msPubKey
.PublicKey
.pbData
= keyBlobs
[i
].pbData
;
1857 if (CertComparePublicKeyInfo(
1858 X509_ASN_ENCODING
| PKCS_7_ASN_ENCODING
,
1859 &root
->pCertInfo
->SubjectPublicKeyInfo
, &msPubKey
))
1863 pPolicyStatus
->lChainIndex
= pPolicyStatus
->lElementIndex
= 0;
1868 typedef BOOL (WINAPI
*CertVerifyCertificateChainPolicyFunc
)(LPCSTR szPolicyOID
,
1869 PCCERT_CHAIN_CONTEXT pChainContext
, PCERT_CHAIN_POLICY_PARA pPolicyPara
,
1870 PCERT_CHAIN_POLICY_STATUS pPolicyStatus
);
1872 BOOL WINAPI
CertVerifyCertificateChainPolicy(LPCSTR szPolicyOID
,
1873 PCCERT_CHAIN_CONTEXT pChainContext
, PCERT_CHAIN_POLICY_PARA pPolicyPara
,
1874 PCERT_CHAIN_POLICY_STATUS pPolicyStatus
)
1876 static HCRYPTOIDFUNCSET set
= NULL
;
1878 CertVerifyCertificateChainPolicyFunc verifyPolicy
= NULL
;
1879 HCRYPTOIDFUNCADDR hFunc
= NULL
;
1881 TRACE("(%s, %p, %p, %p)\n", debugstr_a(szPolicyOID
), pChainContext
,
1882 pPolicyPara
, pPolicyStatus
);
1884 if (!HIWORD(szPolicyOID
))
1886 switch (LOWORD(szPolicyOID
))
1888 case LOWORD(CERT_CHAIN_POLICY_BASE
):
1889 verifyPolicy
= verify_base_policy
;
1891 case LOWORD(CERT_CHAIN_POLICY_AUTHENTICODE
):
1892 verifyPolicy
= verify_authenticode_policy
;
1894 case LOWORD(CERT_CHAIN_POLICY_BASIC_CONSTRAINTS
):
1895 verifyPolicy
= verify_basic_constraints_policy
;
1897 case LOWORD(CERT_CHAIN_POLICY_MICROSOFT_ROOT
):
1898 verifyPolicy
= verify_ms_root_policy
;
1901 FIXME("unimplemented for %d\n", LOWORD(szPolicyOID
));
1907 set
= CryptInitOIDFunctionSet(
1908 CRYPT_OID_VERIFY_CERTIFICATE_CHAIN_POLICY_FUNC
, 0);
1909 CryptGetOIDFunctionAddress(set
, X509_ASN_ENCODING
, szPolicyOID
, 0,
1910 (void **)&verifyPolicy
, &hFunc
);
1913 ret
= verifyPolicy(szPolicyOID
, pChainContext
, pPolicyPara
,
1916 CryptFreeOIDFunctionAddress(hFunc
, 0);