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
24 #include "wine/debug.h"
25 #include "crypt32_private.h"
27 WINE_DEFAULT_DEBUG_CHANNEL(crypt
);
29 #define DEFAULT_CYCLE_MODULUS 7
31 static HCERTCHAINENGINE CRYPT_defaultChainEngine
;
33 /* This represents a subset of a certificate chain engine: it doesn't include
34 * the "hOther" store described by MSDN, because I'm not sure how that's used.
35 * It also doesn't include the "hTrust" store, because I don't yet implement
36 * CTLs or complex certificate chains.
38 typedef struct _CertificateChainEngine
44 DWORD dwUrlRetrievalTimeout
;
45 DWORD MaximumCachedCertificates
;
46 DWORD CycleDetectionModulus
;
47 } CertificateChainEngine
, *PCertificateChainEngine
;
49 static inline void CRYPT_AddStoresToCollection(HCERTSTORE collection
,
50 DWORD cStores
, HCERTSTORE
*stores
)
54 for (i
= 0; i
< cStores
; i
++)
55 CertAddStoreToCollection(collection
, stores
[i
], 0, 0);
58 static inline void CRYPT_CloseStores(DWORD cStores
, HCERTSTORE
*stores
)
62 for (i
= 0; i
< cStores
; i
++)
63 CertCloseStore(stores
[i
], 0);
66 static const WCHAR rootW
[] = { 'R','o','o','t',0 };
68 static BOOL
CRYPT_CheckRestrictedRoot(HCERTSTORE store
)
74 HCERTSTORE rootStore
= CertOpenSystemStoreW(0, rootW
);
75 PCCERT_CONTEXT cert
= NULL
, check
;
80 cert
= CertEnumCertificatesInStore(store
, cert
);
85 ret
= CertGetCertificateContextProperty(cert
, CERT_HASH_PROP_ID
,
89 CRYPT_HASH_BLOB blob
= { sizeof(hash
), hash
};
91 check
= CertFindCertificateInStore(rootStore
,
92 cert
->dwCertEncodingType
, 0, CERT_FIND_SHA1_HASH
, &blob
,
97 CertFreeCertificateContext(check
);
100 } while (ret
&& cert
);
102 CertFreeCertificateContext(cert
);
103 CertCloseStore(rootStore
, 0);
108 HCERTCHAINENGINE
CRYPT_CreateChainEngine(HCERTSTORE root
,
109 PCERT_CHAIN_ENGINE_CONFIG pConfig
)
111 static const WCHAR caW
[] = { 'C','A',0 };
112 static const WCHAR myW
[] = { 'M','y',0 };
113 static const WCHAR trustW
[] = { 'T','r','u','s','t',0 };
114 PCertificateChainEngine engine
=
115 CryptMemAlloc(sizeof(CertificateChainEngine
));
119 HCERTSTORE worldStores
[4];
122 engine
->hRoot
= root
;
123 engine
->hWorld
= CertOpenStore(CERT_STORE_PROV_COLLECTION
, 0, 0,
124 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
125 worldStores
[0] = CertDuplicateStore(engine
->hRoot
);
126 worldStores
[1] = CertOpenSystemStoreW(0, caW
);
127 worldStores
[2] = CertOpenSystemStoreW(0, myW
);
128 worldStores
[3] = CertOpenSystemStoreW(0, trustW
);
129 CRYPT_AddStoresToCollection(engine
->hWorld
,
130 sizeof(worldStores
) / sizeof(worldStores
[0]), worldStores
);
131 CRYPT_AddStoresToCollection(engine
->hWorld
,
132 pConfig
->cAdditionalStore
, pConfig
->rghAdditionalStore
);
133 CRYPT_CloseStores(sizeof(worldStores
) / sizeof(worldStores
[0]),
135 engine
->dwFlags
= pConfig
->dwFlags
;
136 engine
->dwUrlRetrievalTimeout
= pConfig
->dwUrlRetrievalTimeout
;
137 engine
->MaximumCachedCertificates
=
138 pConfig
->MaximumCachedCertificates
;
139 if (pConfig
->CycleDetectionModulus
)
140 engine
->CycleDetectionModulus
= pConfig
->CycleDetectionModulus
;
142 engine
->CycleDetectionModulus
= DEFAULT_CYCLE_MODULUS
;
144 return (HCERTCHAINENGINE
)engine
;
147 BOOL WINAPI
CertCreateCertificateChainEngine(PCERT_CHAIN_ENGINE_CONFIG pConfig
,
148 HCERTCHAINENGINE
*phChainEngine
)
152 TRACE("(%p, %p)\n", pConfig
, phChainEngine
);
154 if (pConfig
->cbSize
!= sizeof(*pConfig
))
156 SetLastError(E_INVALIDARG
);
159 *phChainEngine
= NULL
;
160 ret
= CRYPT_CheckRestrictedRoot(pConfig
->hRestrictedRoot
);
164 HCERTCHAINENGINE engine
;
166 if (pConfig
->hRestrictedRoot
)
167 root
= CertDuplicateStore(pConfig
->hRestrictedRoot
);
169 root
= CertOpenSystemStoreW(0, rootW
);
170 engine
= CRYPT_CreateChainEngine(root
, pConfig
);
173 *phChainEngine
= engine
;
182 VOID WINAPI
CertFreeCertificateChainEngine(HCERTCHAINENGINE hChainEngine
)
184 PCertificateChainEngine engine
= (PCertificateChainEngine
)hChainEngine
;
186 TRACE("(%p)\n", hChainEngine
);
188 if (engine
&& InterlockedDecrement(&engine
->ref
) == 0)
190 CertCloseStore(engine
->hWorld
, 0);
191 CertCloseStore(engine
->hRoot
, 0);
192 CryptMemFree(engine
);
196 static HCERTCHAINENGINE
CRYPT_GetDefaultChainEngine(void)
198 if (!CRYPT_defaultChainEngine
)
200 CERT_CHAIN_ENGINE_CONFIG config
= { 0 };
201 HCERTCHAINENGINE engine
;
203 config
.cbSize
= sizeof(config
);
204 CertCreateCertificateChainEngine(&config
, &engine
);
205 InterlockedCompareExchangePointer(&CRYPT_defaultChainEngine
, engine
,
207 if (CRYPT_defaultChainEngine
!= engine
)
208 CertFreeCertificateChainEngine(engine
);
210 return CRYPT_defaultChainEngine
;
213 void default_chain_engine_free(void)
215 CertFreeCertificateChainEngine(CRYPT_defaultChainEngine
);
218 typedef struct _CertificateChain
220 CERT_CHAIN_CONTEXT context
;
223 } CertificateChain
, *PCertificateChain
;
225 static inline BOOL
CRYPT_IsCertificateSelfSigned(PCCERT_CONTEXT cert
)
227 return CertCompareCertificateName(cert
->dwCertEncodingType
,
228 &cert
->pCertInfo
->Subject
, &cert
->pCertInfo
->Issuer
);
231 static void CRYPT_FreeChainElement(PCERT_CHAIN_ELEMENT element
)
233 CertFreeCertificateContext(element
->pCertContext
);
234 CryptMemFree(element
);
237 static void CRYPT_CheckSimpleChainForCycles(PCERT_SIMPLE_CHAIN chain
)
239 DWORD i
, j
, cyclicCertIndex
= 0;
241 /* O(n^2) - I don't think there's a faster way */
242 for (i
= 0; !cyclicCertIndex
&& i
< chain
->cElement
; i
++)
243 for (j
= i
+ 1; !cyclicCertIndex
&& j
< chain
->cElement
; j
++)
244 if (CertCompareCertificate(X509_ASN_ENCODING
,
245 chain
->rgpElement
[i
]->pCertContext
->pCertInfo
,
246 chain
->rgpElement
[j
]->pCertContext
->pCertInfo
))
250 chain
->rgpElement
[cyclicCertIndex
]->TrustStatus
.dwErrorStatus
251 |= CERT_TRUST_IS_CYCLIC
;
252 /* Release remaining certs */
253 for (i
= cyclicCertIndex
+ 1; i
< chain
->cElement
; i
++)
254 CRYPT_FreeChainElement(chain
->rgpElement
[i
]);
256 chain
->cElement
= cyclicCertIndex
+ 1;
260 /* Checks whether the chain is cyclic by examining the last element's status */
261 static inline BOOL
CRYPT_IsSimpleChainCyclic(PCERT_SIMPLE_CHAIN chain
)
264 return chain
->rgpElement
[chain
->cElement
- 1]->TrustStatus
.dwErrorStatus
265 & CERT_TRUST_IS_CYCLIC
;
270 static inline void CRYPT_CombineTrustStatus(CERT_TRUST_STATUS
*chainStatus
,
271 CERT_TRUST_STATUS
*elementStatus
)
273 /* Any error that applies to an element also applies to a chain.. */
274 chainStatus
->dwErrorStatus
|= elementStatus
->dwErrorStatus
;
275 /* but the bottom nibble of an element's info status doesn't apply to the
278 chainStatus
->dwInfoStatus
|= (elementStatus
->dwInfoStatus
& 0xfffffff0);
281 static BOOL
CRYPT_AddCertToSimpleChain(PCertificateChainEngine engine
,
282 PCERT_SIMPLE_CHAIN chain
, PCCERT_CONTEXT cert
, DWORD subjectInfoStatus
)
285 PCERT_CHAIN_ELEMENT element
= CryptMemAlloc(sizeof(CERT_CHAIN_ELEMENT
));
289 if (!chain
->cElement
)
290 chain
->rgpElement
= CryptMemAlloc(sizeof(PCERT_CHAIN_ELEMENT
));
292 chain
->rgpElement
= CryptMemRealloc(chain
->rgpElement
,
293 (chain
->cElement
+ 1) * sizeof(PCERT_CHAIN_ELEMENT
));
294 if (chain
->rgpElement
)
296 chain
->rgpElement
[chain
->cElement
++] = element
;
297 memset(element
, 0, sizeof(CERT_CHAIN_ELEMENT
));
298 element
->cbSize
= sizeof(CERT_CHAIN_ELEMENT
);
299 element
->pCertContext
= CertDuplicateCertificateContext(cert
);
300 if (chain
->cElement
> 1)
301 chain
->rgpElement
[chain
->cElement
- 2]->TrustStatus
.dwInfoStatus
303 /* FIXME: initialize the rest of element */
304 if (chain
->cElement
% engine
->CycleDetectionModulus
)
305 CRYPT_CheckSimpleChainForCycles(chain
);
306 CRYPT_CombineTrustStatus(&chain
->TrustStatus
,
307 &element
->TrustStatus
);
311 CryptMemFree(element
);
316 static void CRYPT_FreeSimpleChain(PCERT_SIMPLE_CHAIN chain
)
320 for (i
= 0; i
< chain
->cElement
; i
++)
321 CRYPT_FreeChainElement(chain
->rgpElement
[i
]);
322 CryptMemFree(chain
->rgpElement
);
326 static void CRYPT_CheckTrustedStatus(HCERTSTORE hRoot
,
327 PCERT_CHAIN_ELEMENT rootElement
)
330 DWORD size
= sizeof(hash
);
331 CRYPT_HASH_BLOB blob
= { sizeof(hash
), hash
};
332 PCCERT_CONTEXT trustedRoot
;
334 CertGetCertificateContextProperty(rootElement
->pCertContext
,
335 CERT_HASH_PROP_ID
, hash
, &size
);
336 trustedRoot
= CertFindCertificateInStore(hRoot
,
337 rootElement
->pCertContext
->dwCertEncodingType
, 0, CERT_FIND_SHA1_HASH
,
340 rootElement
->TrustStatus
.dwErrorStatus
|=
341 CERT_TRUST_IS_UNTRUSTED_ROOT
;
343 CertFreeCertificateContext(trustedRoot
);
346 static void CRYPT_CheckRootCert(HCERTCHAINENGINE hRoot
,
347 PCERT_CHAIN_ELEMENT rootElement
)
349 PCCERT_CONTEXT root
= rootElement
->pCertContext
;
351 if (!CryptVerifyCertificateSignatureEx(0, root
->dwCertEncodingType
,
352 CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT
, (void *)root
,
353 CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT
, (void *)root
, 0, NULL
))
355 TRACE("Last certificate's signature is invalid\n");
356 rootElement
->TrustStatus
.dwErrorStatus
|=
357 CERT_TRUST_IS_NOT_SIGNATURE_VALID
;
359 CRYPT_CheckTrustedStatus(hRoot
, rootElement
);
362 /* Decodes a cert's basic constraints extension (either szOID_BASIC_CONSTRAINTS
363 * or szOID_BASIC_CONSTRAINTS2, whichever is present) into a
364 * CERT_BASIC_CONSTRAINTS2_INFO. If it neither extension is present, sets
365 * constraints->fCA to defaultIfNotSpecified.
366 * Returns FALSE if the extension is present but couldn't be decoded.
368 static BOOL
CRYPT_DecodeBasicConstraints(PCCERT_CONTEXT cert
,
369 CERT_BASIC_CONSTRAINTS2_INFO
*constraints
, BOOL defaultIfNotSpecified
)
372 PCERT_EXTENSION ext
= CertFindExtension(szOID_BASIC_CONSTRAINTS
,
373 cert
->pCertInfo
->cExtension
, cert
->pCertInfo
->rgExtension
);
375 constraints
->fPathLenConstraint
= FALSE
;
378 CERT_BASIC_CONSTRAINTS_INFO
*info
;
381 ret
= CryptDecodeObjectEx(X509_ASN_ENCODING
, szOID_BASIC_CONSTRAINTS
,
382 ext
->Value
.pbData
, ext
->Value
.cbData
, CRYPT_DECODE_ALLOC_FLAG
,
383 NULL
, (LPBYTE
)&info
, &size
);
386 if (info
->SubjectType
.cbData
== 1)
388 info
->SubjectType
.pbData
[0] & CERT_CA_SUBJECT_FLAG
;
394 ext
= CertFindExtension(szOID_BASIC_CONSTRAINTS2
,
395 cert
->pCertInfo
->cExtension
, cert
->pCertInfo
->rgExtension
);
398 DWORD size
= sizeof(CERT_BASIC_CONSTRAINTS2_INFO
);
400 ret
= CryptDecodeObjectEx(X509_ASN_ENCODING
,
401 szOID_BASIC_CONSTRAINTS2
, ext
->Value
.pbData
, ext
->Value
.cbData
,
402 0, NULL
, constraints
, &size
);
405 constraints
->fCA
= defaultIfNotSpecified
;
410 /* Checks element's basic constraints to see if it can act as a CA, with
411 * remainingCAs CAs left in this chain. Updates chainConstraints with the
412 * element's constraints, if:
413 * 1. chainConstraints doesn't have a path length constraint, or
414 * 2. element's path length constraint is smaller than chainConstraints's
415 * Sets *pathLengthConstraintViolated to TRUE if a path length violation
417 * Returns TRUE if the element can be a CA, and the length of the remaining
420 static BOOL
CRYPT_CheckBasicConstraintsForCA(PCCERT_CONTEXT cert
,
421 CERT_BASIC_CONSTRAINTS2_INFO
*chainConstraints
, DWORD remainingCAs
,
422 BOOL
*pathLengthConstraintViolated
)
424 BOOL validBasicConstraints
;
425 CERT_BASIC_CONSTRAINTS2_INFO constraints
;
427 if ((validBasicConstraints
= CRYPT_DecodeBasicConstraints(cert
,
428 &constraints
, TRUE
)))
430 if (!constraints
.fCA
)
432 TRACE("chain element %d can't be a CA\n", remainingCAs
+ 1);
433 validBasicConstraints
= FALSE
;
435 else if (constraints
.fPathLenConstraint
)
437 /* If the element has path length constraints, they apply to the
438 * entire remaining chain.
440 if (!chainConstraints
->fPathLenConstraint
||
441 constraints
.dwPathLenConstraint
<
442 chainConstraints
->dwPathLenConstraint
)
444 TRACE("setting path length constraint to %d\n",
445 chainConstraints
->dwPathLenConstraint
);
446 chainConstraints
->fPathLenConstraint
= TRUE
;
447 chainConstraints
->dwPathLenConstraint
=
448 constraints
.dwPathLenConstraint
;
452 if (chainConstraints
->fPathLenConstraint
&&
453 remainingCAs
> chainConstraints
->dwPathLenConstraint
)
455 TRACE("remaining CAs %d exceed max path length %d\n", remainingCAs
,
456 chainConstraints
->dwPathLenConstraint
);
457 validBasicConstraints
= FALSE
;
458 *pathLengthConstraintViolated
= TRUE
;
460 return validBasicConstraints
;
463 static void CRYPT_CheckSimpleChain(PCertificateChainEngine engine
,
464 PCERT_SIMPLE_CHAIN chain
, LPFILETIME time
)
466 PCERT_CHAIN_ELEMENT rootElement
= chain
->rgpElement
[chain
->cElement
- 1];
468 BOOL pathLengthConstraintViolated
= FALSE
;
469 CERT_BASIC_CONSTRAINTS2_INFO constraints
= { TRUE
, FALSE
, 0 };
471 for (i
= chain
->cElement
- 1; i
>= 0; i
--)
473 if (CertVerifyTimeValidity(time
,
474 chain
->rgpElement
[i
]->pCertContext
->pCertInfo
) != 0)
475 chain
->rgpElement
[i
]->TrustStatus
.dwErrorStatus
|=
476 CERT_TRUST_IS_NOT_TIME_VALID
;
479 /* Check the signature of the cert this issued */
480 if (!CryptVerifyCertificateSignatureEx(0, X509_ASN_ENCODING
,
481 CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT
,
482 (void *)chain
->rgpElement
[i
- 1]->pCertContext
,
483 CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT
,
484 (void *)chain
->rgpElement
[i
]->pCertContext
, 0, NULL
))
485 chain
->rgpElement
[i
- 1]->TrustStatus
.dwErrorStatus
|=
486 CERT_TRUST_IS_NOT_SIGNATURE_VALID
;
487 /* Once a path length constraint has been violated, every remaining
488 * CA cert's basic constraints is considered invalid.
490 if (pathLengthConstraintViolated
)
491 chain
->rgpElement
[i
]->TrustStatus
.dwErrorStatus
|=
492 CERT_TRUST_INVALID_BASIC_CONSTRAINTS
;
493 else if (!CRYPT_CheckBasicConstraintsForCA(
494 chain
->rgpElement
[i
]->pCertContext
, &constraints
, i
- 1,
495 &pathLengthConstraintViolated
))
496 chain
->rgpElement
[i
]->TrustStatus
.dwErrorStatus
|=
497 CERT_TRUST_INVALID_BASIC_CONSTRAINTS
;
498 else if (constraints
.fPathLenConstraint
&&
499 constraints
.dwPathLenConstraint
)
501 /* This one's valid - decrement max length */
502 constraints
.dwPathLenConstraint
--;
505 /* FIXME: check valid usages and name constraints */
506 CRYPT_CombineTrustStatus(&chain
->TrustStatus
,
507 &chain
->rgpElement
[i
]->TrustStatus
);
509 if (CRYPT_IsCertificateSelfSigned(rootElement
->pCertContext
))
511 rootElement
->TrustStatus
.dwInfoStatus
|=
512 CERT_TRUST_IS_SELF_SIGNED
| CERT_TRUST_HAS_NAME_MATCH_ISSUER
;
513 CRYPT_CheckRootCert(engine
->hRoot
, rootElement
);
515 /* FIXME: check revocation of every cert with CertVerifyRevocation */
516 CRYPT_CombineTrustStatus(&chain
->TrustStatus
, &rootElement
->TrustStatus
);
519 static PCCERT_CONTEXT
CRYPT_GetIssuer(HCERTSTORE store
, PCCERT_CONTEXT subject
,
520 PCCERT_CONTEXT prevIssuer
, DWORD
*infoStatus
)
522 PCCERT_CONTEXT issuer
= NULL
;
527 if ((ext
= CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER
,
528 subject
->pCertInfo
->cExtension
, subject
->pCertInfo
->rgExtension
)))
530 CERT_AUTHORITY_KEY_ID_INFO
*info
;
533 ret
= CryptDecodeObjectEx(subject
->dwCertEncodingType
,
534 X509_AUTHORITY_KEY_ID
, ext
->Value
.pbData
, ext
->Value
.cbData
,
535 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_NOCOPY_FLAG
, NULL
,
541 if (info
->CertIssuer
.cbData
&& info
->CertSerialNumber
.cbData
)
543 id
.dwIdChoice
= CERT_ID_ISSUER_SERIAL_NUMBER
;
544 memcpy(&id
.u
.IssuerSerialNumber
.Issuer
, &info
->CertIssuer
,
545 sizeof(CERT_NAME_BLOB
));
546 memcpy(&id
.u
.IssuerSerialNumber
.SerialNumber
,
547 &info
->CertSerialNumber
, sizeof(CRYPT_INTEGER_BLOB
));
548 issuer
= CertFindCertificateInStore(store
,
549 subject
->dwCertEncodingType
, 0, CERT_FIND_CERT_ID
, &id
,
552 *infoStatus
= CERT_TRUST_HAS_EXACT_MATCH_ISSUER
;
554 else if (info
->KeyId
.cbData
)
556 id
.dwIdChoice
= CERT_ID_KEY_IDENTIFIER
;
557 memcpy(&id
.u
.KeyId
, &info
->KeyId
, sizeof(CRYPT_HASH_BLOB
));
558 issuer
= CertFindCertificateInStore(store
,
559 subject
->dwCertEncodingType
, 0, CERT_FIND_CERT_ID
, &id
,
562 *infoStatus
= CERT_TRUST_HAS_KEY_MATCH_ISSUER
;
567 else if ((ext
= CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER2
,
568 subject
->pCertInfo
->cExtension
, subject
->pCertInfo
->rgExtension
)))
570 CERT_AUTHORITY_KEY_ID2_INFO
*info
;
573 ret
= CryptDecodeObjectEx(subject
->dwCertEncodingType
,
574 X509_AUTHORITY_KEY_ID2
, ext
->Value
.pbData
, ext
->Value
.cbData
,
575 CRYPT_DECODE_ALLOC_FLAG
| CRYPT_DECODE_NOCOPY_FLAG
, NULL
,
581 if (info
->AuthorityCertIssuer
.cAltEntry
&&
582 info
->AuthorityCertSerialNumber
.cbData
)
584 PCERT_ALT_NAME_ENTRY directoryName
= NULL
;
587 for (i
= 0; !directoryName
&&
588 i
< info
->AuthorityCertIssuer
.cAltEntry
; i
++)
589 if (info
->AuthorityCertIssuer
.rgAltEntry
[i
].dwAltNameChoice
590 == CERT_ALT_NAME_DIRECTORY_NAME
)
592 &info
->AuthorityCertIssuer
.rgAltEntry
[i
];
595 id
.dwIdChoice
= CERT_ID_ISSUER_SERIAL_NUMBER
;
596 memcpy(&id
.u
.IssuerSerialNumber
.Issuer
,
597 &directoryName
->u
.DirectoryName
, sizeof(CERT_NAME_BLOB
));
598 memcpy(&id
.u
.IssuerSerialNumber
.SerialNumber
,
599 &info
->AuthorityCertSerialNumber
,
600 sizeof(CRYPT_INTEGER_BLOB
));
601 issuer
= CertFindCertificateInStore(store
,
602 subject
->dwCertEncodingType
, 0, CERT_FIND_CERT_ID
, &id
,
605 *infoStatus
= CERT_TRUST_HAS_EXACT_MATCH_ISSUER
;
608 FIXME("no supported name type in authority key id2\n");
610 else if (info
->KeyId
.cbData
)
612 id
.dwIdChoice
= CERT_ID_KEY_IDENTIFIER
;
613 memcpy(&id
.u
.KeyId
, &info
->KeyId
, sizeof(CRYPT_HASH_BLOB
));
614 issuer
= CertFindCertificateInStore(store
,
615 subject
->dwCertEncodingType
, 0, CERT_FIND_CERT_ID
, &id
,
618 *infoStatus
= CERT_TRUST_HAS_KEY_MATCH_ISSUER
;
625 issuer
= CertFindCertificateInStore(store
,
626 subject
->dwCertEncodingType
, 0, CERT_FIND_SUBJECT_NAME
,
627 &subject
->pCertInfo
->Issuer
, prevIssuer
);
629 *infoStatus
= CERT_TRUST_HAS_NAME_MATCH_ISSUER
;
634 /* Builds a simple chain by finding an issuer for the last cert in the chain,
635 * until reaching a self-signed cert, or until no issuer can be found.
637 static BOOL
CRYPT_BuildSimpleChain(PCertificateChainEngine engine
,
638 HCERTSTORE world
, PCERT_SIMPLE_CHAIN chain
)
641 PCCERT_CONTEXT cert
= chain
->rgpElement
[chain
->cElement
- 1]->pCertContext
;
643 while (ret
&& !CRYPT_IsSimpleChainCyclic(chain
) &&
644 !CRYPT_IsCertificateSelfSigned(cert
))
647 PCCERT_CONTEXT issuer
= CRYPT_GetIssuer(world
, cert
, NULL
, &infoStatus
);
651 ret
= CRYPT_AddCertToSimpleChain(engine
, chain
, issuer
, infoStatus
);
656 TRACE("Couldn't find issuer, halting chain creation\n");
663 static BOOL
CRYPT_GetSimpleChainForCert(PCertificateChainEngine engine
,
664 HCERTSTORE world
, PCCERT_CONTEXT cert
, LPFILETIME pTime
,
665 PCERT_SIMPLE_CHAIN
*ppChain
)
668 PCERT_SIMPLE_CHAIN chain
;
670 TRACE("(%p, %p, %p, %p)\n", engine
, world
, cert
, pTime
);
672 chain
= CryptMemAlloc(sizeof(CERT_SIMPLE_CHAIN
));
675 memset(chain
, 0, sizeof(CERT_SIMPLE_CHAIN
));
676 chain
->cbSize
= sizeof(CERT_SIMPLE_CHAIN
);
677 ret
= CRYPT_AddCertToSimpleChain(engine
, chain
, cert
, 0);
680 ret
= CRYPT_BuildSimpleChain(engine
, world
, chain
);
682 CRYPT_CheckSimpleChain(engine
, chain
, pTime
);
686 CRYPT_FreeSimpleChain(chain
);
694 static BOOL
CRYPT_BuildCandidateChainFromCert(HCERTCHAINENGINE hChainEngine
,
695 PCCERT_CONTEXT cert
, LPFILETIME pTime
, HCERTSTORE hAdditionalStore
,
696 PCertificateChain
*ppChain
)
698 PCertificateChainEngine engine
= (PCertificateChainEngine
)hChainEngine
;
699 PCERT_SIMPLE_CHAIN simpleChain
= NULL
;
703 world
= CertOpenStore(CERT_STORE_PROV_COLLECTION
, 0, 0,
704 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
705 CertAddStoreToCollection(world
, engine
->hWorld
, 0, 0);
706 if (hAdditionalStore
)
707 CertAddStoreToCollection(world
, hAdditionalStore
, 0, 0);
708 /* FIXME: only simple chains are supported for now, as CTLs aren't
711 if ((ret
= CRYPT_GetSimpleChainForCert(engine
, world
, cert
, pTime
,
714 PCertificateChain chain
= CryptMemAlloc(sizeof(CertificateChain
));
719 chain
->world
= world
;
720 chain
->context
.cbSize
= sizeof(CERT_CHAIN_CONTEXT
);
721 memcpy(&chain
->context
.TrustStatus
, &simpleChain
->TrustStatus
,
722 sizeof(CERT_TRUST_STATUS
));
723 chain
->context
.cChain
= 1;
724 chain
->context
.rgpChain
= CryptMemAlloc(sizeof(PCERT_SIMPLE_CHAIN
));
725 chain
->context
.rgpChain
[0] = simpleChain
;
726 chain
->context
.cLowerQualityChainContext
= 0;
727 chain
->context
.rgpLowerQualityChainContext
= NULL
;
728 chain
->context
.fHasRevocationFreshnessTime
= FALSE
;
729 chain
->context
.dwRevocationFreshnessTime
= 0;
738 /* Makes and returns a copy of chain, up to and including element iElement. */
739 static PCERT_SIMPLE_CHAIN
CRYPT_CopySimpleChainToElement(
740 PCERT_SIMPLE_CHAIN chain
, DWORD iElement
)
742 PCERT_SIMPLE_CHAIN copy
= CryptMemAlloc(sizeof(CERT_SIMPLE_CHAIN
));
746 memset(copy
, 0, sizeof(CERT_SIMPLE_CHAIN
));
747 copy
->cbSize
= sizeof(CERT_SIMPLE_CHAIN
);
749 CryptMemAlloc((iElement
+ 1) * sizeof(PCERT_CHAIN_ELEMENT
));
750 if (copy
->rgpElement
)
755 memset(copy
->rgpElement
, 0,
756 (iElement
+ 1) * sizeof(PCERT_CHAIN_ELEMENT
));
757 for (i
= 0; ret
&& i
<= iElement
; i
++)
759 PCERT_CHAIN_ELEMENT element
=
760 CryptMemAlloc(sizeof(CERT_CHAIN_ELEMENT
));
764 memcpy(element
, chain
->rgpElement
[i
],
765 sizeof(CERT_CHAIN_ELEMENT
));
766 element
->pCertContext
= CertDuplicateCertificateContext(
767 chain
->rgpElement
[i
]->pCertContext
);
768 /* Reset the trust status of the copied element, it'll get
769 * rechecked after the new chain is done.
771 memset(&element
->TrustStatus
, 0, sizeof(CERT_TRUST_STATUS
));
772 copy
->rgpElement
[copy
->cElement
++] = element
;
779 for (i
= 0; i
<= iElement
; i
++)
780 CryptMemFree(copy
->rgpElement
[i
]);
781 CryptMemFree(copy
->rgpElement
);
795 static void CRYPT_FreeLowerQualityChains(PCertificateChain chain
)
799 for (i
= 0; i
< chain
->context
.cLowerQualityChainContext
; i
++)
800 CertFreeCertificateChain(chain
->context
.rgpLowerQualityChainContext
[i
]);
801 CryptMemFree(chain
->context
.rgpLowerQualityChainContext
);
804 static void CRYPT_FreeChainContext(PCertificateChain chain
)
808 CRYPT_FreeLowerQualityChains(chain
);
809 for (i
= 0; i
< chain
->context
.cChain
; i
++)
810 CRYPT_FreeSimpleChain(chain
->context
.rgpChain
[i
]);
811 CryptMemFree(chain
->context
.rgpChain
);
812 CertCloseStore(chain
->world
, 0);
816 /* Makes and returns a copy of chain, up to and including element iElement of
817 * simple chain iChain.
819 static PCertificateChain
CRYPT_CopyChainToElement(PCertificateChain chain
,
820 DWORD iChain
, DWORD iElement
)
822 PCertificateChain copy
= CryptMemAlloc(sizeof(CertificateChain
));
827 copy
->world
= CertDuplicateStore(chain
->world
);
828 copy
->context
.cbSize
= sizeof(CERT_CHAIN_CONTEXT
);
829 /* Leave the trust status of the copied chain unset, it'll get
830 * rechecked after the new chain is done.
832 memset(©
->context
.TrustStatus
, 0, sizeof(CERT_TRUST_STATUS
));
833 copy
->context
.cLowerQualityChainContext
= 0;
834 copy
->context
.rgpLowerQualityChainContext
= NULL
;
835 copy
->context
.fHasRevocationFreshnessTime
= FALSE
;
836 copy
->context
.dwRevocationFreshnessTime
= 0;
837 copy
->context
.rgpChain
= CryptMemAlloc(
838 (iChain
+ 1) * sizeof(PCERT_SIMPLE_CHAIN
));
839 if (copy
->context
.rgpChain
)
844 memset(copy
->context
.rgpChain
, 0,
845 (iChain
+ 1) * sizeof(PCERT_SIMPLE_CHAIN
));
848 for (i
= 0; ret
&& iChain
&& i
< iChain
- 1; i
++)
850 copy
->context
.rgpChain
[i
] =
851 CRYPT_CopySimpleChainToElement(chain
->context
.rgpChain
[i
],
852 chain
->context
.rgpChain
[i
]->cElement
- 1);
853 if (!copy
->context
.rgpChain
[i
])
861 copy
->context
.rgpChain
[i
] =
862 CRYPT_CopySimpleChainToElement(chain
->context
.rgpChain
[i
],
864 if (!copy
->context
.rgpChain
[i
])
869 CRYPT_FreeChainContext(copy
);
873 copy
->context
.cChain
= iChain
+ 1;
884 static PCertificateChain
CRYPT_BuildAlternateContextFromChain(
885 HCERTCHAINENGINE hChainEngine
, LPFILETIME pTime
, HCERTSTORE hAdditionalStore
,
886 PCertificateChain chain
)
888 PCertificateChainEngine engine
= (PCertificateChainEngine
)hChainEngine
;
889 PCertificateChain alternate
;
891 TRACE("(%p, %p, %p, %p)\n", hChainEngine
, pTime
, hAdditionalStore
, chain
);
893 /* Always start with the last "lower quality" chain to ensure a consistent
894 * order of alternate creation:
896 if (chain
->context
.cLowerQualityChainContext
)
897 chain
= (PCertificateChain
)chain
->context
.rgpLowerQualityChainContext
[
898 chain
->context
.cLowerQualityChainContext
- 1];
899 /* A chain with only one element can't have any alternates */
900 if (chain
->context
.cChain
<= 1 && chain
->context
.rgpChain
[0]->cElement
<= 1)
904 DWORD i
, j
, infoStatus
;
905 PCCERT_CONTEXT alternateIssuer
= NULL
;
908 for (i
= 0; !alternateIssuer
&& i
< chain
->context
.cChain
; i
++)
909 for (j
= 0; !alternateIssuer
&&
910 j
< chain
->context
.rgpChain
[i
]->cElement
- 1; j
++)
912 PCCERT_CONTEXT subject
=
913 chain
->context
.rgpChain
[i
]->rgpElement
[j
]->pCertContext
;
914 PCCERT_CONTEXT prevIssuer
= CertDuplicateCertificateContext(
915 chain
->context
.rgpChain
[i
]->rgpElement
[j
+ 1]->pCertContext
);
917 alternateIssuer
= CRYPT_GetIssuer(prevIssuer
->hCertStore
,
918 subject
, prevIssuer
, &infoStatus
);
924 alternate
= CRYPT_CopyChainToElement(chain
, i
, j
);
927 BOOL ret
= CRYPT_AddCertToSimpleChain(engine
,
928 alternate
->context
.rgpChain
[i
], alternateIssuer
, infoStatus
);
932 ret
= CRYPT_BuildSimpleChain(engine
, alternate
->world
,
933 alternate
->context
.rgpChain
[i
]);
935 CRYPT_CheckSimpleChain(engine
,
936 alternate
->context
.rgpChain
[i
], pTime
);
937 CRYPT_CombineTrustStatus(&alternate
->context
.TrustStatus
,
938 &alternate
->context
.rgpChain
[i
]->TrustStatus
);
942 CRYPT_FreeChainContext(alternate
);
948 TRACE("%p\n", alternate
);
952 #define CHAIN_QUALITY_SIGNATURE_VALID 8
953 #define CHAIN_QUALITY_TIME_VALID 4
954 #define CHAIN_QUALITY_COMPLETE_CHAIN 2
955 #define CHAIN_QUALITY_TRUSTED_ROOT 1
957 #define CHAIN_QUALITY_HIGHEST \
958 CHAIN_QUALITY_SIGNATURE_VALID | CHAIN_QUALITY_TIME_VALID | \
959 CHAIN_QUALITY_COMPLETE_CHAIN | CHAIN_QUALITY_TRUSTED_ROOT
961 #define IS_TRUST_ERROR_SET(TrustStatus, bits) \
962 (TrustStatus)->dwErrorStatus & (bits)
964 static DWORD
CRYPT_ChainQuality(PCertificateChain chain
)
966 DWORD quality
= CHAIN_QUALITY_HIGHEST
;
968 if (IS_TRUST_ERROR_SET(&chain
->context
.TrustStatus
,
969 CERT_TRUST_IS_UNTRUSTED_ROOT
))
970 quality
&= ~CHAIN_QUALITY_TRUSTED_ROOT
;
971 if (IS_TRUST_ERROR_SET(&chain
->context
.TrustStatus
,
972 CERT_TRUST_IS_PARTIAL_CHAIN
))
973 if (chain
->context
.TrustStatus
.dwErrorStatus
& CERT_TRUST_IS_PARTIAL_CHAIN
)
974 quality
&= ~CHAIN_QUALITY_COMPLETE_CHAIN
;
975 if (IS_TRUST_ERROR_SET(&chain
->context
.TrustStatus
,
976 CERT_TRUST_IS_NOT_TIME_VALID
| CERT_TRUST_IS_NOT_TIME_NESTED
))
977 quality
&= ~CHAIN_QUALITY_TIME_VALID
;
978 if (IS_TRUST_ERROR_SET(&chain
->context
.TrustStatus
,
979 CERT_TRUST_IS_NOT_SIGNATURE_VALID
))
980 quality
&= ~CHAIN_QUALITY_SIGNATURE_VALID
;
984 /* Chooses the highest quality chain among chain and its "lower quality"
985 * alternate chains. Returns the highest quality chain, with all other
986 * chains as lower quality chains of it.
988 static PCertificateChain
CRYPT_ChooseHighestQualityChain(
989 PCertificateChain chain
)
993 /* There are always only two chains being considered: chain, and an
994 * alternate at chain->rgpLowerQualityChainContext[i]. If the alternate
995 * has a higher quality than chain, the alternate gets assigned the lower
996 * quality contexts, with chain taking the alternate's place among the
997 * lower quality contexts.
999 for (i
= 0; i
< chain
->context
.cLowerQualityChainContext
; i
++)
1001 PCertificateChain alternate
=
1002 (PCertificateChain
)chain
->context
.rgpLowerQualityChainContext
[i
];
1004 if (CRYPT_ChainQuality(alternate
) > CRYPT_ChainQuality(chain
))
1006 alternate
->context
.cLowerQualityChainContext
=
1007 chain
->context
.cLowerQualityChainContext
;
1008 alternate
->context
.rgpLowerQualityChainContext
=
1009 chain
->context
.rgpLowerQualityChainContext
;
1010 alternate
->context
.rgpLowerQualityChainContext
[i
] =
1011 (PCCERT_CHAIN_CONTEXT
)chain
;
1018 static BOOL
CRYPT_AddAlternateChainToChain(PCertificateChain chain
,
1019 PCertificateChain alternate
)
1023 if (chain
->context
.cLowerQualityChainContext
)
1024 chain
->context
.rgpLowerQualityChainContext
=
1025 CryptMemRealloc(chain
->context
.rgpLowerQualityChainContext
,
1026 (chain
->context
.cLowerQualityChainContext
+ 1) *
1027 sizeof(PCCERT_CHAIN_CONTEXT
));
1029 chain
->context
.rgpLowerQualityChainContext
=
1030 CryptMemAlloc(sizeof(PCCERT_CHAIN_CONTEXT
));
1031 if (chain
->context
.rgpLowerQualityChainContext
)
1033 chain
->context
.rgpLowerQualityChainContext
[
1034 chain
->context
.cLowerQualityChainContext
++] =
1035 (PCCERT_CHAIN_CONTEXT
)alternate
;
1043 typedef struct _CERT_CHAIN_PARA_NO_EXTRA_FIELDS
{
1045 CERT_USAGE_MATCH RequestedUsage
;
1046 } CERT_CHAIN_PARA_NO_EXTRA_FIELDS
, *PCERT_CHAIN_PARA_NO_EXTRA_FIELDS
;
1048 typedef struct _CERT_CHAIN_PARA_EXTRA_FIELDS
{
1050 CERT_USAGE_MATCH RequestedUsage
;
1051 CERT_USAGE_MATCH RequestedIssuancePolicy
;
1052 DWORD dwUrlRetrievalTimeout
;
1053 BOOL fCheckRevocationFreshnessTime
;
1054 DWORD dwRevocationFreshnessTime
;
1055 } CERT_CHAIN_PARA_EXTRA_FIELDS
, *PCERT_CHAIN_PARA_EXTRA_FIELDS
;
1057 BOOL WINAPI
CertGetCertificateChain(HCERTCHAINENGINE hChainEngine
,
1058 PCCERT_CONTEXT pCertContext
, LPFILETIME pTime
, HCERTSTORE hAdditionalStore
,
1059 PCERT_CHAIN_PARA pChainPara
, DWORD dwFlags
, LPVOID pvReserved
,
1060 PCCERT_CHAIN_CONTEXT
* ppChainContext
)
1063 PCertificateChain chain
= NULL
;
1065 TRACE("(%p, %p, %p, %p, %p, %08x, %p, %p)\n", hChainEngine
, pCertContext
,
1066 pTime
, hAdditionalStore
, pChainPara
, dwFlags
, pvReserved
, ppChainContext
);
1069 *ppChainContext
= NULL
;
1072 SetLastError(E_INVALIDARG
);
1075 if (!pCertContext
->pCertInfo
->SignatureAlgorithm
.pszObjId
)
1077 SetLastError(ERROR_INVALID_DATA
);
1081 hChainEngine
= CRYPT_GetDefaultChainEngine();
1082 /* FIXME: what about HCCE_LOCAL_MACHINE? */
1083 /* FIXME: pChainPara is for now ignored */
1084 ret
= CRYPT_BuildCandidateChainFromCert(hChainEngine
, pCertContext
, pTime
,
1085 hAdditionalStore
, &chain
);
1088 PCertificateChain alternate
= NULL
;
1091 alternate
= CRYPT_BuildAlternateContextFromChain(hChainEngine
,
1092 pTime
, hAdditionalStore
, chain
);
1094 /* Alternate contexts are added as "lower quality" contexts of
1095 * chain, to avoid loops in alternate chain creation.
1096 * The highest-quality chain is chosen at the end.
1099 ret
= CRYPT_AddAlternateChainToChain(chain
, alternate
);
1100 } while (ret
&& alternate
);
1101 chain
= CRYPT_ChooseHighestQualityChain(chain
);
1102 if (!(dwFlags
& CERT_CHAIN_RETURN_LOWER_QUALITY_CONTEXTS
))
1104 CRYPT_FreeLowerQualityChains(chain
);
1105 chain
->context
.cLowerQualityChainContext
= 0;
1106 chain
->context
.rgpLowerQualityChainContext
= NULL
;
1109 *ppChainContext
= (PCCERT_CHAIN_CONTEXT
)chain
;
1111 CertFreeCertificateChain((PCCERT_CHAIN_CONTEXT
)chain
);
1113 TRACE("returning %d\n", ret
);
1117 PCCERT_CHAIN_CONTEXT WINAPI
CertDuplicateCertificateChain(
1118 PCCERT_CHAIN_CONTEXT pChainContext
)
1120 PCertificateChain chain
= (PCertificateChain
)pChainContext
;
1122 TRACE("(%p)\n", pChainContext
);
1125 InterlockedIncrement(&chain
->ref
);
1126 return pChainContext
;
1129 VOID WINAPI
CertFreeCertificateChain(PCCERT_CHAIN_CONTEXT pChainContext
)
1131 PCertificateChain chain
= (PCertificateChain
)pChainContext
;
1133 TRACE("(%p)\n", pChainContext
);
1137 if (InterlockedDecrement(&chain
->ref
) == 0)
1138 CRYPT_FreeChainContext(chain
);
1142 static void find_element_with_error(PCCERT_CHAIN_CONTEXT chain
, DWORD error
,
1143 LONG
*iChain
, LONG
*iElement
)
1147 for (i
= 0; i
< chain
->cChain
; i
++)
1148 for (j
= 0; j
< chain
->rgpChain
[i
]->cElement
; j
++)
1149 if (chain
->rgpChain
[i
]->rgpElement
[j
]->TrustStatus
.dwErrorStatus
&
1158 static BOOL WINAPI
verify_base_policy(LPCSTR szPolicyOID
,
1159 PCCERT_CHAIN_CONTEXT pChainContext
, PCERT_CHAIN_POLICY_PARA pPolicyPara
,
1160 PCERT_CHAIN_POLICY_STATUS pPolicyStatus
)
1162 pPolicyStatus
->lChainIndex
= pPolicyStatus
->lElementIndex
= -1;
1163 if (pChainContext
->TrustStatus
.dwErrorStatus
&
1164 CERT_TRUST_IS_NOT_SIGNATURE_VALID
)
1166 pPolicyStatus
->dwError
= TRUST_E_CERT_SIGNATURE
;
1167 find_element_with_error(pChainContext
,
1168 CERT_TRUST_IS_NOT_SIGNATURE_VALID
, &pPolicyStatus
->lChainIndex
,
1169 &pPolicyStatus
->lElementIndex
);
1171 else if (pChainContext
->TrustStatus
.dwErrorStatus
&
1172 CERT_TRUST_IS_UNTRUSTED_ROOT
)
1174 pPolicyStatus
->dwError
= CERT_E_UNTRUSTEDROOT
;
1175 find_element_with_error(pChainContext
,
1176 CERT_TRUST_IS_UNTRUSTED_ROOT
, &pPolicyStatus
->lChainIndex
,
1177 &pPolicyStatus
->lElementIndex
);
1179 else if (pChainContext
->TrustStatus
.dwErrorStatus
& CERT_TRUST_IS_CYCLIC
)
1181 pPolicyStatus
->dwError
= CERT_E_CHAINING
;
1182 find_element_with_error(pChainContext
, CERT_TRUST_IS_CYCLIC
,
1183 &pPolicyStatus
->lChainIndex
, &pPolicyStatus
->lElementIndex
);
1184 /* For a cyclic chain, which element is a cycle isn't meaningful */
1185 pPolicyStatus
->lElementIndex
= -1;
1190 static BYTE msTestPubKey1
[] = {
1191 0x30,0x47,0x02,0x40,0x81,0x55,0x22,0xb9,0x8a,0xa4,0x6f,0xed,0xd6,0xe7,0xd9,
1192 0x66,0x0f,0x55,0xbc,0xd7,0xcd,0xd5,0xbc,0x4e,0x40,0x02,0x21,0xa2,0xb1,0xf7,
1193 0x87,0x30,0x85,0x5e,0xd2,0xf2,0x44,0xb9,0xdc,0x9b,0x75,0xb6,0xfb,0x46,0x5f,
1194 0x42,0xb6,0x9d,0x23,0x36,0x0b,0xde,0x54,0x0f,0xcd,0xbd,0x1f,0x99,0x2a,0x10,
1195 0x58,0x11,0xcb,0x40,0xcb,0xb5,0xa7,0x41,0x02,0x03,0x01,0x00,0x01 };
1196 static BYTE msTestPubKey2
[] = {
1197 0x30,0x48,0x02,0x41,0x00,0x81,0x55,0x22,0xb9,0x8a,0xa4,0x6f,0xed,0xd6,0xe7,
1198 0xd9,0x66,0x0f,0x55,0xbc,0xd7,0xcd,0xd5,0xbc,0x4e,0x40,0x02,0x21,0xa2,0xb1,
1199 0xf7,0x87,0x30,0x85,0x5e,0xd2,0xf2,0x44,0xb9,0xdc,0x9b,0x75,0xb6,0xfb,0x46,
1200 0x5f,0x42,0xb6,0x9d,0x23,0x36,0x0b,0xde,0x54,0x0f,0xcd,0xbd,0x1f,0x99,0x2a,
1201 0x10,0x58,0x11,0xcb,0x40,0xcb,0xb5,0xa7,0x41,0x02,0x03,0x01,0x00,0x01 };
1202 static BYTE msTestPubKey3
[] = {
1203 0x30,0x47,0x02,0x40,0x9c,0x50,0x05,0x1d,0xe2,0x0e,0x4c,0x53,0xd8,0xd9,0xb5,
1204 0xe5,0xfd,0xe9,0xe3,0xad,0x83,0x4b,0x80,0x08,0xd9,0xdc,0xe8,0xe8,0x35,0xf8,
1205 0x11,0xf1,0xe9,0x9b,0x03,0x7a,0x65,0x64,0x76,0x35,0xce,0x38,0x2c,0xf2,0xb6,
1206 0x71,0x9e,0x06,0xd9,0xbf,0xbb,0x31,0x69,0xa3,0xf6,0x30,0xa0,0x78,0x7b,0x18,
1207 0xdd,0x50,0x4d,0x79,0x1e,0xeb,0x61,0xc1,0x02,0x03,0x01,0x00,0x01 };
1209 static BOOL WINAPI
verify_authenticode_policy(LPCSTR szPolicyOID
,
1210 PCCERT_CHAIN_CONTEXT pChainContext
, PCERT_CHAIN_POLICY_PARA pPolicyPara
,
1211 PCERT_CHAIN_POLICY_STATUS pPolicyStatus
)
1213 BOOL ret
= verify_base_policy(szPolicyOID
, pChainContext
, pPolicyPara
,
1216 if (ret
&& pPolicyStatus
->dwError
== CERT_E_UNTRUSTEDROOT
)
1218 CERT_PUBLIC_KEY_INFO msPubKey
= { { 0 } };
1219 BOOL isMSTestRoot
= FALSE
;
1220 PCCERT_CONTEXT failingCert
=
1221 pChainContext
->rgpChain
[pPolicyStatus
->lChainIndex
]->
1222 rgpElement
[pPolicyStatus
->lElementIndex
]->pCertContext
;
1224 CRYPT_DATA_BLOB keyBlobs
[] = {
1225 { sizeof(msTestPubKey1
), msTestPubKey1
},
1226 { sizeof(msTestPubKey2
), msTestPubKey2
},
1227 { sizeof(msTestPubKey3
), msTestPubKey3
},
1230 /* Check whether the root is an MS test root */
1231 for (i
= 0; !isMSTestRoot
&& i
< sizeof(keyBlobs
) / sizeof(keyBlobs
[0]);
1234 msPubKey
.PublicKey
.cbData
= keyBlobs
[i
].cbData
;
1235 msPubKey
.PublicKey
.pbData
= keyBlobs
[i
].pbData
;
1236 if (CertComparePublicKeyInfo(
1237 X509_ASN_ENCODING
| PKCS_7_ASN_ENCODING
,
1238 &failingCert
->pCertInfo
->SubjectPublicKeyInfo
, &msPubKey
))
1239 isMSTestRoot
= TRUE
;
1242 pPolicyStatus
->dwError
= CERT_E_UNTRUSTEDTESTROOT
;
1247 static BOOL WINAPI
verify_basic_constraints_policy(LPCSTR szPolicyOID
,
1248 PCCERT_CHAIN_CONTEXT pChainContext
, PCERT_CHAIN_POLICY_PARA pPolicyPara
,
1249 PCERT_CHAIN_POLICY_STATUS pPolicyStatus
)
1251 pPolicyStatus
->lChainIndex
= pPolicyStatus
->lElementIndex
= -1;
1252 if (pChainContext
->TrustStatus
.dwErrorStatus
&
1253 CERT_TRUST_INVALID_BASIC_CONSTRAINTS
)
1255 pPolicyStatus
->dwError
= TRUST_E_BASIC_CONSTRAINTS
;
1256 find_element_with_error(pChainContext
,
1257 CERT_TRUST_INVALID_BASIC_CONSTRAINTS
, &pPolicyStatus
->lChainIndex
,
1258 &pPolicyStatus
->lElementIndex
);
1263 typedef BOOL (WINAPI
*CertVerifyCertificateChainPolicyFunc
)(LPCSTR szPolicyOID
,
1264 PCCERT_CHAIN_CONTEXT pChainContext
, PCERT_CHAIN_POLICY_PARA pPolicyPara
,
1265 PCERT_CHAIN_POLICY_STATUS pPolicyStatus
);
1267 BOOL WINAPI
CertVerifyCertificateChainPolicy(LPCSTR szPolicyOID
,
1268 PCCERT_CHAIN_CONTEXT pChainContext
, PCERT_CHAIN_POLICY_PARA pPolicyPara
,
1269 PCERT_CHAIN_POLICY_STATUS pPolicyStatus
)
1271 static HCRYPTOIDFUNCSET set
= NULL
;
1273 CertVerifyCertificateChainPolicyFunc verifyPolicy
= NULL
;
1274 HCRYPTOIDFUNCADDR hFunc
= NULL
;
1276 TRACE("(%s, %p, %p, %p)\n", debugstr_a(szPolicyOID
), pChainContext
,
1277 pPolicyPara
, pPolicyStatus
);
1279 if (!HIWORD(szPolicyOID
))
1281 switch (LOWORD(szPolicyOID
))
1283 case (int)CERT_CHAIN_POLICY_BASE
:
1284 verifyPolicy
= verify_base_policy
;
1286 case (int)CERT_CHAIN_POLICY_AUTHENTICODE
:
1287 verifyPolicy
= verify_authenticode_policy
;
1289 case (int)CERT_CHAIN_POLICY_BASIC_CONSTRAINTS
:
1290 verifyPolicy
= verify_basic_constraints_policy
;
1293 FIXME("unimplemented for %d\n", LOWORD(szPolicyOID
));
1299 set
= CryptInitOIDFunctionSet(
1300 CRYPT_OID_VERIFY_CERTIFICATE_CHAIN_POLICY_FUNC
, 0);
1301 CryptGetOIDFunctionAddress(set
, X509_ASN_ENCODING
, szPolicyOID
, 0,
1302 (void **)&verifyPolicy
, hFunc
);
1305 ret
= verifyPolicy(szPolicyOID
, pChainContext
, pPolicyPara
,
1308 CryptFreeOIDFunctionAddress(hFunc
, 0);