?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cmd: Add the Romanian translation.
[wine/hacks.git] / dlls / crypt32 / chain.c
blobe951ef8e9c51ded4cf23315808372058760f6339
1 /*
2 * Copyright 2006 Juan Lang
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 *
18 */
19 #include <stdarg.h>
20 #define NONAMELESSUNION
21 #include "windef.h"
22 #include "winbase.h"
23 #define CERT_CHAIN_PARA_HAS_EXTRA_FIELDS
24 #define CERT_REVOCATION_PARA_HAS_EXTRA_FIELDS
25 #include "wincrypt.h"
26 #include "wine/debug.h"
27 #include "wine/unicode.h"
28 #include "crypt32_private.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
31 WINE_DECLARE_DEBUG_CHANNEL(chain);
32
33 #define DEFAULT_CYCLE_MODULUS 7
34
35 static HCERTCHAINENGINE CRYPT_defaultChainEngine;
36
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.
41 */
42 typedef struct _CertificateChainEngine
43 {
44 LONG ref;
45 HCERTSTORE hRoot;
46 HCERTSTORE hWorld;
47 DWORD dwFlags;
48 DWORD dwUrlRetrievalTimeout;
49 DWORD MaximumCachedCertificates;
50 DWORD CycleDetectionModulus;
51 } CertificateChainEngine, *PCertificateChainEngine;
52
53 static inline void CRYPT_AddStoresToCollection(HCERTSTORE collection,
54 DWORD cStores, HCERTSTORE *stores)
55 {
56 DWORD i;
57
58 for (i = 0; i < cStores; i++)
59 CertAddStoreToCollection(collection, stores[i], 0, 0);
60 }
61
62 static inline void CRYPT_CloseStores(DWORD cStores, HCERTSTORE *stores)
63 {
64 DWORD i;
65
66 for (i = 0; i < cStores; i++)
67 CertCloseStore(stores[i], 0);
68 }
69
70 static const WCHAR rootW[] = { 'R','o','o','t',0 };
71
72 /* Finds cert in store by comparing the cert's hashes. */
73 static PCCERT_CONTEXT CRYPT_FindCertInStore(HCERTSTORE store,
74 PCCERT_CONTEXT cert)
75 {
76 PCCERT_CONTEXT matching = NULL;
77 BYTE hash[20];
78 DWORD size = sizeof(hash);
79
80 if (CertGetCertificateContextProperty(cert, CERT_HASH_PROP_ID, hash, &size))
81 {
82 CRYPT_HASH_BLOB blob = { sizeof(hash), hash };
83
84 matching = CertFindCertificateInStore(store, cert->dwCertEncodingType,
85 0, CERT_FIND_SHA1_HASH, &blob, NULL);
86 }
87 return matching;
88 }
89
90 static BOOL CRYPT_CheckRestrictedRoot(HCERTSTORE store)
91 {
92 BOOL ret = TRUE;
93
94 if (store)
95 {
96 HCERTSTORE rootStore = CertOpenSystemStoreW(0, rootW);
97 PCCERT_CONTEXT cert = NULL, check;
98
99 do {
100 cert = CertEnumCertificatesInStore(store, cert);
101 if (cert)
102 {
103 if (!(check = CRYPT_FindCertInStore(rootStore, cert)))
104 ret = FALSE;
105 else
106 CertFreeCertificateContext(check);
107 }
108 } while (ret && cert);
109 if (cert)
110 CertFreeCertificateContext(cert);
111 CertCloseStore(rootStore, 0);
112 }
113 return ret;
114 }
115
116 HCERTCHAINENGINE CRYPT_CreateChainEngine(HCERTSTORE root,
117 PCERT_CHAIN_ENGINE_CONFIG pConfig)
118 {
119 static const WCHAR caW[] = { 'C','A',0 };
120 static const WCHAR myW[] = { 'M','y',0 };
121 static const WCHAR trustW[] = { 'T','r','u','s','t',0 };
122 PCertificateChainEngine engine =
123 CryptMemAlloc(sizeof(CertificateChainEngine));
124
125 if (engine)
126 {
127 HCERTSTORE worldStores[4];
128
129 engine->ref = 1;
130 engine->hRoot = root;
131 engine->hWorld = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0,
132 CERT_STORE_CREATE_NEW_FLAG, NULL);
133 worldStores[0] = CertDuplicateStore(engine->hRoot);
134 worldStores[1] = CertOpenSystemStoreW(0, caW);
135 worldStores[2] = CertOpenSystemStoreW(0, myW);
136 worldStores[3] = CertOpenSystemStoreW(0, trustW);
137 CRYPT_AddStoresToCollection(engine->hWorld,
138 sizeof(worldStores) / sizeof(worldStores[0]), worldStores);
139 CRYPT_AddStoresToCollection(engine->hWorld,
140 pConfig->cAdditionalStore, pConfig->rghAdditionalStore);
141 CRYPT_CloseStores(sizeof(worldStores) / sizeof(worldStores[0]),
142 worldStores);
143 engine->dwFlags = pConfig->dwFlags;
144 engine->dwUrlRetrievalTimeout = pConfig->dwUrlRetrievalTimeout;
145 engine->MaximumCachedCertificates =
146 pConfig->MaximumCachedCertificates;
147 if (pConfig->CycleDetectionModulus)
148 engine->CycleDetectionModulus = pConfig->CycleDetectionModulus;
149 else
150 engine->CycleDetectionModulus = DEFAULT_CYCLE_MODULUS;
151 }
152 return engine;
153 }
154
155 typedef struct _CERT_CHAIN_ENGINE_CONFIG_NO_EXCLUSIVE_ROOT
156 {
157 DWORD cbSize;
158 HCERTSTORE hRestrictedRoot;
159 HCERTSTORE hRestrictedTrust;
160 HCERTSTORE hRestrictedOther;
161 DWORD cAdditionalStore;
162 HCERTSTORE *rghAdditionalStore;
163 DWORD dwFlags;
164 DWORD dwUrlRetrievalTimeout;
165 DWORD MaximumCachedCertificates;
166 DWORD CycleDetectionModulus;
167 } CERT_CHAIN_ENGINE_CONFIG_NO_EXCLUSIVE_ROOT;
168
169 BOOL WINAPI CertCreateCertificateChainEngine(PCERT_CHAIN_ENGINE_CONFIG pConfig,
170 HCERTCHAINENGINE *phChainEngine)
171 {
172 BOOL ret;
173
174 TRACE("(%p, %p)\n", pConfig, phChainEngine);
175
176 if (pConfig->cbSize != sizeof(CERT_CHAIN_ENGINE_CONFIG_NO_EXCLUSIVE_ROOT)
177 && pConfig->cbSize != sizeof(CERT_CHAIN_ENGINE_CONFIG))
178 {
179 SetLastError(E_INVALIDARG);
180 return FALSE;
181 }
182 *phChainEngine = NULL;
183 ret = CRYPT_CheckRestrictedRoot(pConfig->hRestrictedRoot);
184 if (ret)
185 {
186 HCERTSTORE root;
187 HCERTCHAINENGINE engine;
188
189 if (pConfig->cbSize >= sizeof(CERT_CHAIN_ENGINE_CONFIG) &&
190 pConfig->hExclusiveRoot)
191 root = CertDuplicateStore(pConfig->hExclusiveRoot);
192 else if (pConfig->hRestrictedRoot)
193 root = CertDuplicateStore(pConfig->hRestrictedRoot);
194 else
195 root = CertOpenSystemStoreW(0, rootW);
196 engine = CRYPT_CreateChainEngine(root, pConfig);
197 if (engine)
198 {
199 *phChainEngine = engine;
200 ret = TRUE;
201 }
202 else
203 ret = FALSE;
204 }
205 return ret;
206 }
207
208 VOID WINAPI CertFreeCertificateChainEngine(HCERTCHAINENGINE hChainEngine)
209 {
210 PCertificateChainEngine engine = (PCertificateChainEngine)hChainEngine;
211
212 TRACE("(%p)\n", hChainEngine);
213
214 if (engine && InterlockedDecrement(&engine->ref) == 0)
215 {
216 CertCloseStore(engine->hWorld, 0);
217 CertCloseStore(engine->hRoot, 0);
218 CryptMemFree(engine);
219 }
220 }
221
222 static HCERTCHAINENGINE CRYPT_GetDefaultChainEngine(void)
223 {
224 if (!CRYPT_defaultChainEngine)
225 {
226 CERT_CHAIN_ENGINE_CONFIG config = { 0 };
227 HCERTCHAINENGINE engine;
228
229 config.cbSize = sizeof(config);
230 CertCreateCertificateChainEngine(&config, &engine);
231 InterlockedCompareExchangePointer(&CRYPT_defaultChainEngine, engine,
232 NULL);
233 if (CRYPT_defaultChainEngine != engine)
234 CertFreeCertificateChainEngine(engine);
235 }
236 return CRYPT_defaultChainEngine;
237 }
238
239 void default_chain_engine_free(void)
240 {
241 CertFreeCertificateChainEngine(CRYPT_defaultChainEngine);
242 }
243
244 typedef struct _CertificateChain
245 {
246 CERT_CHAIN_CONTEXT context;
247 HCERTSTORE world;
248 LONG ref;
249 } CertificateChain, *PCertificateChain;
250
251 static BOOL CRYPT_IsCertificateSelfSigned(PCCERT_CONTEXT cert)
252 {
253 PCERT_EXTENSION ext;
254 DWORD size;
255 BOOL ret;
256
257 if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER2,
258 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
259 {
260 CERT_AUTHORITY_KEY_ID2_INFO *info;
261
262 ret = CryptDecodeObjectEx(cert->dwCertEncodingType,
263 X509_AUTHORITY_KEY_ID2, ext->Value.pbData, ext->Value.cbData,
264 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
265 &info, &size);
266 if (ret)
267 {
268 if (info->AuthorityCertIssuer.cAltEntry &&
269 info->AuthorityCertSerialNumber.cbData)
270 {
271 PCERT_ALT_NAME_ENTRY directoryName = NULL;
272 DWORD i;
273
274 for (i = 0; !directoryName &&
275 i < info->AuthorityCertIssuer.cAltEntry; i++)
276 if (info->AuthorityCertIssuer.rgAltEntry[i].dwAltNameChoice
277 == CERT_ALT_NAME_DIRECTORY_NAME)
278 directoryName =
279 &info->AuthorityCertIssuer.rgAltEntry[i];
280 if (directoryName)
281 {
282 ret = CertCompareCertificateName(cert->dwCertEncodingType,
283 &directoryName->u.DirectoryName, &cert->pCertInfo->Issuer)
284 && CertCompareIntegerBlob(&info->AuthorityCertSerialNumber,
285 &cert->pCertInfo->SerialNumber);
286 }
287 else
288 {
289 FIXME("no supported name type in authority key id2\n");
290 ret = FALSE;
291 }
292 }
293 else if (info->KeyId.cbData)
294 {
295 ret = CertGetCertificateContextProperty(cert,
296 CERT_KEY_IDENTIFIER_PROP_ID, NULL, &size);
297 if (ret && size == info->KeyId.cbData)
298 {
299 LPBYTE buf = CryptMemAlloc(size);
300
301 if (buf)
302 {
303 CertGetCertificateContextProperty(cert,
304 CERT_KEY_IDENTIFIER_PROP_ID, buf, &size);
305 ret = !memcmp(buf, info->KeyId.pbData, size);
306 CryptMemFree(buf);
307 }
308 }
309 else
310 ret = FALSE;
311 }
312 LocalFree(info);
313 }
314 }
315 else if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER,
316 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
317 {
318 CERT_AUTHORITY_KEY_ID_INFO *info;
319
320 ret = CryptDecodeObjectEx(cert->dwCertEncodingType,
321 X509_AUTHORITY_KEY_ID, ext->Value.pbData, ext->Value.cbData,
322 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
323 &info, &size);
324 if (ret)
325 {
326 if (info->CertIssuer.cbData && info->CertSerialNumber.cbData)
327 {
328 ret = CertCompareCertificateName(cert->dwCertEncodingType,
329 &info->CertIssuer, &cert->pCertInfo->Issuer) &&
330 CertCompareIntegerBlob(&info->CertSerialNumber,
331 &cert->pCertInfo->SerialNumber);
332 }
333 else if (info->KeyId.cbData)
334 {
335 ret = CertGetCertificateContextProperty(cert,
336 CERT_KEY_IDENTIFIER_PROP_ID, NULL, &size);
337 if (ret && size == info->KeyId.cbData)
338 {
339 LPBYTE buf = CryptMemAlloc(size);
340
341 if (buf)
342 {
343 CertGetCertificateContextProperty(cert,
344 CERT_KEY_IDENTIFIER_PROP_ID, buf, &size);
345 ret = !memcmp(buf, info->KeyId.pbData, size);
346 CryptMemFree(buf);
347 }
348 else
349 ret = FALSE;
350 }
351 else
352 ret = FALSE;
353 }
354 else
355 ret = FALSE;
356 LocalFree(info);
357 }
358 }
359 else
360 ret = CertCompareCertificateName(cert->dwCertEncodingType,
361 &cert->pCertInfo->Subject, &cert->pCertInfo->Issuer);
362 return ret;
363 }
364
365 static void CRYPT_FreeChainElement(PCERT_CHAIN_ELEMENT element)
366 {
367 CertFreeCertificateContext(element->pCertContext);
368 CryptMemFree(element);
369 }
370
371 static void CRYPT_CheckSimpleChainForCycles(PCERT_SIMPLE_CHAIN chain)
372 {
373 DWORD i, j, cyclicCertIndex = 0;
374
375 /* O(n^2) - I don't think there's a faster way */
376 for (i = 0; !cyclicCertIndex && i < chain->cElement; i++)
377 for (j = i + 1; !cyclicCertIndex && j < chain->cElement; j++)
378 if (CertCompareCertificate(X509_ASN_ENCODING,
379 chain->rgpElement[i]->pCertContext->pCertInfo,
380 chain->rgpElement[j]->pCertContext->pCertInfo))
381 cyclicCertIndex = j;
382 if (cyclicCertIndex)
383 {
384 chain->rgpElement[cyclicCertIndex]->TrustStatus.dwErrorStatus
385 |= CERT_TRUST_IS_CYCLIC | CERT_TRUST_INVALID_BASIC_CONSTRAINTS;
386 /* Release remaining certs */
387 for (i = cyclicCertIndex + 1; i < chain->cElement; i++)
388 CRYPT_FreeChainElement(chain->rgpElement[i]);
389 /* Truncate chain */
390 chain->cElement = cyclicCertIndex + 1;
391 }
392 }
393
394 /* Checks whether the chain is cyclic by examining the last element's status */
395 static inline BOOL CRYPT_IsSimpleChainCyclic(const CERT_SIMPLE_CHAIN *chain)
396 {
397 if (chain->cElement)
398 return chain->rgpElement[chain->cElement - 1]->TrustStatus.dwErrorStatus
399 & CERT_TRUST_IS_CYCLIC;
400 else
401 return FALSE;
402 }
403
404 static inline void CRYPT_CombineTrustStatus(CERT_TRUST_STATUS *chainStatus,
405 const CERT_TRUST_STATUS *elementStatus)
406 {
407 /* Any error that applies to an element also applies to a chain.. */
408 chainStatus->dwErrorStatus |= elementStatus->dwErrorStatus;
409 /* but the bottom nibble of an element's info status doesn't apply to the
410 * chain.
411 */
412 chainStatus->dwInfoStatus |= (elementStatus->dwInfoStatus & 0xfffffff0);
413 }
414
415 static BOOL CRYPT_AddCertToSimpleChain(const CertificateChainEngine *engine,
416 PCERT_SIMPLE_CHAIN chain, PCCERT_CONTEXT cert, DWORD subjectInfoStatus)
417 {
418 BOOL ret = FALSE;
419 PCERT_CHAIN_ELEMENT element = CryptMemAlloc(sizeof(CERT_CHAIN_ELEMENT));
420
421 if (element)
422 {
423 if (!chain->cElement)
424 chain->rgpElement = CryptMemAlloc(sizeof(PCERT_CHAIN_ELEMENT));
425 else
426 chain->rgpElement = CryptMemRealloc(chain->rgpElement,
427 (chain->cElement + 1) * sizeof(PCERT_CHAIN_ELEMENT));
428 if (chain->rgpElement)
429 {
430 chain->rgpElement[chain->cElement++] = element;
431 memset(element, 0, sizeof(CERT_CHAIN_ELEMENT));
432 element->cbSize = sizeof(CERT_CHAIN_ELEMENT);
433 element->pCertContext = CertDuplicateCertificateContext(cert);
434 if (chain->cElement > 1)
435 chain->rgpElement[chain->cElement - 2]->TrustStatus.dwInfoStatus
436 = subjectInfoStatus;
437 /* FIXME: initialize the rest of element */
438 if (!(chain->cElement % engine->CycleDetectionModulus))
439 {
440 CRYPT_CheckSimpleChainForCycles(chain);
441 /* Reinitialize the element pointer in case the chain is
442 * cyclic, in which case the chain is truncated.
443 */
444 element = chain->rgpElement[chain->cElement - 1];
445 }
446 CRYPT_CombineTrustStatus(&chain->TrustStatus,
447 &element->TrustStatus);
448 ret = TRUE;
449 }
450 else
451 CryptMemFree(element);
452 }
453 return ret;
454 }
455
456 static void CRYPT_FreeSimpleChain(PCERT_SIMPLE_CHAIN chain)
457 {
458 DWORD i;
459
460 for (i = 0; i < chain->cElement; i++)
461 CRYPT_FreeChainElement(chain->rgpElement[i]);
462 CryptMemFree(chain->rgpElement);
463 CryptMemFree(chain);
464 }
465
466 static void CRYPT_CheckTrustedStatus(HCERTSTORE hRoot,
467 PCERT_CHAIN_ELEMENT rootElement)
468 {
469 PCCERT_CONTEXT trustedRoot = CRYPT_FindCertInStore(hRoot,
470 rootElement->pCertContext);
471
472 if (!trustedRoot)
473 rootElement->TrustStatus.dwErrorStatus |=
474 CERT_TRUST_IS_UNTRUSTED_ROOT;
475 else
476 CertFreeCertificateContext(trustedRoot);
477 }
478
479 static void CRYPT_CheckRootCert(HCERTCHAINENGINE hRoot,
480 PCERT_CHAIN_ELEMENT rootElement)
481 {
482 PCCERT_CONTEXT root = rootElement->pCertContext;
483
484 if (!CryptVerifyCertificateSignatureEx(0, root->dwCertEncodingType,
485 CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT, (void *)root,
486 CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT, (void *)root, 0, NULL))
487 {
488 TRACE_(chain)("Last certificate's signature is invalid\n");
489 rootElement->TrustStatus.dwErrorStatus |=
490 CERT_TRUST_IS_NOT_SIGNATURE_VALID;
491 }
492 CRYPT_CheckTrustedStatus(hRoot, rootElement);
493 }
494
495 /* Decodes a cert's basic constraints extension (either szOID_BASIC_CONSTRAINTS
496 * or szOID_BASIC_CONSTRAINTS2, whichever is present) into a
497 * CERT_BASIC_CONSTRAINTS2_INFO. If it neither extension is present, sets
498 * constraints->fCA to defaultIfNotSpecified.
499 * Returns FALSE if the extension is present but couldn't be decoded.
500 */
501 static BOOL CRYPT_DecodeBasicConstraints(PCCERT_CONTEXT cert,
502 CERT_BASIC_CONSTRAINTS2_INFO *constraints, BOOL defaultIfNotSpecified)
503 {
504 BOOL ret = TRUE;
505 PCERT_EXTENSION ext = CertFindExtension(szOID_BASIC_CONSTRAINTS,
506 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
507
508 constraints->fPathLenConstraint = FALSE;
509 if (ext)
510 {
511 CERT_BASIC_CONSTRAINTS_INFO *info;
512 DWORD size = 0;
513
514 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
515 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
516 NULL, &info, &size);
517 if (ret)
518 {
519 if (info->SubjectType.cbData == 1)
520 constraints->fCA =
521 info->SubjectType.pbData[0] & CERT_CA_SUBJECT_FLAG;
522 LocalFree(info);
523 }
524 }
525 else
526 {
527 ext = CertFindExtension(szOID_BASIC_CONSTRAINTS2,
528 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
529 if (ext)
530 {
531 DWORD size = sizeof(CERT_BASIC_CONSTRAINTS2_INFO);
532
533 ret = CryptDecodeObjectEx(X509_ASN_ENCODING,
534 szOID_BASIC_CONSTRAINTS2, ext->Value.pbData, ext->Value.cbData,
535 0, NULL, constraints, &size);
536 }
537 else
538 constraints->fCA = defaultIfNotSpecified;
539 }
540 return ret;
541 }
542
543 /* Checks element's basic constraints to see if it can act as a CA, with
544 * remainingCAs CAs left in this chain. In general, a cert must include the
545 * basic constraints extension, with the CA flag asserted, in order to be
546 * allowed to be a CA. A V1 or V2 cert, which has no extensions, is also
547 * allowed to be a CA if it's installed locally (in the engine's world store.)
548 * This matches the expected usage in RFC 5280, section 4.2.1.9: a conforming
549 * CA MUST include the basic constraints extension in all certificates that are
550 * used to validate digital signatures on certificates. It also matches
551 * section 6.1.4(k): "If a certificate is a v1 or v2 certificate, then the
552 * application MUST either verify that the certificate is a CA certificate
553 * through out-of-band means or reject the certificate." Rejecting the
554 * certificate prohibits a large number of commonly used certificates, so
555 * accepting locally installed ones is a compromise.
556 * Root certificates are also allowed to be CAs even without a basic
557 * constraints extension. This is implied by RFC 5280, section 6.1: the
558 * root of a certificate chain's only requirement is that it was used to issue
559 * the next certificate in the chain.
560 * Updates chainConstraints with the element's constraints, if:
561 * 1. chainConstraints doesn't have a path length constraint, or
562 * 2. element's path length constraint is smaller than chainConstraints's
563 * Sets *pathLengthConstraintViolated to TRUE if a path length violation
564 * occurs.
565 * Returns TRUE if the element can be a CA, and the length of the remaining
566 * chain is valid.
567 */
568 static BOOL CRYPT_CheckBasicConstraintsForCA(PCertificateChainEngine engine,
569 PCCERT_CONTEXT cert, CERT_BASIC_CONSTRAINTS2_INFO *chainConstraints,
570 DWORD remainingCAs, BOOL isRoot, BOOL *pathLengthConstraintViolated)
571 {
572 BOOL validBasicConstraints, implicitCA = FALSE;
573 CERT_BASIC_CONSTRAINTS2_INFO constraints;
574
575 if (isRoot)
576 implicitCA = TRUE;
577 else if (cert->pCertInfo->dwVersion == CERT_V1 ||
578 cert->pCertInfo->dwVersion == CERT_V2)
579 {
580 BYTE hash[20];
581 DWORD size = sizeof(hash);
582
583 if (CertGetCertificateContextProperty(cert, CERT_HASH_PROP_ID,
584 hash, &size))
585 {
586 CRYPT_HASH_BLOB blob = { sizeof(hash), hash };
587 PCCERT_CONTEXT localCert = CertFindCertificateInStore(
588 engine->hWorld, cert->dwCertEncodingType, 0, CERT_FIND_SHA1_HASH,
589 &blob, NULL);
590
591 if (localCert)
592 {
593 CertFreeCertificateContext(localCert);
594 implicitCA = TRUE;
595 }
596 }
597 }
598 if ((validBasicConstraints = CRYPT_DecodeBasicConstraints(cert,
599 &constraints, implicitCA)))
600 {
601 chainConstraints->fCA = constraints.fCA;
602 if (!constraints.fCA)
603 {
604 TRACE_(chain)("chain element %d can't be a CA\n", remainingCAs + 1);
605 validBasicConstraints = FALSE;
606 }
607 else if (constraints.fPathLenConstraint)
608 {
609 /* If the element has path length constraints, they apply to the
610 * entire remaining chain.
611 */
612 if (!chainConstraints->fPathLenConstraint ||
613 constraints.dwPathLenConstraint <
614 chainConstraints->dwPathLenConstraint)
615 {
616 TRACE_(chain)("setting path length constraint to %d\n",
617 chainConstraints->dwPathLenConstraint);
618 chainConstraints->fPathLenConstraint = TRUE;
619 chainConstraints->dwPathLenConstraint =
620 constraints.dwPathLenConstraint;
621 }
622 }
623 }
624 if (chainConstraints->fPathLenConstraint &&
625 remainingCAs > chainConstraints->dwPathLenConstraint)
626 {
627 TRACE_(chain)("remaining CAs %d exceed max path length %d\n",
628 remainingCAs, chainConstraints->dwPathLenConstraint);
629 validBasicConstraints = FALSE;
630 *pathLengthConstraintViolated = TRUE;
631 }
632 return validBasicConstraints;
633 }
634
635 static BOOL domain_name_matches(LPCWSTR constraint, LPCWSTR name)
636 {
637 BOOL match;
638
639 /* RFC 5280, section 4.2.1.10:
640 * "For URIs, the constraint applies to the host part of the name...
641 * When the constraint begins with a period, it MAY be expanded with one
642 * or more labels. That is, the constraint ".example.com" is satisfied by
643 * both host.example.com and my.host.example.com. However, the constraint
644 * ".example.com" is not satisfied by "example.com". When the constraint
645 * does not begin with a period, it specifies a host."
646 * and for email addresses,
647 * "To indicate all Internet mail addresses on a particular host, the
648 * constraint is specified as the host name. For example, the constraint
649 * "example.com" is satisfied by any mail address at the host
650 * "example.com". To specify any address within a domain, the constraint
651 * is specified with a leading period (as with URIs)."
652 */
653 if (constraint[0] == '.')
654 {
655 /* Must be strictly greater than, a name can't begin with '.' */
656 if (lstrlenW(name) > lstrlenW(constraint))
657 match = !lstrcmpiW(name + lstrlenW(name) - lstrlenW(constraint),
658 constraint);
659 else
660 {
661 /* name is too short, no match */
662 match = FALSE;
663 }
664 }
665 else
666 match = !lstrcmpiW(name, constraint);
667 return match;
668 }
669
670 static BOOL url_matches(LPCWSTR constraint, LPCWSTR name,
671 DWORD *trustErrorStatus)
672 {
673 BOOL match = FALSE;
674
675 TRACE("%s, %s\n", debugstr_w(constraint), debugstr_w(name));
676
677 if (!constraint)
678 *trustErrorStatus |= CERT_TRUST_INVALID_NAME_CONSTRAINTS;
679 else if (!name)
680 ; /* no match */
681 else
682 {
683 LPCWSTR colon, authority_end, at, hostname = NULL;
684 /* The maximum length for a hostname is 254 in the DNS, see RFC 1034 */
685 WCHAR hostname_buf[255];
686
687 /* RFC 5280: only the hostname portion of the URL is compared. From
688 * section 4.2.1.10:
689 * "For URIs, the constraint applies to the host part of the name.
690 * The constraint MUST be specified as a fully qualified domain name
691 * and MAY specify a host or a domain."
692 * The format for URIs is in RFC 2396.
693 *
694 * First, remove any scheme that's present. */
695 colon = strchrW(name, ':');
696 if (colon && *(colon + 1) == '/' && *(colon + 2) == '/')
697 name = colon + 3;
698 /* Next, find the end of the authority component. (The authority is
699 * generally just the hostname, but it may contain a username or a port.
700 * Those are removed next.)
701 */
702 authority_end = strchrW(name, '/');
703 if (!authority_end)
704 authority_end = strchrW(name, '?');
705 if (!authority_end)
706 authority_end = name + strlenW(name);
707 /* Remove any port number from the authority. The userinfo portion
708 * of an authority may contain a colon, so stop if a userinfo portion
709 * is found (indicated by '@').
710 */
711 for (colon = authority_end; colon >= name && *colon != ':' &&
712 *colon != '@'; colon--)
713 ;
714 if (*colon == ':')
715 authority_end = colon;
716 /* Remove any username from the authority */
717 if ((at = strchrW(name, '@')))
718 name = at;
719 /* Ignore any path or query portion of the URL. */
720 if (*authority_end)
721 {
722 if (authority_end - name < sizeof(hostname_buf) /
723 sizeof(hostname_buf[0]))
724 {
725 memcpy(hostname_buf, name,
726 (authority_end - name) * sizeof(WCHAR));
727 hostname_buf[authority_end - name] = 0;
728 hostname = hostname_buf;
729 }
730 /* else: Hostname is too long, not a match */
731 }
732 else
733 hostname = name;
734 if (hostname)
735 match = domain_name_matches(constraint, hostname);
736 }
737 return match;
738 }
739
740 static BOOL rfc822_name_matches(LPCWSTR constraint, LPCWSTR name,
741 DWORD *trustErrorStatus)
742 {
743 BOOL match = FALSE;
744 LPCWSTR at;
745
746 TRACE("%s, %s\n", debugstr_w(constraint), debugstr_w(name));
747
748 if (!constraint)
749 *trustErrorStatus |= CERT_TRUST_INVALID_NAME_CONSTRAINTS;
750 else if (!name)
751 ; /* no match */
752 else if (strchrW(constraint, '@'))
753 match = !lstrcmpiW(constraint, name);
754 else
755 {
756 if ((at = strchrW(name, '@')))
757 match = domain_name_matches(constraint, at + 1);
758 else
759 match = !lstrcmpiW(constraint, name);
760 }
761 return match;
762 }
763
764 static BOOL dns_name_matches(LPCWSTR constraint, LPCWSTR name,
765 DWORD *trustErrorStatus)
766 {
767 BOOL match = FALSE;
768
769 TRACE("%s, %s\n", debugstr_w(constraint), debugstr_w(name));
770
771 if (!constraint)
772 *trustErrorStatus |= CERT_TRUST_INVALID_NAME_CONSTRAINTS;
773 else if (!name)
774 ; /* no match */
775 /* RFC 5280, section 4.2.1.10:
776 * "DNS name restrictions are expressed as host.example.com. Any DNS name
777 * that can be constructed by simply adding zero or more labels to the
778 * left-hand side of the name satisfies the name constraint. For example,
779 * www.host.example.com would satisfy the constraint but host1.example.com
780 * would not."
781 */
782 else if (lstrlenW(name) == lstrlenW(constraint))
783 match = !lstrcmpiW(name, constraint);
784 else if (lstrlenW(name) > lstrlenW(constraint))
785 {
786 match = !lstrcmpiW(name + lstrlenW(name) - lstrlenW(constraint),
787 constraint);
788 if (match)
789 {
790 BOOL dot = FALSE;
791 LPCWSTR ptr;
792
793 /* This only matches if name is a subdomain of constraint, i.e.
794 * there's a '.' between the beginning of the name and the
795 * matching portion of the name.
796 */
797 for (ptr = name + lstrlenW(name) - lstrlenW(constraint);
798 !dot && ptr >= name; ptr--)
799 if (*ptr == '.')
800 dot = TRUE;
801 match = dot;
802 }
803 }
804 /* else: name is too short, no match */
805
806 return match;
807 }
808
809 static BOOL ip_address_matches(const CRYPT_DATA_BLOB *constraint,
810 const CRYPT_DATA_BLOB *name, DWORD *trustErrorStatus)
811 {
812 BOOL match = FALSE;
813
814 TRACE("(%d, %p), (%d, %p)\n", constraint->cbData, constraint->pbData,
815 name->cbData, name->pbData);
816
817 /* RFC5280, section 4.2.1.10, iPAddress syntax: either 8 or 32 bytes, for
818 * IPv4 or IPv6 addresses, respectively.
819 */
820 if (constraint->cbData != sizeof(DWORD) * 2 && constraint->cbData != 32)
821 *trustErrorStatus |= CERT_TRUST_INVALID_NAME_CONSTRAINTS;
822 else if (name->cbData == sizeof(DWORD) &&
823 constraint->cbData == sizeof(DWORD) * 2)
824 {
825 DWORD subnet, mask, addr;
826
827 memcpy(&subnet, constraint->pbData, sizeof(subnet));
828 memcpy(&mask, constraint->pbData + sizeof(subnet), sizeof(mask));
829 memcpy(&addr, name->pbData, sizeof(addr));
830 /* These are really in big-endian order, but for equality matching we
831 * don't need to swap to host order
832 */
833 match = (subnet & mask) == (addr & mask);
834 }
835 else if (name->cbData == 16 && constraint->cbData == 32)
836 {
837 const BYTE *subnet, *mask, *addr;
838 DWORD i;
839
840 subnet = constraint->pbData;
841 mask = constraint->pbData + 16;
842 addr = name->pbData;
843 match = TRUE;
844 for (i = 0; match && i < 16; i++)
845 if ((subnet[i] & mask[i]) != (addr[i] & mask[i]))
846 match = FALSE;
847 }
848 /* else: name is wrong size, no match */
849
850 return match;
851 }
852
853 static BOOL directory_name_matches(const CERT_NAME_BLOB *constraint,
854 const CERT_NAME_BLOB *name)
855 {
856 CERT_NAME_INFO *constraintName;
857 DWORD size;
858 BOOL match = FALSE;
859
860 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME, constraint->pbData,
861 constraint->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &constraintName, &size))
862 {
863 DWORD i;
864
865 match = TRUE;
866 for (i = 0; match && i < constraintName->cRDN; i++)
867 match = CertIsRDNAttrsInCertificateName(X509_ASN_ENCODING,
868 CERT_CASE_INSENSITIVE_IS_RDN_ATTRS_FLAG,
869 (CERT_NAME_BLOB *)name, &constraintName->rgRDN[i]);
870 LocalFree(constraintName);
871 }
872 return match;
873 }
874
875 static BOOL alt_name_matches(const CERT_ALT_NAME_ENTRY *name,
876 const CERT_ALT_NAME_ENTRY *constraint, DWORD *trustErrorStatus, BOOL *present)
877 {
878 BOOL match = FALSE;
879
880 if (name->dwAltNameChoice == constraint->dwAltNameChoice)
881 {
882 if (present)
883 *present = TRUE;
884 switch (constraint->dwAltNameChoice)
885 {
886 case CERT_ALT_NAME_RFC822_NAME:
887 match = rfc822_name_matches(constraint->u.pwszURL,
888 name->u.pwszURL, trustErrorStatus);
889 break;
890 case CERT_ALT_NAME_DNS_NAME:
891 match = dns_name_matches(constraint->u.pwszURL,
892 name->u.pwszURL, trustErrorStatus);
893 break;
894 case CERT_ALT_NAME_URL:
895 match = url_matches(constraint->u.pwszURL,
896 name->u.pwszURL, trustErrorStatus);
897 break;
898 case CERT_ALT_NAME_IP_ADDRESS:
899 match = ip_address_matches(&constraint->u.IPAddress,
900 &name->u.IPAddress, trustErrorStatus);
901 break;
902 case CERT_ALT_NAME_DIRECTORY_NAME:
903 match = directory_name_matches(&constraint->u.DirectoryName,
904 &name->u.DirectoryName);
905 break;
906 default:
907 ERR("name choice %d unsupported in this context\n",
908 constraint->dwAltNameChoice);
909 *trustErrorStatus |=
910 CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT;
911 }
912 }
913 else if (present)
914 *present = FALSE;
915 return match;
916 }
917
918 static BOOL alt_name_matches_excluded_name(const CERT_ALT_NAME_ENTRY *name,
919 const CERT_NAME_CONSTRAINTS_INFO *nameConstraints, DWORD *trustErrorStatus)
920 {
921 DWORD i;
922 BOOL match = FALSE;
923
924 for (i = 0; !match && i < nameConstraints->cExcludedSubtree; i++)
925 match = alt_name_matches(name,
926 &nameConstraints->rgExcludedSubtree[i].Base, trustErrorStatus, NULL);
927 return match;
928 }
929
930 static BOOL alt_name_matches_permitted_name(const CERT_ALT_NAME_ENTRY *name,
931 const CERT_NAME_CONSTRAINTS_INFO *nameConstraints, DWORD *trustErrorStatus,
932 BOOL *present)
933 {
934 DWORD i;
935 BOOL match = FALSE;
936
937 for (i = 0; !match && i < nameConstraints->cPermittedSubtree; i++)
938 match = alt_name_matches(name,
939 &nameConstraints->rgPermittedSubtree[i].Base, trustErrorStatus,
940 present);
941 return match;
942 }
943
944 static inline PCERT_EXTENSION get_subject_alt_name_ext(const CERT_INFO *cert)
945 {
946 PCERT_EXTENSION ext;
947
948 ext = CertFindExtension(szOID_SUBJECT_ALT_NAME2,
949 cert->cExtension, cert->rgExtension);
950 if (!ext)
951 ext = CertFindExtension(szOID_SUBJECT_ALT_NAME,
952 cert->cExtension, cert->rgExtension);
953 return ext;
954 }
955
956 static void compare_alt_name_with_constraints(const CERT_EXTENSION *altNameExt,
957 const CERT_NAME_CONSTRAINTS_INFO *nameConstraints, DWORD *trustErrorStatus)
958 {
959 CERT_ALT_NAME_INFO *subjectAltName;
960 DWORD size;
961
962 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_ALTERNATE_NAME,
963 altNameExt->Value.pbData, altNameExt->Value.cbData,
964 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
965 &subjectAltName, &size))
966 {
967 DWORD i;
968
969 for (i = 0; i < subjectAltName->cAltEntry; i++)
970 {
971 BOOL nameFormPresent;
972
973 /* A name constraint only applies if the name form is present.
974 * From RFC 5280, section 4.2.1.10:
975 * "Restrictions apply only when the specified name form is
976 * present. If no name of the type is in the certificate,
977 * the certificate is acceptable."
978 */
979 if (alt_name_matches_excluded_name(
980 &subjectAltName->rgAltEntry[i], nameConstraints,
981 trustErrorStatus))
982 {
983 TRACE_(chain)("subject alternate name form %d excluded\n",
984 subjectAltName->rgAltEntry[i].dwAltNameChoice);
985 *trustErrorStatus |=
986 CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT;
987 }
988 nameFormPresent = FALSE;
989 if (!alt_name_matches_permitted_name(
990 &subjectAltName->rgAltEntry[i], nameConstraints,
991 trustErrorStatus, &nameFormPresent) && nameFormPresent)
992 {
993 TRACE_(chain)("subject alternate name form %d not permitted\n",
994 subjectAltName->rgAltEntry[i].dwAltNameChoice);
995 *trustErrorStatus |=
996 CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT;
997 }
998 }
999 LocalFree(subjectAltName);
1000 }
1001 else
1002 *trustErrorStatus |=
1003 CERT_TRUST_INVALID_EXTENSION | CERT_TRUST_INVALID_NAME_CONSTRAINTS;
1004 }
1005
1006 static BOOL rfc822_attr_matches_excluded_name(const CERT_RDN_ATTR *attr,
1007 const CERT_NAME_CONSTRAINTS_INFO *nameConstraints, DWORD *trustErrorStatus)
1008 {
1009 DWORD i;
1010 BOOL match = FALSE;
1011
1012 for (i = 0; !match && i < nameConstraints->cExcludedSubtree; i++)
1013 {
1014 const CERT_ALT_NAME_ENTRY *constraint =
1015 &nameConstraints->rgExcludedSubtree[i].Base;
1016
1017 if (constraint->dwAltNameChoice == CERT_ALT_NAME_RFC822_NAME)
1018 match = rfc822_name_matches(constraint->u.pwszRfc822Name,
1019 (LPCWSTR)attr->Value.pbData, trustErrorStatus);
1020 }
1021 return match;
1022 }
1023
1024 static BOOL rfc822_attr_matches_permitted_name(const CERT_RDN_ATTR *attr,
1025 const CERT_NAME_CONSTRAINTS_INFO *nameConstraints, DWORD *trustErrorStatus,
1026 BOOL *present)
1027 {
1028 DWORD i;
1029 BOOL match = FALSE;
1030
1031 for (i = 0; !match && i < nameConstraints->cPermittedSubtree; i++)
1032 {
1033 const CERT_ALT_NAME_ENTRY *constraint =
1034 &nameConstraints->rgPermittedSubtree[i].Base;
1035
1036 if (constraint->dwAltNameChoice == CERT_ALT_NAME_RFC822_NAME)
1037 {
1038 *present = TRUE;
1039 match = rfc822_name_matches(constraint->u.pwszRfc822Name,
1040 (LPCWSTR)attr->Value.pbData, trustErrorStatus);
1041 }
1042 }
1043 return match;
1044 }
1045
1046 static void compare_subject_with_email_constraints(
1047 const CERT_NAME_BLOB *subjectName,
1048 const CERT_NAME_CONSTRAINTS_INFO *nameConstraints, DWORD *trustErrorStatus)
1049 {
1050 CERT_NAME_INFO *name;
1051 DWORD size;
1052
1053 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_UNICODE_NAME,
1054 subjectName->pbData, subjectName->cbData,
1055 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL, &name, &size))
1056 {
1057 DWORD i, j;
1058
1059 for (i = 0; i < name->cRDN; i++)
1060 for (j = 0; j < name->rgRDN[i].cRDNAttr; j++)
1061 if (!strcmp(name->rgRDN[i].rgRDNAttr[j].pszObjId,
1062 szOID_RSA_emailAddr))
1063 {
1064 BOOL nameFormPresent;
1065
1066 /* A name constraint only applies if the name form is
1067 * present. From RFC 5280, section 4.2.1.10:
1068 * "Restrictions apply only when the specified name form is
1069 * present. If no name of the type is in the certificate,
1070 * the certificate is acceptable."
1071 */
1072 if (rfc822_attr_matches_excluded_name(
1073 &name->rgRDN[i].rgRDNAttr[j], nameConstraints,
1074 trustErrorStatus))
1075 {
1076 TRACE_(chain)(
1077 "email address in subject name is excluded\n");
1078 *trustErrorStatus |=
1079 CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT;
1080 }
1081 nameFormPresent = FALSE;
1082 if (!rfc822_attr_matches_permitted_name(
1083 &name->rgRDN[i].rgRDNAttr[j], nameConstraints,
1084 trustErrorStatus, &nameFormPresent) && nameFormPresent)
1085 {
1086 TRACE_(chain)(
1087 "email address in subject name is not permitted\n");
1088 *trustErrorStatus |=
1089 CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT;
1090 }
1091 }
1092 LocalFree(name);
1093 }
1094 else
1095 *trustErrorStatus |=
1096 CERT_TRUST_INVALID_EXTENSION | CERT_TRUST_INVALID_NAME_CONSTRAINTS;
1097 }
1098
1099 static BOOL CRYPT_IsEmptyName(const CERT_NAME_BLOB *name)
1100 {
1101 BOOL empty;
1102
1103 if (!name->cbData)
1104 empty = TRUE;
1105 else if (name->cbData == 2 && name->pbData[1] == 0)
1106 {
1107 /* An empty sequence is also empty */
1108 empty = TRUE;
1109 }
1110 else
1111 empty = FALSE;
1112 return empty;
1113 }
1114
1115 static void compare_subject_with_constraints(const CERT_NAME_BLOB *subjectName,
1116 const CERT_NAME_CONSTRAINTS_INFO *nameConstraints, DWORD *trustErrorStatus)
1117 {
1118 BOOL hasEmailConstraint = FALSE;
1119 DWORD i;
1120
1121 /* In general, a subject distinguished name only matches a directory name
1122 * constraint. However, an exception exists for email addresses.
1123 * From RFC 5280, section 4.2.1.6:
1124 * "Legacy implementations exist where an electronic mail address is
1125 * embedded in the subject distinguished name as an emailAddress
1126 * attribute [RFC2985]."
1127 * If an email address constraint exists, check that constraint separately.
1128 */
1129 for (i = 0; !hasEmailConstraint && i < nameConstraints->cExcludedSubtree;
1130 i++)
1131 if (nameConstraints->rgExcludedSubtree[i].Base.dwAltNameChoice ==
1132 CERT_ALT_NAME_RFC822_NAME)
1133 hasEmailConstraint = TRUE;
1134 for (i = 0; !hasEmailConstraint && i < nameConstraints->cPermittedSubtree;
1135 i++)
1136 if (nameConstraints->rgPermittedSubtree[i].Base.dwAltNameChoice ==
1137 CERT_ALT_NAME_RFC822_NAME)
1138 hasEmailConstraint = TRUE;
1139 if (hasEmailConstraint)
1140 compare_subject_with_email_constraints(subjectName, nameConstraints,
1141 trustErrorStatus);
1142 for (i = 0; i < nameConstraints->cExcludedSubtree; i++)
1143 {
1144 CERT_ALT_NAME_ENTRY *constraint =
1145 &nameConstraints->rgExcludedSubtree[i].Base;
1146
1147 if (constraint->dwAltNameChoice == CERT_ALT_NAME_DIRECTORY_NAME &&
1148 directory_name_matches(&constraint->u.DirectoryName, subjectName))
1149 {
1150 TRACE_(chain)("subject name is excluded\n");
1151 *trustErrorStatus |=
1152 CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT;
1153 }
1154 }
1155 /* RFC 5280, section 4.2.1.10:
1156 * "Restrictions apply only when the specified name form is present.
1157 * If no name of the type is in the certificate, the certificate is
1158 * acceptable."
1159 * An empty name can't have the name form present, so don't check it.
1160 */
1161 if (nameConstraints->cPermittedSubtree && !CRYPT_IsEmptyName(subjectName))
1162 {
1163 BOOL match = FALSE, hasDirectoryConstraint = FALSE;
1164
1165 for (i = 0; !match && i < nameConstraints->cPermittedSubtree; i++)
1166 {
1167 CERT_ALT_NAME_ENTRY *constraint =
1168 &nameConstraints->rgPermittedSubtree[i].Base;
1169
1170 if (constraint->dwAltNameChoice == CERT_ALT_NAME_DIRECTORY_NAME)
1171 {
1172 hasDirectoryConstraint = TRUE;
1173 match = directory_name_matches(&constraint->u.DirectoryName,
1174 subjectName);
1175 }
1176 }
1177 if (hasDirectoryConstraint && !match)
1178 {
1179 TRACE_(chain)("subject name is not permitted\n");
1180 *trustErrorStatus |= CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT;
1181 }
1182 }
1183 }
1184
1185 static void CRYPT_CheckNameConstraints(
1186 const CERT_NAME_CONSTRAINTS_INFO *nameConstraints, const CERT_INFO *cert,
1187 DWORD *trustErrorStatus)
1188 {
1189 CERT_EXTENSION *ext = get_subject_alt_name_ext(cert);
1190
1191 if (ext)
1192 compare_alt_name_with_constraints(ext, nameConstraints,
1193 trustErrorStatus);
1194 /* Name constraints apply to the subject alternative name as well as the
1195 * subject name. From RFC 5280, section 4.2.1.10:
1196 * "Restrictions apply to the subject distinguished name and apply to
1197 * subject alternative names."
1198 */
1199 compare_subject_with_constraints(&cert->Subject, nameConstraints,
1200 trustErrorStatus);
1201 }
1202
1203 /* Gets cert's name constraints, if any. Free with LocalFree. */
1204 static CERT_NAME_CONSTRAINTS_INFO *CRYPT_GetNameConstraints(CERT_INFO *cert)
1205 {
1206 CERT_NAME_CONSTRAINTS_INFO *info = NULL;
1207
1208 CERT_EXTENSION *ext;
1209
1210 if ((ext = CertFindExtension(szOID_NAME_CONSTRAINTS, cert->cExtension,
1211 cert->rgExtension)))
1212 {
1213 DWORD size;
1214
1215 CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME_CONSTRAINTS,
1216 ext->Value.pbData, ext->Value.cbData,
1217 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL, &info,
1218 &size);
1219 }
1220 return info;
1221 }
1222
1223 static BOOL CRYPT_IsValidNameConstraint(const CERT_NAME_CONSTRAINTS_INFO *info)
1224 {
1225 DWORD i;
1226 BOOL ret = TRUE;
1227
1228 /* Make sure at least one permitted or excluded subtree is present. From
1229 * RFC 5280, section 4.2.1.10:
1230 * "Conforming CAs MUST NOT issue certificates where name constraints is an
1231 * empty sequence. That is, either the permittedSubtrees field or the
1232 * excludedSubtrees MUST be present."
1233 */
1234 if (!info->cPermittedSubtree && !info->cExcludedSubtree)
1235 {
1236 WARN_(chain)("constraints contain no permitted nor excluded subtree\n");
1237 ret = FALSE;
1238 }
1239 /* Check that none of the constraints specifies a minimum or a maximum.
1240 * See RFC 5280, section 4.2.1.10:
1241 * "Within this profile, the minimum and maximum fields are not used with
1242 * any name forms, thus, the minimum MUST be zero, and maximum MUST be
1243 * absent. However, if an application encounters a critical name
1244 * constraints extension that specifies other values for minimum or
1245 * maximum for a name form that appears in a subsequent certificate, the
1246 * application MUST either process these fields or reject the
1247 * certificate."
1248 * Since it gives no guidance as to how to process these fields, we
1249 * reject any name constraint that contains them.
1250 */
1251 for (i = 0; ret && i < info->cPermittedSubtree; i++)
1252 if (info->rgPermittedSubtree[i].dwMinimum ||
1253 info->rgPermittedSubtree[i].fMaximum)
1254 {
1255 TRACE_(chain)("found a minimum or maximum in permitted subtrees\n");
1256 ret = FALSE;
1257 }
1258 for (i = 0; ret && i < info->cExcludedSubtree; i++)
1259 if (info->rgExcludedSubtree[i].dwMinimum ||
1260 info->rgExcludedSubtree[i].fMaximum)
1261 {
1262 TRACE_(chain)("found a minimum or maximum in excluded subtrees\n");
1263 ret = FALSE;
1264 }
1265 return ret;
1266 }
1267
1268 static void CRYPT_CheckChainNameConstraints(PCERT_SIMPLE_CHAIN chain)
1269 {
1270 int i, j;
1271
1272 /* Microsoft's implementation appears to violate RFC 3280: according to
1273 * MSDN, the various CERT_TRUST_*_NAME_CONSTRAINT errors are set if a CA's
1274 * name constraint is violated in the end cert. According to RFC 3280,
1275 * the constraints should be checked against every subsequent certificate
1276 * in the chain, not just the end cert.
1277 * Microsoft's implementation also sets the name constraint errors on the
1278 * certs whose constraints were violated, not on the certs that violated
1279 * them.
1280 * In order to be error-compatible with Microsoft's implementation, while
1281 * still adhering to RFC 3280, I use a O(n ^ 2) algorithm to check name
1282 * constraints.
1283 */
1284 for (i = chain->cElement - 1; i > 0; i--)
1285 {
1286 CERT_NAME_CONSTRAINTS_INFO *nameConstraints;
1287
1288 if ((nameConstraints = CRYPT_GetNameConstraints(
1289 chain->rgpElement[i]->pCertContext->pCertInfo)))
1290 {
1291 if (!CRYPT_IsValidNameConstraint(nameConstraints))
1292 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1293 CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT;
1294 else
1295 {
1296 for (j = i - 1; j >= 0; j--)
1297 {
1298 DWORD errorStatus = 0;
1299
1300 /* According to RFC 3280, self-signed certs don't have name
1301 * constraints checked unless they're the end cert.
1302 */
1303 if (j == 0 || !CRYPT_IsCertificateSelfSigned(
1304 chain->rgpElement[j]->pCertContext))
1305 {
1306 CRYPT_CheckNameConstraints(nameConstraints,
1307 chain->rgpElement[j]->pCertContext->pCertInfo,
1308 &errorStatus);
1309 if (errorStatus)
1310 {
1311 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1312 errorStatus;
1313 CRYPT_CombineTrustStatus(&chain->TrustStatus,
1314 &chain->rgpElement[i]->TrustStatus);
1315 }
1316 else
1317 chain->rgpElement[i]->TrustStatus.dwInfoStatus |=
1318 CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS;
1319 }
1320 }
1321 }
1322 LocalFree(nameConstraints);
1323 }
1324 }
1325 }
1326
1327 /* Gets cert's policies info, if any. Free with LocalFree. */
1328 static CERT_POLICIES_INFO *CRYPT_GetPolicies(PCCERT_CONTEXT cert)
1329 {
1330 PCERT_EXTENSION ext;
1331 CERT_POLICIES_INFO *policies = NULL;
1332
1333 ext = CertFindExtension(szOID_KEY_USAGE, cert->pCertInfo->cExtension,
1334 cert->pCertInfo->rgExtension);
1335 if (ext)
1336 {
1337 DWORD size;
1338
1339 CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_POLICIES,
1340 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
1341 &policies, &size);
1342 }
1343 return policies;
1344 }
1345
1346 static void CRYPT_CheckPolicies(CERT_POLICIES_INFO *policies, CERT_INFO *cert,
1347 DWORD *errorStatus)
1348 {
1349 DWORD i;
1350
1351 for (i = 0; i < policies->cPolicyInfo; i++)
1352 {
1353 /* For now, the only accepted policy identifier is the anyPolicy
1354 * identifier.
1355 * FIXME: the policy identifiers should be compared against the
1356 * cert's certificate policies extension, subject to the policy
1357 * mappings extension, and the policy constraints extension.
1358 * See RFC 5280, sections 4.2.1.4, 4.2.1.5, and 4.2.1.11.
1359 */
1360 if (strcmp(policies->rgPolicyInfo[i].pszPolicyIdentifier,
1361 szOID_ANY_CERT_POLICY))
1362 {
1363 FIXME("unsupported policy %s\n",
1364 policies->rgPolicyInfo[i].pszPolicyIdentifier);
1365 *errorStatus |= CERT_TRUST_INVALID_POLICY_CONSTRAINTS;
1366 }
1367 }
1368 }
1369
1370 static void CRYPT_CheckChainPolicies(PCERT_SIMPLE_CHAIN chain)
1371 {
1372 int i, j;
1373
1374 for (i = chain->cElement - 1; i > 0; i--)
1375 {
1376 CERT_POLICIES_INFO *policies;
1377
1378 if ((policies = CRYPT_GetPolicies(chain->rgpElement[i]->pCertContext)))
1379 {
1380 for (j = i - 1; j >= 0; j--)
1381 {
1382 DWORD errorStatus = 0;
1383
1384 CRYPT_CheckPolicies(policies,
1385 chain->rgpElement[j]->pCertContext->pCertInfo, &errorStatus);
1386 if (errorStatus)
1387 {
1388 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1389 errorStatus;
1390 CRYPT_CombineTrustStatus(&chain->TrustStatus,
1391 &chain->rgpElement[i]->TrustStatus);
1392 }
1393 }
1394 LocalFree(policies);
1395 }
1396 }
1397 }
1398
1399 static LPWSTR name_value_to_str(const CERT_NAME_BLOB *name)
1400 {
1401 DWORD len = cert_name_to_str_with_indent(X509_ASN_ENCODING, 0, name,
1402 CERT_SIMPLE_NAME_STR, NULL, 0);
1403 LPWSTR str = NULL;
1404
1405 if (len)
1406 {
1407 str = CryptMemAlloc(len * sizeof(WCHAR));
1408 if (str)
1409 cert_name_to_str_with_indent(X509_ASN_ENCODING, 0, name,
1410 CERT_SIMPLE_NAME_STR, str, len);
1411 }
1412 return str;
1413 }
1414
1415 static void dump_alt_name_entry(const CERT_ALT_NAME_ENTRY *entry)
1416 {
1417 LPWSTR str;
1418
1419 switch (entry->dwAltNameChoice)
1420 {
1421 case CERT_ALT_NAME_OTHER_NAME:
1422 TRACE_(chain)("CERT_ALT_NAME_OTHER_NAME, oid = %s\n",
1423 debugstr_a(entry->u.pOtherName->pszObjId));
1424 break;
1425 case CERT_ALT_NAME_RFC822_NAME:
1426 TRACE_(chain)("CERT_ALT_NAME_RFC822_NAME: %s\n",
1427 debugstr_w(entry->u.pwszRfc822Name));
1428 break;
1429 case CERT_ALT_NAME_DNS_NAME:
1430 TRACE_(chain)("CERT_ALT_NAME_DNS_NAME: %s\n",
1431 debugstr_w(entry->u.pwszDNSName));
1432 break;
1433 case CERT_ALT_NAME_DIRECTORY_NAME:
1434 str = name_value_to_str(&entry->u.DirectoryName);
1435 TRACE_(chain)("CERT_ALT_NAME_DIRECTORY_NAME: %s\n", debugstr_w(str));
1436 CryptMemFree(str);
1437 break;
1438 case CERT_ALT_NAME_URL:
1439 TRACE_(chain)("CERT_ALT_NAME_URL: %s\n", debugstr_w(entry->u.pwszURL));
1440 break;
1441 case CERT_ALT_NAME_IP_ADDRESS:
1442 TRACE_(chain)("CERT_ALT_NAME_IP_ADDRESS: %d bytes\n",
1443 entry->u.IPAddress.cbData);
1444 break;
1445 case CERT_ALT_NAME_REGISTERED_ID:
1446 TRACE_(chain)("CERT_ALT_NAME_REGISTERED_ID: %s\n",
1447 debugstr_a(entry->u.pszRegisteredID));
1448 break;
1449 default:
1450 TRACE_(chain)("dwAltNameChoice = %d\n", entry->dwAltNameChoice);
1451 }
1452 }
1453
1454 static void dump_alt_name(LPCSTR type, const CERT_EXTENSION *ext)
1455 {
1456 CERT_ALT_NAME_INFO *name;
1457 DWORD size;
1458
1459 TRACE_(chain)("%s:\n", type);
1460 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_ALTERNATE_NAME,
1461 ext->Value.pbData, ext->Value.cbData,
1462 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL, &name, &size))
1463 {
1464 DWORD i;
1465
1466 TRACE_(chain)("%d alt name entries:\n", name->cAltEntry);
1467 for (i = 0; i < name->cAltEntry; i++)
1468 dump_alt_name_entry(&name->rgAltEntry[i]);
1469 LocalFree(name);
1470 }
1471 }
1472
1473 static void dump_basic_constraints(const CERT_EXTENSION *ext)
1474 {
1475 CERT_BASIC_CONSTRAINTS_INFO *info;
1476 DWORD size = 0;
1477
1478 if (CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
1479 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
1480 NULL, &info, &size))
1481 {
1482 TRACE_(chain)("SubjectType: %02x\n", info->SubjectType.pbData[0]);
1483 TRACE_(chain)("%s path length constraint\n",
1484 info->fPathLenConstraint ? "has" : "doesn't have");
1485 TRACE_(chain)("path length=%d\n", info->dwPathLenConstraint);
1486 LocalFree(info);
1487 }
1488 }
1489
1490 static void dump_basic_constraints2(const CERT_EXTENSION *ext)
1491 {
1492 CERT_BASIC_CONSTRAINTS2_INFO constraints;
1493 DWORD size = sizeof(CERT_BASIC_CONSTRAINTS2_INFO);
1494
1495 if (CryptDecodeObjectEx(X509_ASN_ENCODING,
1496 szOID_BASIC_CONSTRAINTS2, ext->Value.pbData, ext->Value.cbData,
1497 0, NULL, &constraints, &size))
1498 {
1499 TRACE_(chain)("basic constraints:\n");
1500 TRACE_(chain)("can%s be a CA\n", constraints.fCA ? "" : "not");
1501 TRACE_(chain)("%s path length constraint\n",
1502 constraints.fPathLenConstraint ? "has" : "doesn't have");
1503 TRACE_(chain)("path length=%d\n", constraints.dwPathLenConstraint);
1504 }
1505 }
1506
1507 static void dump_key_usage(const CERT_EXTENSION *ext)
1508 {
1509 CRYPT_BIT_BLOB usage;
1510 DWORD size = sizeof(usage);
1511
1512 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_BITS, ext->Value.pbData,
1513 ext->Value.cbData, CRYPT_DECODE_NOCOPY_FLAG, NULL, &usage, &size))
1514 {
1515 #define trace_usage_bit(bits, bit) \
1516 if ((bits) & (bit)) TRACE_(chain)("%s\n", #bit)
1517 if (usage.cbData)
1518 {
1519 trace_usage_bit(usage.pbData[0], CERT_DIGITAL_SIGNATURE_KEY_USAGE);
1520 trace_usage_bit(usage.pbData[0], CERT_NON_REPUDIATION_KEY_USAGE);
1521 trace_usage_bit(usage.pbData[0], CERT_KEY_ENCIPHERMENT_KEY_USAGE);
1522 trace_usage_bit(usage.pbData[0], CERT_DATA_ENCIPHERMENT_KEY_USAGE);
1523 trace_usage_bit(usage.pbData[0], CERT_KEY_AGREEMENT_KEY_USAGE);
1524 trace_usage_bit(usage.pbData[0], CERT_KEY_CERT_SIGN_KEY_USAGE);
1525 trace_usage_bit(usage.pbData[0], CERT_CRL_SIGN_KEY_USAGE);
1526 trace_usage_bit(usage.pbData[0], CERT_ENCIPHER_ONLY_KEY_USAGE);
1527 }
1528 #undef trace_usage_bit
1529 if (usage.cbData > 1 && usage.pbData[1] & CERT_DECIPHER_ONLY_KEY_USAGE)
1530 TRACE_(chain)("CERT_DECIPHER_ONLY_KEY_USAGE\n");
1531 }
1532 }
1533
1534 static void dump_general_subtree(const CERT_GENERAL_SUBTREE *subtree)
1535 {
1536 dump_alt_name_entry(&subtree->Base);
1537 TRACE_(chain)("dwMinimum = %d, fMaximum = %d, dwMaximum = %d\n",
1538 subtree->dwMinimum, subtree->fMaximum, subtree->dwMaximum);
1539 }
1540
1541 static void dump_name_constraints(const CERT_EXTENSION *ext)
1542 {
1543 CERT_NAME_CONSTRAINTS_INFO *nameConstraints;
1544 DWORD size;
1545
1546 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME_CONSTRAINTS,
1547 ext->Value.pbData, ext->Value.cbData,
1548 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL, &nameConstraints,
1549 &size))
1550 {
1551 DWORD i;
1552
1553 TRACE_(chain)("%d permitted subtrees:\n",
1554 nameConstraints->cPermittedSubtree);
1555 for (i = 0; i < nameConstraints->cPermittedSubtree; i++)
1556 dump_general_subtree(&nameConstraints->rgPermittedSubtree[i]);
1557 TRACE_(chain)("%d excluded subtrees:\n",
1558 nameConstraints->cExcludedSubtree);
1559 for (i = 0; i < nameConstraints->cExcludedSubtree; i++)
1560 dump_general_subtree(&nameConstraints->rgExcludedSubtree[i]);
1561 LocalFree(nameConstraints);
1562 }
1563 }
1564
1565 static void dump_cert_policies(const CERT_EXTENSION *ext)
1566 {
1567 CERT_POLICIES_INFO *policies;
1568 DWORD size;
1569
1570 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_POLICIES,
1571 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
1572 &policies, &size))
1573 {
1574 DWORD i, j;
1575
1576 TRACE_(chain)("%d policies:\n", policies->cPolicyInfo);
1577 for (i = 0; i < policies->cPolicyInfo; i++)
1578 {
1579 TRACE_(chain)("policy identifier: %s\n",
1580 debugstr_a(policies->rgPolicyInfo[i].pszPolicyIdentifier));
1581 TRACE_(chain)("%d policy qualifiers:\n",
1582 policies->rgPolicyInfo[i].cPolicyQualifier);
1583 for (j = 0; j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
1584 TRACE_(chain)("%s\n", debugstr_a(
1585 policies->rgPolicyInfo[i].rgPolicyQualifier[j].
1586 pszPolicyQualifierId));
1587 }
1588 LocalFree(policies);
1589 }
1590 }
1591
1592 static void dump_enhanced_key_usage(const CERT_EXTENSION *ext)
1593 {
1594 CERT_ENHKEY_USAGE *usage;
1595 DWORD size;
1596
1597 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_ENHANCED_KEY_USAGE,
1598 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
1599 &usage, &size))
1600 {
1601 DWORD i;
1602
1603 TRACE_(chain)("%d usages:\n", usage->cUsageIdentifier);
1604 for (i = 0; i < usage->cUsageIdentifier; i++)
1605 TRACE_(chain)("%s\n", usage->rgpszUsageIdentifier[i]);
1606 LocalFree(usage);
1607 }
1608 }
1609
1610 static void dump_netscape_cert_type(const CERT_EXTENSION *ext)
1611 {
1612 CRYPT_BIT_BLOB usage;
1613 DWORD size = sizeof(usage);
1614
1615 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_BITS, ext->Value.pbData,
1616 ext->Value.cbData, CRYPT_DECODE_NOCOPY_FLAG, NULL, &usage, &size))
1617 {
1618 #define trace_cert_type_bit(bits, bit) \
1619 if ((bits) & (bit)) TRACE_(chain)("%s\n", #bit)
1620 if (usage.cbData)
1621 {
1622 trace_cert_type_bit(usage.pbData[0],
1623 NETSCAPE_SSL_CLIENT_AUTH_CERT_TYPE);
1624 trace_cert_type_bit(usage.pbData[0],
1625 NETSCAPE_SSL_SERVER_AUTH_CERT_TYPE);
1626 trace_cert_type_bit(usage.pbData[0], NETSCAPE_SMIME_CERT_TYPE);
1627 trace_cert_type_bit(usage.pbData[0], NETSCAPE_SIGN_CERT_TYPE);
1628 trace_cert_type_bit(usage.pbData[0], NETSCAPE_SSL_CA_CERT_TYPE);
1629 trace_cert_type_bit(usage.pbData[0], NETSCAPE_SMIME_CA_CERT_TYPE);
1630 trace_cert_type_bit(usage.pbData[0], NETSCAPE_SIGN_CA_CERT_TYPE);
1631 }
1632 #undef trace_cert_type_bit
1633 }
1634 }
1635
1636 static void dump_extension(const CERT_EXTENSION *ext)
1637 {
1638 TRACE_(chain)("%s (%scritical)\n", debugstr_a(ext->pszObjId),
1639 ext->fCritical ? "" : "not ");
1640 if (!strcmp(ext->pszObjId, szOID_SUBJECT_ALT_NAME))
1641 dump_alt_name("subject alt name", ext);
1642 else if (!strcmp(ext->pszObjId, szOID_ISSUER_ALT_NAME))
1643 dump_alt_name("issuer alt name", ext);
1644 else if (!strcmp(ext->pszObjId, szOID_BASIC_CONSTRAINTS))
1645 dump_basic_constraints(ext);
1646 else if (!strcmp(ext->pszObjId, szOID_KEY_USAGE))
1647 dump_key_usage(ext);
1648 else if (!strcmp(ext->pszObjId, szOID_SUBJECT_ALT_NAME2))
1649 dump_alt_name("subject alt name 2", ext);
1650 else if (!strcmp(ext->pszObjId, szOID_ISSUER_ALT_NAME2))
1651 dump_alt_name("issuer alt name 2", ext);
1652 else if (!strcmp(ext->pszObjId, szOID_BASIC_CONSTRAINTS2))
1653 dump_basic_constraints2(ext);
1654 else if (!strcmp(ext->pszObjId, szOID_NAME_CONSTRAINTS))
1655 dump_name_constraints(ext);
1656 else if (!strcmp(ext->pszObjId, szOID_CERT_POLICIES))
1657 dump_cert_policies(ext);
1658 else if (!strcmp(ext->pszObjId, szOID_ENHANCED_KEY_USAGE))
1659 dump_enhanced_key_usage(ext);
1660 else if (!strcmp(ext->pszObjId, szOID_NETSCAPE_CERT_TYPE))
1661 dump_netscape_cert_type(ext);
1662 }
1663
1664 static LPCWSTR filetime_to_str(const FILETIME *time)
1665 {
1666 static WCHAR date[80];
1667 WCHAR dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
1668 SYSTEMTIME sysTime;
1669
1670 if (!time) return NULL;
1671
1672 GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
1673 sizeof(dateFmt) / sizeof(dateFmt[0]));
1674 FileTimeToSystemTime(time, &sysTime);
1675 GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
1676 sizeof(date) / sizeof(date[0]));
1677 return date;
1678 }
1679
1680 static void dump_element(PCCERT_CONTEXT cert)
1681 {
1682 LPWSTR name = NULL;
1683 DWORD len, i;
1684
1685 TRACE_(chain)("%p: version %d\n", cert, cert->pCertInfo->dwVersion);
1686 len = CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1687 CERT_NAME_ISSUER_FLAG, NULL, NULL, 0);
1688 name = CryptMemAlloc(len * sizeof(WCHAR));
1689 if (name)
1690 {
1691 CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1692 CERT_NAME_ISSUER_FLAG, NULL, name, len);
1693 TRACE_(chain)("issued by %s\n", debugstr_w(name));
1694 CryptMemFree(name);
1695 }
1696 len = CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL,
1697 NULL, 0);
1698 name = CryptMemAlloc(len * sizeof(WCHAR));
1699 if (name)
1700 {
1701 CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL,
1702 name, len);
1703 TRACE_(chain)("issued to %s\n", debugstr_w(name));
1704 CryptMemFree(name);
1705 }
1706 TRACE_(chain)("valid from %s to %s\n",
1707 debugstr_w(filetime_to_str(&cert->pCertInfo->NotBefore)),
1708 debugstr_w(filetime_to_str(&cert->pCertInfo->NotAfter)));
1709 TRACE_(chain)("%d extensions\n", cert->pCertInfo->cExtension);
1710 for (i = 0; i < cert->pCertInfo->cExtension; i++)
1711 dump_extension(&cert->pCertInfo->rgExtension[i]);
1712 }
1713
1714 static BOOL CRYPT_KeyUsageValid(PCertificateChainEngine engine,
1715 PCCERT_CONTEXT cert, BOOL isRoot, BOOL isCA, DWORD index)
1716 {
1717 PCERT_EXTENSION ext;
1718 BOOL ret;
1719 BYTE usageBits = 0;
1720
1721 ext = CertFindExtension(szOID_KEY_USAGE, cert->pCertInfo->cExtension,
1722 cert->pCertInfo->rgExtension);
1723 if (ext)
1724 {
1725 CRYPT_BIT_BLOB usage;
1726 DWORD size = sizeof(usage);
1727
1728 ret = CryptDecodeObjectEx(cert->dwCertEncodingType, X509_BITS,
1729 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_NOCOPY_FLAG, NULL,
1730 &usage, &size);
1731 if (!ret)
1732 return FALSE;
1733 else if (usage.cbData > 2)
1734 {
1735 /* The key usage extension only defines 9 bits => no more than 2
1736 * bytes are needed to encode all known usages.
1737 */
1738 return FALSE;
1739 }
1740 else
1741 {
1742 /* The only bit relevant to chain validation is the keyCertSign
1743 * bit, which is always in the least significant byte of the
1744 * key usage bits.
1745 */
1746 usageBits = usage.pbData[usage.cbData - 1];
1747 }
1748 }
1749 if (isCA)
1750 {
1751 if (!ext)
1752 {
1753 /* MS appears to violate RFC 5280, section 4.2.1.3 (Key Usage)
1754 * here. Quoting the RFC:
1755 * "This [key usage] extension MUST appear in certificates that
1756 * contain public keys that are used to validate digital signatures
1757 * on other public key certificates or CRLs."
1758 * MS appears to accept certs that do not contain key usage
1759 * extensions as CA certs. V1 and V2 certificates did not have
1760 * extensions, and many root certificates are V1 certificates, so
1761 * perhaps this is prudent. On the other hand, MS also accepts V3
1762 * certs without key usage extensions. We are more restrictive:
1763 * we accept locally installed V1 or V2 certs as CA certs.
1764 * We also accept a lack of key usage extension on root certs,
1765 * which is implied in RFC 5280, section 6.1: the trust anchor's
1766 * only requirement is that it was used to issue the next
1767 * certificate in the chain.
1768 */
1769 if (isRoot)
1770 ret = TRUE;
1771 else if (cert->pCertInfo->dwVersion == CERT_V1 ||
1772 cert->pCertInfo->dwVersion == CERT_V2)
1773 {
1774 PCCERT_CONTEXT localCert = CRYPT_FindCertInStore(
1775 engine->hWorld, cert);
1776
1777 ret = localCert != NULL;
1778 CertFreeCertificateContext(localCert);
1779 }
1780 else
1781 ret = FALSE;
1782 if (!ret)
1783 WARN_(chain)("no key usage extension on a CA cert\n");
1784 }
1785 else
1786 {
1787 if (!(usageBits & CERT_KEY_CERT_SIGN_KEY_USAGE))
1788 {
1789 WARN_(chain)("keyCertSign not asserted on a CA cert\n");
1790 ret = FALSE;
1791 }
1792 else
1793 ret = TRUE;
1794 }
1795 }
1796 else
1797 {
1798 if (ext && (usageBits & CERT_KEY_CERT_SIGN_KEY_USAGE))
1799 {
1800 WARN_(chain)("keyCertSign asserted on a non-CA cert\n");
1801 ret = FALSE;
1802 }
1803 else
1804 ret = TRUE;
1805 }
1806 return ret;
1807 }
1808
1809 static BOOL CRYPT_CriticalExtensionsSupported(PCCERT_CONTEXT cert)
1810 {
1811 BOOL ret = TRUE;
1812 DWORD i;
1813
1814 for (i = 0; ret && i < cert->pCertInfo->cExtension; i++)
1815 {
1816 if (cert->pCertInfo->rgExtension[i].fCritical)
1817 {
1818 LPCSTR oid = cert->pCertInfo->rgExtension[i].pszObjId;
1819
1820 if (!strcmp(oid, szOID_BASIC_CONSTRAINTS))
1821 ret = TRUE;
1822 else if (!strcmp(oid, szOID_BASIC_CONSTRAINTS2))
1823 ret = TRUE;
1824 else if (!strcmp(oid, szOID_NAME_CONSTRAINTS))
1825 ret = TRUE;
1826 else if (!strcmp(oid, szOID_KEY_USAGE))
1827 ret = TRUE;
1828 else if (!strcmp(oid, szOID_SUBJECT_ALT_NAME))
1829 ret = TRUE;
1830 else if (!strcmp(oid, szOID_SUBJECT_ALT_NAME2))
1831 ret = TRUE;
1832 else if (!strcmp(oid, szOID_CERT_POLICIES))
1833 ret = TRUE;
1834 else if (!strcmp(oid, szOID_ENHANCED_KEY_USAGE))
1835 ret = TRUE;
1836 else
1837 {
1838 FIXME("unsupported critical extension %s\n",
1839 debugstr_a(oid));
1840 ret = FALSE;
1841 }
1842 }
1843 }
1844 return ret;
1845 }
1846
1847 static BOOL CRYPT_IsCertVersionValid(PCCERT_CONTEXT cert)
1848 {
1849 BOOL ret = TRUE;
1850
1851 /* Checks whether the contents of the cert match the cert's version. */
1852 switch (cert->pCertInfo->dwVersion)
1853 {
1854 case CERT_V1:
1855 /* A V1 cert may not contain unique identifiers. See RFC 5280,
1856 * section 4.1.2.8:
1857 * "These fields MUST only appear if the version is 2 or 3 (Section
1858 * 4.1.2.1). These fields MUST NOT appear if the version is 1."
1859 */
1860 if (cert->pCertInfo->IssuerUniqueId.cbData ||
1861 cert->pCertInfo->SubjectUniqueId.cbData)
1862 ret = FALSE;
1863 /* A V1 cert may not contain extensions. See RFC 5280, section 4.1.2.9:
1864 * "This field MUST only appear if the version is 3 (Section 4.1.2.1)."
1865 */
1866 if (cert->pCertInfo->cExtension)
1867 ret = FALSE;
1868 break;
1869 case CERT_V2:
1870 /* A V2 cert may not contain extensions. See RFC 5280, section 4.1.2.9:
1871 * "This field MUST only appear if the version is 3 (Section 4.1.2.1)."
1872 */
1873 if (cert->pCertInfo->cExtension)
1874 ret = FALSE;
1875 break;
1876 case CERT_V3:
1877 /* Do nothing, all fields are allowed for V3 certs */
1878 break;
1879 default:
1880 WARN_(chain)("invalid cert version %d\n", cert->pCertInfo->dwVersion);
1881 ret = FALSE;
1882 }
1883 return ret;
1884 }
1885
1886 static void CRYPT_CheckSimpleChain(PCertificateChainEngine engine,
1887 PCERT_SIMPLE_CHAIN chain, LPFILETIME time)
1888 {
1889 PCERT_CHAIN_ELEMENT rootElement = chain->rgpElement[chain->cElement - 1];
1890 int i;
1891 BOOL pathLengthConstraintViolated = FALSE;
1892 CERT_BASIC_CONSTRAINTS2_INFO constraints = { FALSE, FALSE, 0 };
1893
1894 TRACE_(chain)("checking chain with %d elements for time %s\n",
1895 chain->cElement, debugstr_w(filetime_to_str(time)));
1896 for (i = chain->cElement - 1; i >= 0; i--)
1897 {
1898 BOOL isRoot;
1899
1900 if (TRACE_ON(chain))
1901 dump_element(chain->rgpElement[i]->pCertContext);
1902 if (i == chain->cElement - 1)
1903 isRoot = CRYPT_IsCertificateSelfSigned(
1904 chain->rgpElement[i]->pCertContext);
1905 else
1906 isRoot = FALSE;
1907 if (!CRYPT_IsCertVersionValid(chain->rgpElement[i]->pCertContext))
1908 {
1909 /* MS appears to accept certs whose versions don't match their
1910 * contents, so there isn't an appropriate error code.
1911 */
1912 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1913 CERT_TRUST_INVALID_EXTENSION;
1914 }
1915 if (CertVerifyTimeValidity(time,
1916 chain->rgpElement[i]->pCertContext->pCertInfo) != 0)
1917 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1918 CERT_TRUST_IS_NOT_TIME_VALID;
1919 if (i != 0)
1920 {
1921 /* Check the signature of the cert this issued */
1922 if (!CryptVerifyCertificateSignatureEx(0, X509_ASN_ENCODING,
1923 CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT,
1924 (void *)chain->rgpElement[i - 1]->pCertContext,
1925 CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT,
1926 (void *)chain->rgpElement[i]->pCertContext, 0, NULL))
1927 chain->rgpElement[i - 1]->TrustStatus.dwErrorStatus |=
1928 CERT_TRUST_IS_NOT_SIGNATURE_VALID;
1929 /* Once a path length constraint has been violated, every remaining
1930 * CA cert's basic constraints is considered invalid.
1931 */
1932 if (pathLengthConstraintViolated)
1933 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1934 CERT_TRUST_INVALID_BASIC_CONSTRAINTS;
1935 else if (!CRYPT_CheckBasicConstraintsForCA(engine,
1936 chain->rgpElement[i]->pCertContext, &constraints, i - 1, isRoot,
1937 &pathLengthConstraintViolated))
1938 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1939 CERT_TRUST_INVALID_BASIC_CONSTRAINTS;
1940 else if (constraints.fPathLenConstraint &&
1941 constraints.dwPathLenConstraint)
1942 {
1943 /* This one's valid - decrement max length */
1944 constraints.dwPathLenConstraint--;
1945 }
1946 }
1947 else
1948 {
1949 /* Check whether end cert has a basic constraints extension */
1950 if (!CRYPT_DecodeBasicConstraints(
1951 chain->rgpElement[i]->pCertContext, &constraints, FALSE))
1952 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1953 CERT_TRUST_INVALID_BASIC_CONSTRAINTS;
1954 }
1955 if (!CRYPT_KeyUsageValid(engine, chain->rgpElement[i]->pCertContext,
1956 isRoot, constraints.fCA, i))
1957 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1958 CERT_TRUST_IS_NOT_VALID_FOR_USAGE;
1959 if (CRYPT_IsSimpleChainCyclic(chain))
1960 {
1961 /* If the chain is cyclic, then the path length constraints
1962 * are violated, because the chain is infinitely long.
1963 */
1964 pathLengthConstraintViolated = TRUE;
1965 chain->TrustStatus.dwErrorStatus |=
1966 CERT_TRUST_IS_PARTIAL_CHAIN |
1967 CERT_TRUST_INVALID_BASIC_CONSTRAINTS;
1968 }
1969 /* Check whether every critical extension is supported */
1970 if (!CRYPT_CriticalExtensionsSupported(
1971 chain->rgpElement[i]->pCertContext))
1972 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1973 CERT_TRUST_INVALID_EXTENSION;
1974 CRYPT_CombineTrustStatus(&chain->TrustStatus,
1975 &chain->rgpElement[i]->TrustStatus);
1976 }
1977 CRYPT_CheckChainNameConstraints(chain);
1978 CRYPT_CheckChainPolicies(chain);
1979 if (CRYPT_IsCertificateSelfSigned(rootElement->pCertContext))
1980 {
1981 rootElement->TrustStatus.dwInfoStatus |=
1982 CERT_TRUST_IS_SELF_SIGNED | CERT_TRUST_HAS_NAME_MATCH_ISSUER;
1983 CRYPT_CheckRootCert(engine->hRoot, rootElement);
1984 }
1985 CRYPT_CombineTrustStatus(&chain->TrustStatus, &rootElement->TrustStatus);
1986 }
1987
1988 static PCCERT_CONTEXT CRYPT_GetIssuer(HCERTSTORE store, PCCERT_CONTEXT subject,
1989 PCCERT_CONTEXT prevIssuer, DWORD *infoStatus)
1990 {
1991 PCCERT_CONTEXT issuer = NULL;
1992 PCERT_EXTENSION ext;
1993 DWORD size;
1994
1995 *infoStatus = 0;
1996 if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER,
1997 subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)))
1998 {
1999 CERT_AUTHORITY_KEY_ID_INFO *info;
2000 BOOL ret;
2001
2002 ret = CryptDecodeObjectEx(subject->dwCertEncodingType,
2003 X509_AUTHORITY_KEY_ID, ext->Value.pbData, ext->Value.cbData,
2004 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
2005 &info, &size);
2006 if (ret)
2007 {
2008 CERT_ID id;
2009
2010 if (info->CertIssuer.cbData && info->CertSerialNumber.cbData)
2011 {
2012 id.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
2013 memcpy(&id.u.IssuerSerialNumber.Issuer, &info->CertIssuer,
2014 sizeof(CERT_NAME_BLOB));
2015 memcpy(&id.u.IssuerSerialNumber.SerialNumber,
2016 &info->CertSerialNumber, sizeof(CRYPT_INTEGER_BLOB));
2017 issuer = CertFindCertificateInStore(store,
2018 subject->dwCertEncodingType, 0, CERT_FIND_CERT_ID, &id,
2019 prevIssuer);
2020 if (issuer)
2021 {
2022 TRACE_(chain)("issuer found by issuer/serial number\n");
2023 *infoStatus = CERT_TRUST_HAS_EXACT_MATCH_ISSUER;
2024 }
2025 }
2026 else if (info->KeyId.cbData)
2027 {
2028 id.dwIdChoice = CERT_ID_KEY_IDENTIFIER;
2029 memcpy(&id.u.KeyId, &info->KeyId, sizeof(CRYPT_HASH_BLOB));
2030 issuer = CertFindCertificateInStore(store,
2031 subject->dwCertEncodingType, 0, CERT_FIND_CERT_ID, &id,
2032 prevIssuer);
2033 if (issuer)
2034 {
2035 TRACE_(chain)("issuer found by key id\n");
2036 *infoStatus = CERT_TRUST_HAS_KEY_MATCH_ISSUER;
2037 }
2038 }
2039 LocalFree(info);
2040 }
2041 }
2042 else if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER2,
2043 subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)))
2044 {
2045 CERT_AUTHORITY_KEY_ID2_INFO *info;
2046 BOOL ret;
2047
2048 ret = CryptDecodeObjectEx(subject->dwCertEncodingType,
2049 X509_AUTHORITY_KEY_ID2, ext->Value.pbData, ext->Value.cbData,
2050 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
2051 &info, &size);
2052 if (ret)
2053 {
2054 CERT_ID id;
2055
2056 if (info->AuthorityCertIssuer.cAltEntry &&
2057 info->AuthorityCertSerialNumber.cbData)
2058 {
2059 PCERT_ALT_NAME_ENTRY directoryName = NULL;
2060 DWORD i;
2061
2062 for (i = 0; !directoryName &&
2063 i < info->AuthorityCertIssuer.cAltEntry; i++)
2064 if (info->AuthorityCertIssuer.rgAltEntry[i].dwAltNameChoice
2065 == CERT_ALT_NAME_DIRECTORY_NAME)
2066 directoryName =
2067 &info->AuthorityCertIssuer.rgAltEntry[i];
2068 if (directoryName)
2069 {
2070 id.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
2071 memcpy(&id.u.IssuerSerialNumber.Issuer,
2072 &directoryName->u.DirectoryName, sizeof(CERT_NAME_BLOB));
2073 memcpy(&id.u.IssuerSerialNumber.SerialNumber,
2074 &info->AuthorityCertSerialNumber,
2075 sizeof(CRYPT_INTEGER_BLOB));
2076 issuer = CertFindCertificateInStore(store,
2077 subject->dwCertEncodingType, 0, CERT_FIND_CERT_ID, &id,
2078 prevIssuer);
2079 if (issuer)
2080 {
2081 TRACE_(chain)("issuer found by directory name\n");
2082 *infoStatus = CERT_TRUST_HAS_EXACT_MATCH_ISSUER;
2083 }
2084 }
2085 else
2086 FIXME("no supported name type in authority key id2\n");
2087 }
2088 else if (info->KeyId.cbData)
2089 {
2090 id.dwIdChoice = CERT_ID_KEY_IDENTIFIER;
2091 memcpy(&id.u.KeyId, &info->KeyId, sizeof(CRYPT_HASH_BLOB));
2092 issuer = CertFindCertificateInStore(store,
2093 subject->dwCertEncodingType, 0, CERT_FIND_CERT_ID, &id,
2094 prevIssuer);
2095 if (issuer)
2096 {
2097 TRACE_(chain)("issuer found by key id\n");
2098 *infoStatus = CERT_TRUST_HAS_KEY_MATCH_ISSUER;
2099 }
2100 }
2101 LocalFree(info);
2102 }
2103 }
2104 else
2105 {
2106 issuer = CertFindCertificateInStore(store,
2107 subject->dwCertEncodingType, 0, CERT_FIND_SUBJECT_NAME,
2108 &subject->pCertInfo->Issuer, prevIssuer);
2109 TRACE_(chain)("issuer found by name\n");
2110 *infoStatus = CERT_TRUST_HAS_NAME_MATCH_ISSUER;
2111 }
2112 return issuer;
2113 }
2114
2115 /* Builds a simple chain by finding an issuer for the last cert in the chain,
2116 * until reaching a self-signed cert, or until no issuer can be found.
2117 */
2118 static BOOL CRYPT_BuildSimpleChain(const CertificateChainEngine *engine,
2119 HCERTSTORE world, PCERT_SIMPLE_CHAIN chain)
2120 {
2121 BOOL ret = TRUE;
2122 PCCERT_CONTEXT cert = chain->rgpElement[chain->cElement - 1]->pCertContext;
2123
2124 while (ret && !CRYPT_IsSimpleChainCyclic(chain) &&
2125 !CRYPT_IsCertificateSelfSigned(cert))
2126 {
2127 PCCERT_CONTEXT issuer = CRYPT_GetIssuer(world, cert, NULL,
2128 &chain->rgpElement[chain->cElement - 1]->TrustStatus.dwInfoStatus);
2129
2130 if (issuer)
2131 {
2132 ret = CRYPT_AddCertToSimpleChain(engine, chain, issuer,
2133 chain->rgpElement[chain->cElement - 1]->TrustStatus.dwInfoStatus);
2134 /* CRYPT_AddCertToSimpleChain add-ref's the issuer, so free it to
2135 * close the enumeration that found it
2136 */
2137 CertFreeCertificateContext(issuer);
2138 cert = issuer;
2139 }
2140 else
2141 {
2142 TRACE_(chain)("Couldn't find issuer, halting chain creation\n");
2143 chain->TrustStatus.dwErrorStatus |= CERT_TRUST_IS_PARTIAL_CHAIN;
2144 break;
2145 }
2146 }
2147 return ret;
2148 }
2149
2150 static BOOL CRYPT_GetSimpleChainForCert(PCertificateChainEngine engine,
2151 HCERTSTORE world, PCCERT_CONTEXT cert, LPFILETIME pTime,
2152 PCERT_SIMPLE_CHAIN *ppChain)
2153 {
2154 BOOL ret = FALSE;
2155 PCERT_SIMPLE_CHAIN chain;
2156
2157 TRACE("(%p, %p, %p, %p)\n", engine, world, cert, pTime);
2158
2159 chain = CryptMemAlloc(sizeof(CERT_SIMPLE_CHAIN));
2160 if (chain)
2161 {
2162 memset(chain, 0, sizeof(CERT_SIMPLE_CHAIN));
2163 chain->cbSize = sizeof(CERT_SIMPLE_CHAIN);
2164 ret = CRYPT_AddCertToSimpleChain(engine, chain, cert, 0);
2165 if (ret)
2166 {
2167 ret = CRYPT_BuildSimpleChain(engine, world, chain);
2168 if (ret)
2169 CRYPT_CheckSimpleChain(engine, chain, pTime);
2170 }
2171 if (!ret)
2172 {
2173 CRYPT_FreeSimpleChain(chain);
2174 chain = NULL;
2175 }
2176 *ppChain = chain;
2177 }
2178 return ret;
2179 }
2180
2181 static BOOL CRYPT_BuildCandidateChainFromCert(HCERTCHAINENGINE hChainEngine,
2182 PCCERT_CONTEXT cert, LPFILETIME pTime, HCERTSTORE hAdditionalStore,
2183 PCertificateChain *ppChain)
2184 {
2185 PCertificateChainEngine engine = (PCertificateChainEngine)hChainEngine;
2186 PCERT_SIMPLE_CHAIN simpleChain = NULL;
2187 HCERTSTORE world;
2188 BOOL ret;
2189
2190 world = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0,
2191 CERT_STORE_CREATE_NEW_FLAG, NULL);
2192 CertAddStoreToCollection(world, engine->hWorld, 0, 0);
2193 if (hAdditionalStore)
2194 CertAddStoreToCollection(world, hAdditionalStore, 0, 0);
2195 /* FIXME: only simple chains are supported for now, as CTLs aren't
2196 * supported yet.
2197 */
2198 if ((ret = CRYPT_GetSimpleChainForCert(engine, world, cert, pTime,
2199 &simpleChain)))
2200 {
2201 PCertificateChain chain = CryptMemAlloc(sizeof(CertificateChain));
2202
2203 if (chain)
2204 {
2205 chain->ref = 1;
2206 chain->world = world;
2207 chain->context.cbSize = sizeof(CERT_CHAIN_CONTEXT);
2208 chain->context.TrustStatus = simpleChain->TrustStatus;
2209 chain->context.cChain = 1;
2210 chain->context.rgpChain = CryptMemAlloc(sizeof(PCERT_SIMPLE_CHAIN));
2211 chain->context.rgpChain[0] = simpleChain;
2212 chain->context.cLowerQualityChainContext = 0;
2213 chain->context.rgpLowerQualityChainContext = NULL;
2214 chain->context.fHasRevocationFreshnessTime = FALSE;
2215 chain->context.dwRevocationFreshnessTime = 0;
2216 }
2217 else
2218 ret = FALSE;
2219 *ppChain = chain;
2220 }
2221 return ret;
2222 }
2223
2224 /* Makes and returns a copy of chain, up to and including element iElement. */
2225 static PCERT_SIMPLE_CHAIN CRYPT_CopySimpleChainToElement(
2226 const CERT_SIMPLE_CHAIN *chain, DWORD iElement)
2227 {
2228 PCERT_SIMPLE_CHAIN copy = CryptMemAlloc(sizeof(CERT_SIMPLE_CHAIN));
2229
2230 if (copy)
2231 {
2232 memset(copy, 0, sizeof(CERT_SIMPLE_CHAIN));
2233 copy->cbSize = sizeof(CERT_SIMPLE_CHAIN);
2234 copy->rgpElement =
2235 CryptMemAlloc((iElement + 1) * sizeof(PCERT_CHAIN_ELEMENT));
2236 if (copy->rgpElement)
2237 {
2238 DWORD i;
2239 BOOL ret = TRUE;
2240
2241 memset(copy->rgpElement, 0,
2242 (iElement + 1) * sizeof(PCERT_CHAIN_ELEMENT));
2243 for (i = 0; ret && i <= iElement; i++)
2244 {
2245 PCERT_CHAIN_ELEMENT element =
2246 CryptMemAlloc(sizeof(CERT_CHAIN_ELEMENT));
2247
2248 if (element)
2249 {
2250 *element = *chain->rgpElement[i];
2251 element->pCertContext = CertDuplicateCertificateContext(
2252 chain->rgpElement[i]->pCertContext);
2253 /* Reset the trust status of the copied element, it'll get
2254 * rechecked after the new chain is done.
2255 */
2256 memset(&element->TrustStatus, 0, sizeof(CERT_TRUST_STATUS));
2257 copy->rgpElement[copy->cElement++] = element;
2258 }
2259 else
2260 ret = FALSE;
2261 }
2262 if (!ret)
2263 {
2264 for (i = 0; i <= iElement; i++)
2265 CryptMemFree(copy->rgpElement[i]);
2266 CryptMemFree(copy->rgpElement);
2267 CryptMemFree(copy);
2268 copy = NULL;
2269 }
2270 }
2271 else
2272 {
2273 CryptMemFree(copy);
2274 copy = NULL;
2275 }
2276 }
2277 return copy;
2278 }
2279
2280 static void CRYPT_FreeLowerQualityChains(PCertificateChain chain)
2281 {
2282 DWORD i;
2283
2284 for (i = 0; i < chain->context.cLowerQualityChainContext; i++)
2285 CertFreeCertificateChain(chain->context.rgpLowerQualityChainContext[i]);
2286 CryptMemFree(chain->context.rgpLowerQualityChainContext);
2287 chain->context.cLowerQualityChainContext = 0;
2288 chain->context.rgpLowerQualityChainContext = NULL;
2289 }
2290
2291 static void CRYPT_FreeChainContext(PCertificateChain chain)
2292 {
2293 DWORD i;
2294
2295 CRYPT_FreeLowerQualityChains(chain);
2296 for (i = 0; i < chain->context.cChain; i++)
2297 CRYPT_FreeSimpleChain(chain->context.rgpChain[i]);
2298 CryptMemFree(chain->context.rgpChain);
2299 CertCloseStore(chain->world, 0);
2300 CryptMemFree(chain);
2301 }
2302
2303 /* Makes and returns a copy of chain, up to and including element iElement of
2304 * simple chain iChain.
2305 */
2306 static PCertificateChain CRYPT_CopyChainToElement(PCertificateChain chain,
2307 DWORD iChain, DWORD iElement)
2308 {
2309 PCertificateChain copy = CryptMemAlloc(sizeof(CertificateChain));
2310
2311 if (copy)
2312 {
2313 copy->ref = 1;
2314 copy->world = CertDuplicateStore(chain->world);
2315 copy->context.cbSize = sizeof(CERT_CHAIN_CONTEXT);
2316 /* Leave the trust status of the copied chain unset, it'll get
2317 * rechecked after the new chain is done.
2318 */
2319 memset(&copy->context.TrustStatus, 0, sizeof(CERT_TRUST_STATUS));
2320 copy->context.cLowerQualityChainContext = 0;
2321 copy->context.rgpLowerQualityChainContext = NULL;
2322 copy->context.fHasRevocationFreshnessTime = FALSE;
2323 copy->context.dwRevocationFreshnessTime = 0;
2324 copy->context.rgpChain = CryptMemAlloc(
2325 (iChain + 1) * sizeof(PCERT_SIMPLE_CHAIN));
2326 if (copy->context.rgpChain)
2327 {
2328 BOOL ret = TRUE;
2329 DWORD i;
2330
2331 memset(copy->context.rgpChain, 0,
2332 (iChain + 1) * sizeof(PCERT_SIMPLE_CHAIN));
2333 if (iChain)
2334 {
2335 for (i = 0; ret && iChain && i < iChain - 1; i++)
2336 {
2337 copy->context.rgpChain[i] =
2338 CRYPT_CopySimpleChainToElement(chain->context.rgpChain[i],
2339 chain->context.rgpChain[i]->cElement - 1);
2340 if (!copy->context.rgpChain[i])
2341 ret = FALSE;
2342 }
2343 }
2344 else
2345 i = 0;
2346 if (ret)
2347 {
2348 copy->context.rgpChain[i] =
2349 CRYPT_CopySimpleChainToElement(chain->context.rgpChain[i],
2350 iElement);
2351 if (!copy->context.rgpChain[i])
2352 ret = FALSE;
2353 }
2354 if (!ret)
2355 {
2356 CRYPT_FreeChainContext(copy);
2357 copy = NULL;
2358 }
2359 else
2360 copy->context.cChain = iChain + 1;
2361 }
2362 else
2363 {
2364 CryptMemFree(copy);
2365 copy = NULL;
2366 }
2367 }
2368 return copy;
2369 }
2370
2371 static PCertificateChain CRYPT_BuildAlternateContextFromChain(
2372 HCERTCHAINENGINE hChainEngine, LPFILETIME pTime, HCERTSTORE hAdditionalStore,
2373 PCertificateChain chain)
2374 {
2375 PCertificateChainEngine engine = (PCertificateChainEngine)hChainEngine;
2376 PCertificateChain alternate;
2377
2378 TRACE("(%p, %p, %p, %p)\n", hChainEngine, pTime, hAdditionalStore, chain);
2379
2380 /* Always start with the last "lower quality" chain to ensure a consistent
2381 * order of alternate creation:
2382 */
2383 if (chain->context.cLowerQualityChainContext)
2384 chain = (PCertificateChain)chain->context.rgpLowerQualityChainContext[
2385 chain->context.cLowerQualityChainContext - 1];
2386 /* A chain with only one element can't have any alternates */
2387 if (chain->context.cChain <= 1 && chain->context.rgpChain[0]->cElement <= 1)
2388 alternate = NULL;
2389 else
2390 {
2391 DWORD i, j, infoStatus;
2392 PCCERT_CONTEXT alternateIssuer = NULL;
2393
2394 alternate = NULL;
2395 for (i = 0; !alternateIssuer && i < chain->context.cChain; i++)
2396 for (j = 0; !alternateIssuer &&
2397 j < chain->context.rgpChain[i]->cElement - 1; j++)
2398 {
2399 PCCERT_CONTEXT subject =
2400 chain->context.rgpChain[i]->rgpElement[j]->pCertContext;
2401 PCCERT_CONTEXT prevIssuer = CertDuplicateCertificateContext(
2402 chain->context.rgpChain[i]->rgpElement[j + 1]->pCertContext);
2403
2404 alternateIssuer = CRYPT_GetIssuer(prevIssuer->hCertStore,
2405 subject, prevIssuer, &infoStatus);
2406 }
2407 if (alternateIssuer)
2408 {
2409 i--;
2410 j--;
2411 alternate = CRYPT_CopyChainToElement(chain, i, j);
2412 if (alternate)
2413 {
2414 BOOL ret = CRYPT_AddCertToSimpleChain(engine,
2415 alternate->context.rgpChain[i], alternateIssuer, infoStatus);
2416
2417 /* CRYPT_AddCertToSimpleChain add-ref's the issuer, so free it
2418 * to close the enumeration that found it
2419 */
2420 CertFreeCertificateContext(alternateIssuer);
2421 if (ret)
2422 {
2423 ret = CRYPT_BuildSimpleChain(engine, alternate->world,
2424 alternate->context.rgpChain[i]);
2425 if (ret)
2426 CRYPT_CheckSimpleChain(engine,
2427 alternate->context.rgpChain[i], pTime);
2428 CRYPT_CombineTrustStatus(&alternate->context.TrustStatus,
2429 &alternate->context.rgpChain[i]->TrustStatus);
2430 }
2431 if (!ret)
2432 {
2433 CRYPT_FreeChainContext(alternate);
2434 alternate = NULL;
2435 }
2436 }
2437 }
2438 }
2439 TRACE("%p\n", alternate);
2440 return alternate;
2441 }
2442
2443 #define CHAIN_QUALITY_SIGNATURE_VALID 0x16
2444 #define CHAIN_QUALITY_TIME_VALID 8
2445 #define CHAIN_QUALITY_COMPLETE_CHAIN 4
2446 #define CHAIN_QUALITY_BASIC_CONSTRAINTS 2
2447 #define CHAIN_QUALITY_TRUSTED_ROOT 1
2448
2449 #define CHAIN_QUALITY_HIGHEST \
2450 CHAIN_QUALITY_SIGNATURE_VALID | CHAIN_QUALITY_TIME_VALID | \
2451 CHAIN_QUALITY_COMPLETE_CHAIN | CHAIN_QUALITY_BASIC_CONSTRAINTS | \
2452 CHAIN_QUALITY_TRUSTED_ROOT
2453
2454 #define IS_TRUST_ERROR_SET(TrustStatus, bits) \
2455 (TrustStatus)->dwErrorStatus & (bits)
2456
2457 static DWORD CRYPT_ChainQuality(const CertificateChain *chain)
2458 {
2459 DWORD quality = CHAIN_QUALITY_HIGHEST;
2460
2461 if (IS_TRUST_ERROR_SET(&chain->context.TrustStatus,
2462 CERT_TRUST_IS_UNTRUSTED_ROOT))
2463 quality &= ~CHAIN_QUALITY_TRUSTED_ROOT;
2464 if (IS_TRUST_ERROR_SET(&chain->context.TrustStatus,
2465 CERT_TRUST_INVALID_BASIC_CONSTRAINTS))
2466 quality &= ~CHAIN_QUALITY_BASIC_CONSTRAINTS;
2467 if (IS_TRUST_ERROR_SET(&chain->context.TrustStatus,
2468 CERT_TRUST_IS_PARTIAL_CHAIN))
2469 quality &= ~CHAIN_QUALITY_COMPLETE_CHAIN;
2470 if (IS_TRUST_ERROR_SET(&chain->context.TrustStatus,
2471 CERT_TRUST_IS_NOT_TIME_VALID | CERT_TRUST_IS_NOT_TIME_NESTED))
2472 quality &= ~CHAIN_QUALITY_TIME_VALID;
2473 if (IS_TRUST_ERROR_SET(&chain->context.TrustStatus,
2474 CERT_TRUST_IS_NOT_SIGNATURE_VALID))
2475 quality &= ~CHAIN_QUALITY_SIGNATURE_VALID;
2476 return quality;
2477 }
2478
2479 /* Chooses the highest quality chain among chain and its "lower quality"
2480 * alternate chains. Returns the highest quality chain, with all other
2481 * chains as lower quality chains of it.
2482 */
2483 static PCertificateChain CRYPT_ChooseHighestQualityChain(
2484 PCertificateChain chain)
2485 {
2486 DWORD i;
2487
2488 /* There are always only two chains being considered: chain, and an
2489 * alternate at chain->rgpLowerQualityChainContext[i]. If the alternate
2490 * has a higher quality than chain, the alternate gets assigned the lower
2491 * quality contexts, with chain taking the alternate's place among the
2492 * lower quality contexts.
2493 */
2494 for (i = 0; i < chain->context.cLowerQualityChainContext; i++)
2495 {
2496 PCertificateChain alternate =
2497 (PCertificateChain)chain->context.rgpLowerQualityChainContext[i];
2498
2499 if (CRYPT_ChainQuality(alternate) > CRYPT_ChainQuality(chain))
2500 {
2501 alternate->context.cLowerQualityChainContext =
2502 chain->context.cLowerQualityChainContext;
2503 alternate->context.rgpLowerQualityChainContext =
2504 chain->context.rgpLowerQualityChainContext;
2505 alternate->context.rgpLowerQualityChainContext[i] =
2506 (PCCERT_CHAIN_CONTEXT)chain;
2507 chain->context.cLowerQualityChainContext = 0;
2508 chain->context.rgpLowerQualityChainContext = NULL;
2509 chain = alternate;
2510 }
2511 }
2512 return chain;
2513 }
2514
2515 static BOOL CRYPT_AddAlternateChainToChain(PCertificateChain chain,
2516 const CertificateChain *alternate)
2517 {
2518 BOOL ret;
2519
2520 if (chain->context.cLowerQualityChainContext)
2521 chain->context.rgpLowerQualityChainContext =
2522 CryptMemRealloc(chain->context.rgpLowerQualityChainContext,
2523 (chain->context.cLowerQualityChainContext + 1) *
2524 sizeof(PCCERT_CHAIN_CONTEXT));
2525 else
2526 chain->context.rgpLowerQualityChainContext =
2527 CryptMemAlloc(sizeof(PCCERT_CHAIN_CONTEXT));
2528 if (chain->context.rgpLowerQualityChainContext)
2529 {
2530 chain->context.rgpLowerQualityChainContext[
2531 chain->context.cLowerQualityChainContext++] =
2532 (PCCERT_CHAIN_CONTEXT)alternate;
2533 ret = TRUE;
2534 }
2535 else
2536 ret = FALSE;
2537 return ret;
2538 }
2539
2540 static PCERT_CHAIN_ELEMENT CRYPT_FindIthElementInChain(
2541 const CERT_CHAIN_CONTEXT *chain, DWORD i)
2542 {
2543 DWORD j, iElement;
2544 PCERT_CHAIN_ELEMENT element = NULL;
2545
2546 for (j = 0, iElement = 0; !element && j < chain->cChain; j++)
2547 {
2548 if (iElement + chain->rgpChain[j]->cElement < i)
2549 iElement += chain->rgpChain[j]->cElement;
2550 else
2551 element = chain->rgpChain[j]->rgpElement[i - iElement];
2552 }
2553 return element;
2554 }
2555
2556 typedef struct _CERT_CHAIN_PARA_NO_EXTRA_FIELDS {
2557 DWORD cbSize;
2558 CERT_USAGE_MATCH RequestedUsage;
2559 } CERT_CHAIN_PARA_NO_EXTRA_FIELDS, *PCERT_CHAIN_PARA_NO_EXTRA_FIELDS;
2560
2561 static void CRYPT_VerifyChainRevocation(PCERT_CHAIN_CONTEXT chain,
2562 LPFILETIME pTime, const CERT_CHAIN_PARA *pChainPara, DWORD chainFlags)
2563 {
2564 DWORD cContext;
2565
2566 if (chainFlags & CERT_CHAIN_REVOCATION_CHECK_END_CERT)
2567 cContext = 1;
2568 else if ((chainFlags & CERT_CHAIN_REVOCATION_CHECK_CHAIN) ||
2569 (chainFlags & CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT))
2570 {
2571 DWORD i;
2572
2573 for (i = 0, cContext = 0; i < chain->cChain; i++)
2574 {
2575 if (i < chain->cChain - 1 ||
2576 chainFlags & CERT_CHAIN_REVOCATION_CHECK_CHAIN)
2577 cContext += chain->rgpChain[i]->cElement;
2578 else
2579 cContext += chain->rgpChain[i]->cElement - 1;
2580 }
2581 }
2582 else
2583 cContext = 0;
2584 if (cContext)
2585 {
2586 PCCERT_CONTEXT *contexts =
2587 CryptMemAlloc(cContext * sizeof(PCCERT_CONTEXT));
2588
2589 if (contexts)
2590 {
2591 DWORD i, j, iContext, revocationFlags;
2592 CERT_REVOCATION_PARA revocationPara = { sizeof(revocationPara), 0 };
2593 CERT_REVOCATION_STATUS revocationStatus =
2594 { sizeof(revocationStatus), 0 };
2595 BOOL ret;
2596
2597 for (i = 0, iContext = 0; iContext < cContext && i < chain->cChain;
2598 i++)
2599 {
2600 for (j = 0; iContext < cContext &&
2601 j < chain->rgpChain[i]->cElement; j++)
2602 contexts[iContext++] =
2603 chain->rgpChain[i]->rgpElement[j]->pCertContext;
2604 }
2605 revocationFlags = CERT_VERIFY_REV_CHAIN_FLAG;
2606 if (chainFlags & CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY)
2607 revocationFlags |= CERT_VERIFY_CACHE_ONLY_BASED_REVOCATION;
2608 if (chainFlags & CERT_CHAIN_REVOCATION_ACCUMULATIVE_TIMEOUT)
2609 revocationFlags |= CERT_VERIFY_REV_ACCUMULATIVE_TIMEOUT_FLAG;
2610 revocationPara.pftTimeToUse = pTime;
2611 if (pChainPara->cbSize == sizeof(CERT_CHAIN_PARA))
2612 {
2613 revocationPara.dwUrlRetrievalTimeout =
2614 pChainPara->dwUrlRetrievalTimeout;
2615 revocationPara.fCheckFreshnessTime =
2616 pChainPara->fCheckRevocationFreshnessTime;
2617 revocationPara.dwFreshnessTime =
2618 pChainPara->dwRevocationFreshnessTime;
2619 }
2620 ret = CertVerifyRevocation(X509_ASN_ENCODING,
2621 CERT_CONTEXT_REVOCATION_TYPE, cContext, (void **)contexts,
2622 revocationFlags, &revocationPara, &revocationStatus);
2623 if (!ret)
2624 {
2625 PCERT_CHAIN_ELEMENT element =
2626 CRYPT_FindIthElementInChain(chain, revocationStatus.dwIndex);
2627 DWORD error;
2628
2629 switch (revocationStatus.dwError)
2630 {
2631 case CRYPT_E_NO_REVOCATION_CHECK:
2632 case CRYPT_E_NO_REVOCATION_DLL:
2633 case CRYPT_E_NOT_IN_REVOCATION_DATABASE:
2634 /* If the revocation status is unknown, it's assumed to be
2635 * offline too.
2636 */
2637 error = CERT_TRUST_REVOCATION_STATUS_UNKNOWN |
2638 CERT_TRUST_IS_OFFLINE_REVOCATION;
2639 break;
2640 case CRYPT_E_REVOCATION_OFFLINE:
2641 error = CERT_TRUST_IS_OFFLINE_REVOCATION;
2642 break;
2643 case CRYPT_E_REVOKED:
2644 error = CERT_TRUST_IS_REVOKED;
2645 break;
2646 default:
2647 WARN("unmapped error %08x\n", revocationStatus.dwError);
2648 error = 0;
2649 }
2650 if (element)
2651 {
2652 /* FIXME: set element's pRevocationInfo member */
2653 element->TrustStatus.dwErrorStatus |= error;
2654 }
2655 chain->TrustStatus.dwErrorStatus |= error;
2656 }
2657 CryptMemFree(contexts);
2658 }
2659 }
2660 }
2661
2662 static void CRYPT_CheckUsages(PCERT_CHAIN_CONTEXT chain,
2663 const CERT_CHAIN_PARA *pChainPara)
2664 {
2665 if (pChainPara->cbSize >= sizeof(CERT_CHAIN_PARA_NO_EXTRA_FIELDS) &&
2666 pChainPara->RequestedUsage.Usage.cUsageIdentifier)
2667 {
2668 PCCERT_CONTEXT endCert;
2669 PCERT_EXTENSION ext;
2670 BOOL validForUsage;
2671
2672 /* A chain, if created, always includes the end certificate */
2673 endCert = chain->rgpChain[0]->rgpElement[0]->pCertContext;
2674 /* The extended key usage extension specifies how a certificate's
2675 * public key may be used. From RFC 5280, section 4.2.1.12:
2676 * "This extension indicates one or more purposes for which the
2677 * certified public key may be used, in addition to or in place of the
2678 * basic purposes indicated in the key usage extension."
2679 * If the extension is present, it only satisfies the requested usage
2680 * if that usage is included in the extension:
2681 * "If the extension is present, then the certificate MUST only be used
2682 * for one of the purposes indicated."
2683 * There is also the special anyExtendedKeyUsage OID, but it doesn't
2684 * have to be respected:
2685 * "Applications that require the presence of a particular purpose
2686 * MAY reject certificates that include the anyExtendedKeyUsage OID
2687 * but not the particular OID expected for the application."
2688 * For now, I'm being more conservative and ignoring the presence of
2689 * the anyExtendedKeyUsage OID.
2690 */
2691 if ((ext = CertFindExtension(szOID_ENHANCED_KEY_USAGE,
2692 endCert->pCertInfo->cExtension, endCert->pCertInfo->rgExtension)))
2693 {
2694 const CERT_ENHKEY_USAGE *requestedUsage =
2695 &pChainPara->RequestedUsage.Usage;
2696 CERT_ENHKEY_USAGE *usage;
2697 DWORD size;
2698
2699 if (CryptDecodeObjectEx(X509_ASN_ENCODING,
2700 X509_ENHANCED_KEY_USAGE, ext->Value.pbData, ext->Value.cbData,
2701 CRYPT_DECODE_ALLOC_FLAG, NULL, &usage, &size))
2702 {
2703 if (pChainPara->RequestedUsage.dwType == USAGE_MATCH_TYPE_AND)
2704 {
2705 DWORD i, j;
2706
2707 /* For AND matches, all usages must be present */
2708 validForUsage = TRUE;
2709 for (i = 0; validForUsage &&
2710 i < requestedUsage->cUsageIdentifier; i++)
2711 {
2712 BOOL match = FALSE;
2713
2714 for (j = 0; !match && j < usage->cUsageIdentifier; j++)
2715 match = !strcmp(usage->rgpszUsageIdentifier[j],
2716 requestedUsage->rgpszUsageIdentifier[i]);
2717 if (!match)
2718 validForUsage = FALSE;
2719 }
2720 }
2721 else
2722 {
2723 DWORD i, j;
2724
2725 /* For OR matches, any matching usage suffices */
2726 validForUsage = FALSE;
2727 for (i = 0; !validForUsage &&
2728 i < requestedUsage->cUsageIdentifier; i++)
2729 {
2730 for (j = 0; !validForUsage &&
2731 j < usage->cUsageIdentifier; j++)
2732 validForUsage =
2733 !strcmp(usage->rgpszUsageIdentifier[j],
2734 requestedUsage->rgpszUsageIdentifier[i]);
2735 }
2736 }
2737 LocalFree(usage);
2738 }
2739 else
2740 validForUsage = FALSE;
2741 }
2742 else
2743 {
2744 /* If the extension isn't present, any interpretation is valid:
2745 * "Certificate using applications MAY require that the extended
2746 * key usage extension be present and that a particular purpose
2747 * be indicated in order for the certificate to be acceptable to
2748 * that application."
2749 * Not all web sites include the extended key usage extension, so
2750 * accept chains without it.
2751 */
2752 TRACE_(chain)("requested usage from certificate with no usages\n");
2753 validForUsage = TRUE;
2754 }
2755 if (!validForUsage)
2756 {
2757 chain->TrustStatus.dwErrorStatus |=
2758 CERT_TRUST_IS_NOT_VALID_FOR_USAGE;
2759 chain->rgpChain[0]->rgpElement[0]->TrustStatus.dwErrorStatus |=
2760 CERT_TRUST_IS_NOT_VALID_FOR_USAGE;
2761 }
2762 }
2763 if (pChainPara->cbSize >= sizeof(CERT_CHAIN_PARA) &&
2764 pChainPara->RequestedIssuancePolicy.Usage.cUsageIdentifier)
2765 FIXME("unimplemented for RequestedIssuancePolicy\n");
2766 }
2767
2768 static void dump_usage_match(LPCSTR name, const CERT_USAGE_MATCH *usageMatch)
2769 {
2770 if (usageMatch->Usage.cUsageIdentifier)
2771 {
2772 DWORD i;
2773
2774 TRACE_(chain)("%s: %s\n", name,
2775 usageMatch->dwType == USAGE_MATCH_TYPE_AND ? "AND" : "OR");
2776 for (i = 0; i < usageMatch->Usage.cUsageIdentifier; i++)
2777 TRACE_(chain)("%s\n", usageMatch->Usage.rgpszUsageIdentifier[i]);
2778 }
2779 }
2780
2781 static void dump_chain_para(const CERT_CHAIN_PARA *pChainPara)
2782 {
2783 TRACE_(chain)("%d\n", pChainPara->cbSize);
2784 if (pChainPara->cbSize >= sizeof(CERT_CHAIN_PARA_NO_EXTRA_FIELDS))
2785 dump_usage_match("RequestedUsage", &pChainPara->RequestedUsage);
2786 if (pChainPara->cbSize >= sizeof(CERT_CHAIN_PARA))
2787 {
2788 dump_usage_match("RequestedIssuancePolicy",
2789 &pChainPara->RequestedIssuancePolicy);
2790 TRACE_(chain)("%d\n", pChainPara->dwUrlRetrievalTimeout);
2791 TRACE_(chain)("%d\n", pChainPara->fCheckRevocationFreshnessTime);
2792 TRACE_(chain)("%d\n", pChainPara->dwRevocationFreshnessTime);
2793 }
2794 }
2795
2796 BOOL WINAPI CertGetCertificateChain(HCERTCHAINENGINE hChainEngine,
2797 PCCERT_CONTEXT pCertContext, LPFILETIME pTime, HCERTSTORE hAdditionalStore,
2798 PCERT_CHAIN_PARA pChainPara, DWORD dwFlags, LPVOID pvReserved,
2799 PCCERT_CHAIN_CONTEXT* ppChainContext)
2800 {
2801 BOOL ret;
2802 PCertificateChain chain = NULL;
2803
2804 TRACE("(%p, %p, %p, %p, %p, %08x, %p, %p)\n", hChainEngine, pCertContext,
2805 pTime, hAdditionalStore, pChainPara, dwFlags, pvReserved, ppChainContext);
2806
2807 if (ppChainContext)
2808 *ppChainContext = NULL;
2809 if (!pChainPara)
2810 {
2811 SetLastError(E_INVALIDARG);
2812 return FALSE;
2813 }
2814 if (!pCertContext->pCertInfo->SignatureAlgorithm.pszObjId)
2815 {
2816 SetLastError(ERROR_INVALID_DATA);
2817 return FALSE;
2818 }
2819
2820 if (!hChainEngine)
2821 hChainEngine = CRYPT_GetDefaultChainEngine();
2822 if (TRACE_ON(chain))
2823 dump_chain_para(pChainPara);
2824 /* FIXME: what about HCCE_LOCAL_MACHINE? */
2825 ret = CRYPT_BuildCandidateChainFromCert(hChainEngine, pCertContext, pTime,
2826 hAdditionalStore, &chain);
2827 if (ret)
2828 {
2829 PCertificateChain alternate = NULL;
2830 PCERT_CHAIN_CONTEXT pChain;
2831
2832 do {
2833 alternate = CRYPT_BuildAlternateContextFromChain(hChainEngine,
2834 pTime, hAdditionalStore, chain);
2835
2836 /* Alternate contexts are added as "lower quality" contexts of
2837 * chain, to avoid loops in alternate chain creation.
2838 * The highest-quality chain is chosen at the end.
2839 */
2840 if (alternate)
2841 ret = CRYPT_AddAlternateChainToChain(chain, alternate);
2842 } while (ret && alternate);
2843 chain = CRYPT_ChooseHighestQualityChain(chain);
2844 if (!(dwFlags & CERT_CHAIN_RETURN_LOWER_QUALITY_CONTEXTS))
2845 CRYPT_FreeLowerQualityChains(chain);
2846 pChain = (PCERT_CHAIN_CONTEXT)chain;
2847 if (!pChain->TrustStatus.dwErrorStatus)
2848 CRYPT_VerifyChainRevocation(pChain, pTime, pChainPara, dwFlags);
2849 CRYPT_CheckUsages(pChain, pChainPara);
2850 TRACE_(chain)("error status: %08x\n",
2851 pChain->TrustStatus.dwErrorStatus);
2852 if (ppChainContext)
2853 *ppChainContext = pChain;
2854 else
2855 CertFreeCertificateChain(pChain);
2856 }
2857 TRACE("returning %d\n", ret);
2858 return ret;
2859 }
2860
2861 PCCERT_CHAIN_CONTEXT WINAPI CertDuplicateCertificateChain(
2862 PCCERT_CHAIN_CONTEXT pChainContext)
2863 {
2864 PCertificateChain chain = (PCertificateChain)pChainContext;
2865
2866 TRACE("(%p)\n", pChainContext);
2867
2868 if (chain)
2869 InterlockedIncrement(&chain->ref);
2870 return pChainContext;
2871 }
2872
2873 VOID WINAPI CertFreeCertificateChain(PCCERT_CHAIN_CONTEXT pChainContext)
2874 {
2875 PCertificateChain chain = (PCertificateChain)pChainContext;
2876
2877 TRACE("(%p)\n", pChainContext);
2878
2879 if (chain)
2880 {
2881 if (InterlockedDecrement(&chain->ref) == 0)
2882 CRYPT_FreeChainContext(chain);
2883 }
2884 }
2885
2886 static void find_element_with_error(PCCERT_CHAIN_CONTEXT chain, DWORD error,
2887 LONG *iChain, LONG *iElement)
2888 {
2889 DWORD i, j;
2890
2891 for (i = 0; i < chain->cChain; i++)
2892 for (j = 0; j < chain->rgpChain[i]->cElement; j++)
2893 if (chain->rgpChain[i]->rgpElement[j]->TrustStatus.dwErrorStatus &
2894 error)
2895 {
2896 *iChain = i;
2897 *iElement = j;
2898 return;
2899 }
2900 }
2901
2902 static BOOL WINAPI verify_base_policy(LPCSTR szPolicyOID,
2903 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
2904 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
2905 {
2906 pPolicyStatus->lChainIndex = pPolicyStatus->lElementIndex = -1;
2907 if (pChainContext->TrustStatus.dwErrorStatus &
2908 CERT_TRUST_IS_NOT_SIGNATURE_VALID)
2909 {
2910 pPolicyStatus->dwError = TRUST_E_CERT_SIGNATURE;
2911 find_element_with_error(pChainContext,
2912 CERT_TRUST_IS_NOT_SIGNATURE_VALID, &pPolicyStatus->lChainIndex,
2913 &pPolicyStatus->lElementIndex);
2914 }
2915 else if (pChainContext->TrustStatus.dwErrorStatus &
2916 CERT_TRUST_IS_UNTRUSTED_ROOT)
2917 {
2918 pPolicyStatus->dwError = CERT_E_UNTRUSTEDROOT;
2919 find_element_with_error(pChainContext,
2920 CERT_TRUST_IS_UNTRUSTED_ROOT, &pPolicyStatus->lChainIndex,
2921 &pPolicyStatus->lElementIndex);
2922 }
2923 else if (pChainContext->TrustStatus.dwErrorStatus & CERT_TRUST_IS_CYCLIC)
2924 {
2925 pPolicyStatus->dwError = CERT_E_CHAINING;
2926 find_element_with_error(pChainContext, CERT_TRUST_IS_CYCLIC,
2927 &pPolicyStatus->lChainIndex, &pPolicyStatus->lElementIndex);
2928 /* For a cyclic chain, which element is a cycle isn't meaningful */
2929 pPolicyStatus->lElementIndex = -1;
2930 }
2931 else
2932 pPolicyStatus->dwError = NO_ERROR;
2933 return TRUE;
2934 }
2935
2936 static BYTE msTestPubKey1[] = {
2937 0x30,0x47,0x02,0x40,0x81,0x55,0x22,0xb9,0x8a,0xa4,0x6f,0xed,0xd6,0xe7,0xd9,
2938 0x66,0x0f,0x55,0xbc,0xd7,0xcd,0xd5,0xbc,0x4e,0x40,0x02,0x21,0xa2,0xb1,0xf7,
2939 0x87,0x30,0x85,0x5e,0xd2,0xf2,0x44,0xb9,0xdc,0x9b,0x75,0xb6,0xfb,0x46,0x5f,
2940 0x42,0xb6,0x9d,0x23,0x36,0x0b,0xde,0x54,0x0f,0xcd,0xbd,0x1f,0x99,0x2a,0x10,
2941 0x58,0x11,0xcb,0x40,0xcb,0xb5,0xa7,0x41,0x02,0x03,0x01,0x00,0x01 };
2942 static BYTE msTestPubKey2[] = {
2943 0x30,0x47,0x02,0x40,0x9c,0x50,0x05,0x1d,0xe2,0x0e,0x4c,0x53,0xd8,0xd9,0xb5,
2944 0xe5,0xfd,0xe9,0xe3,0xad,0x83,0x4b,0x80,0x08,0xd9,0xdc,0xe8,0xe8,0x35,0xf8,
2945 0x11,0xf1,0xe9,0x9b,0x03,0x7a,0x65,0x64,0x76,0x35,0xce,0x38,0x2c,0xf2,0xb6,
2946 0x71,0x9e,0x06,0xd9,0xbf,0xbb,0x31,0x69,0xa3,0xf6,0x30,0xa0,0x78,0x7b,0x18,
2947 0xdd,0x50,0x4d,0x79,0x1e,0xeb,0x61,0xc1,0x02,0x03,0x01,0x00,0x01 };
2948
2949 static BOOL WINAPI verify_authenticode_policy(LPCSTR szPolicyOID,
2950 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
2951 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
2952 {
2953 BOOL ret = verify_base_policy(szPolicyOID, pChainContext, pPolicyPara,
2954 pPolicyStatus);
2955
2956 if (ret && pPolicyStatus->dwError == CERT_E_UNTRUSTEDROOT)
2957 {
2958 CERT_PUBLIC_KEY_INFO msPubKey = { { 0 } };
2959 BOOL isMSTestRoot = FALSE;
2960 PCCERT_CONTEXT failingCert =
2961 pChainContext->rgpChain[pPolicyStatus->lChainIndex]->
2962 rgpElement[pPolicyStatus->lElementIndex]->pCertContext;
2963 DWORD i;
2964 CRYPT_DATA_BLOB keyBlobs[] = {
2965 { sizeof(msTestPubKey1), msTestPubKey1 },
2966 { sizeof(msTestPubKey2), msTestPubKey2 },
2967 };
2968
2969 /* Check whether the root is an MS test root */
2970 for (i = 0; !isMSTestRoot && i < sizeof(keyBlobs) / sizeof(keyBlobs[0]);
2971 i++)
2972 {
2973 msPubKey.PublicKey.cbData = keyBlobs[i].cbData;
2974 msPubKey.PublicKey.pbData = keyBlobs[i].pbData;
2975 if (CertComparePublicKeyInfo(
2976 X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
2977 &failingCert->pCertInfo->SubjectPublicKeyInfo, &msPubKey))
2978 isMSTestRoot = TRUE;
2979 }
2980 if (isMSTestRoot)
2981 pPolicyStatus->dwError = CERT_E_UNTRUSTEDTESTROOT;
2982 }
2983 return ret;
2984 }
2985
2986 static BOOL WINAPI verify_basic_constraints_policy(LPCSTR szPolicyOID,
2987 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
2988 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
2989 {
2990 pPolicyStatus->lChainIndex = pPolicyStatus->lElementIndex = -1;
2991 if (pChainContext->TrustStatus.dwErrorStatus &
2992 CERT_TRUST_INVALID_BASIC_CONSTRAINTS)
2993 {
2994 pPolicyStatus->dwError = TRUST_E_BASIC_CONSTRAINTS;
2995 find_element_with_error(pChainContext,
2996 CERT_TRUST_INVALID_BASIC_CONSTRAINTS, &pPolicyStatus->lChainIndex,
2997 &pPolicyStatus->lElementIndex);
2998 }
2999 else
3000 pPolicyStatus->dwError = NO_ERROR;
3001 return TRUE;
3002 }
3003
3004 static BOOL match_dns_to_subject_alt_name(PCERT_EXTENSION ext,
3005 LPCWSTR server_name)
3006 {
3007 BOOL matches = FALSE;
3008 CERT_ALT_NAME_INFO *subjectName;
3009 DWORD size;
3010
3011 TRACE_(chain)("%s\n", debugstr_w(server_name));
3012 /* This could be spoofed by the embedded NULL vulnerability, since the
3013 * returned CERT_ALT_NAME_INFO doesn't have a way to indicate the
3014 * encoded length of a name. Fortunately CryptDecodeObjectEx fails if
3015 * the encoded form of the name contains a NULL.
3016 */
3017 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_ALTERNATE_NAME,
3018 ext->Value.pbData, ext->Value.cbData,
3019 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
3020 &subjectName, &size))
3021 {
3022 DWORD i;
3023
3024 /* RFC 5280 states that multiple instances of each name type may exist,
3025 * in section 4.2.1.6:
3026 * "Multiple name forms, and multiple instances of each name form,
3027 * MAY be included."
3028 * It doesn't specify the behavior in such cases, but both RFC 2818
3029 * and RFC 2595 explicitly accept a certificate if any name matches.
3030 */
3031 for (i = 0; !matches && i < subjectName->cAltEntry; i++)
3032 {
3033 if (subjectName->rgAltEntry[i].dwAltNameChoice ==
3034 CERT_ALT_NAME_DNS_NAME)
3035 {
3036 TRACE_(chain)("dNSName: %s\n", debugstr_w(
3037 subjectName->rgAltEntry[i].u.pwszDNSName));
3038 if (subjectName->rgAltEntry[i].u.pwszDNSName[0] == '*')
3039 {
3040 LPCWSTR server_name_dot;
3041
3042 /* Matching a wildcard: a wildcard matches a single name
3043 * component, which is terminated by a dot. RFC 1034
3044 * doesn't define whether multiple wildcards are allowed,
3045 * but I will assume that they are not until proven
3046 * otherwise. RFC 1034 also states that 'the "*" label
3047 * always matches at least one whole label and sometimes
3048 * more, but always whole labels.' Native crypt32 does not
3049 * match more than one label with a wildcard, so I do the
3050 * same here. Thus, a wildcard only accepts the first
3051 * label, then requires an exact match of the remaining
3052 * string.
3053 */
3054 server_name_dot = strchrW(server_name, '.');
3055 if (server_name_dot)
3056 {
3057 if (!strcmpiW(server_name_dot,
3058 subjectName->rgAltEntry[i].u.pwszDNSName + 1))
3059 matches = TRUE;
3060 }
3061 }
3062 else if (!strcmpiW(server_name,
3063 subjectName->rgAltEntry[i].u.pwszDNSName))
3064 matches = TRUE;
3065 }
3066 }
3067 LocalFree(subjectName);
3068 }
3069 return matches;
3070 }
3071
3072 static BOOL find_matching_domain_component(CERT_NAME_INFO *name,
3073 LPCWSTR component)
3074 {
3075 BOOL matches = FALSE;
3076 DWORD i, j;
3077
3078 for (i = 0; !matches && i < name->cRDN; i++)
3079 for (j = 0; j < name->rgRDN[i].cRDNAttr; j++)
3080 if (!strcmp(szOID_DOMAIN_COMPONENT,
3081 name->rgRDN[i].rgRDNAttr[j].pszObjId))
3082 {
3083 PCERT_RDN_ATTR attr;
3084
3085 attr = &name->rgRDN[i].rgRDNAttr[j];
3086 /* Compare with memicmpW rather than strcmpiW in order to avoid
3087 * a match with a string with an embedded NULL. The component
3088 * must match one domain component attribute's entire string
3089 * value with a case-insensitive match.
3090 */
3091 matches = !memicmpW(component, (LPWSTR)attr->Value.pbData,
3092 attr->Value.cbData / sizeof(WCHAR));
3093 }
3094 return matches;
3095 }
3096
3097 static BOOL match_domain_component(LPCWSTR allowed_component, DWORD allowed_len,
3098 LPCWSTR server_component, DWORD server_len, BOOL allow_wildcards,
3099 BOOL *see_wildcard)
3100 {
3101 LPCWSTR allowed_ptr, server_ptr;
3102 BOOL matches = TRUE;
3103
3104 *see_wildcard = FALSE;
3105 if (server_len < allowed_len)
3106 {
3107 WARN_(chain)("domain component %s too short for %s\n",
3108 debugstr_wn(server_component, server_len),
3109 debugstr_wn(allowed_component, allowed_len));
3110 /* A domain component can't contain a wildcard character, so a domain
3111 * component shorter than the allowed string can't produce a match.
3112 */
3113 return FALSE;
3114 }
3115 for (allowed_ptr = allowed_component, server_ptr = server_component;
3116 matches && allowed_ptr - allowed_component < allowed_len;
3117 allowed_ptr++, server_ptr++)
3118 {
3119 if (*allowed_ptr == '*')
3120 {
3121 if (allowed_ptr - allowed_component < allowed_len - 1)
3122 {
3123 WARN_(chain)("non-wildcard characters after wildcard not supported\n");
3124 matches = FALSE;
3125 }
3126 else if (!allow_wildcards)
3127 {
3128 WARN_(chain)("wildcard after non-wildcard component\n");
3129 matches = FALSE;
3130 }
3131 else
3132 {
3133 /* the preceding characters must have matched, so the rest of
3134 * the component also matches.
3135 */
3136 *see_wildcard = TRUE;
3137 break;
3138 }
3139 }
3140 matches = tolowerW(*allowed_ptr) == tolowerW(*server_ptr);
3141 }
3142 if (matches && server_ptr - server_component < server_len)
3143 {
3144 /* If there are unmatched characters in the server domain component,
3145 * the server domain only matches if the allowed string ended in a '*'.
3146 */
3147 matches = *allowed_ptr == '*';
3148 }
3149 return matches;
3150 }
3151
3152 static BOOL match_common_name(LPCWSTR server_name, PCERT_RDN_ATTR nameAttr)
3153 {
3154 LPCWSTR allowed = (LPCWSTR)nameAttr->Value.pbData;
3155 LPCWSTR allowed_component = allowed;
3156 DWORD allowed_len = nameAttr->Value.cbData / sizeof(WCHAR);
3157 LPCWSTR server_component = server_name;
3158 DWORD server_len = strlenW(server_name);
3159 BOOL matches = TRUE, allow_wildcards = TRUE;
3160
3161 TRACE_(chain)("CN = %s\n", debugstr_wn(allowed_component, allowed_len));
3162
3163 /* From RFC 2818 (HTTP over TLS), section 3.1:
3164 * "Names may contain the wildcard character * which is considered to match
3165 * any single domain name component or component fragment. E.g.,
3166 * *.a.com matches foo.a.com but not bar.foo.a.com. f*.com matches foo.com
3167 * but not bar.com."
3168 *
3169 * And from RFC 2595 (Using TLS with IMAP, POP3 and ACAP), section 2.4:
3170 * "A "*" wildcard character MAY be used as the left-most name component in
3171 * the certificate. For example, *.example.com would match a.example.com,
3172 * foo.example.com, etc. but would not match example.com."
3173 *
3174 * There are other protocols which use TLS, and none of them is
3175 * authoritative. This accepts certificates in common usage, e.g.
3176 * *.domain.com matches www.domain.com but not domain.com, and
3177 * www*.domain.com matches www1.domain.com but not mail.domain.com.
3178 */
3179 do {
3180 LPCWSTR allowed_dot, server_dot;
3181
3182 allowed_dot = memchrW(allowed_component, '.',
3183 allowed_len - (allowed_component - allowed));
3184 server_dot = memchrW(server_component, '.',
3185 server_len - (server_component - server_name));
3186 /* The number of components must match */
3187 if ((!allowed_dot && server_dot) || (allowed_dot && !server_dot))
3188 {
3189 if (!allowed_dot)
3190 WARN_(chain)("%s: too many components for CN=%s\n",
3191 debugstr_w(server_name), debugstr_wn(allowed, allowed_len));
3192 else
3193 WARN_(chain)("%s: not enough components for CN=%s\n",
3194 debugstr_w(server_name), debugstr_wn(allowed, allowed_len));
3195 matches = FALSE;
3196 }
3197 else
3198 {
3199 LPCWSTR allowed_end, server_end;
3200 BOOL has_wildcard;
3201
3202 allowed_end = allowed_dot ? allowed_dot : allowed + allowed_len;
3203 server_end = server_dot ? server_dot : server_name + server_len;
3204 matches = match_domain_component(allowed_component,
3205 allowed_end - allowed_component, server_component,
3206 server_end - server_component, allow_wildcards, &has_wildcard);
3207 /* Once a non-wildcard component is seen, no wildcard components
3208 * may follow
3209 */
3210 if (!has_wildcard)
3211 allow_wildcards = FALSE;
3212 if (matches)
3213 {
3214 allowed_component = allowed_dot ? allowed_dot + 1 : allowed_end;
3215 server_component = server_dot ? server_dot + 1 : server_end;
3216 }
3217 }
3218 } while (matches && allowed_component &&
3219 allowed_component - allowed < allowed_len &&
3220 server_component && server_component - server_name < server_len);
3221 TRACE_(chain)("returning %d\n", matches);
3222 return matches;
3223 }
3224
3225 static BOOL match_dns_to_subject_dn(PCCERT_CONTEXT cert, LPCWSTR server_name)
3226 {
3227 BOOL matches = FALSE;
3228 CERT_NAME_INFO *name;
3229 DWORD size;
3230
3231 TRACE_(chain)("%s\n", debugstr_w(server_name));
3232 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_UNICODE_NAME,
3233 cert->pCertInfo->Subject.pbData, cert->pCertInfo->Subject.cbData,
3234 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
3235 &name, &size))
3236 {
3237 /* If the subject distinguished name contains any name components,
3238 * make sure all of them are present.
3239 */
3240 if (CertFindRDNAttr(szOID_DOMAIN_COMPONENT, name))
3241 {
3242 LPCWSTR ptr = server_name;
3243
3244 matches = TRUE;
3245 do {
3246 LPCWSTR dot = strchrW(ptr, '.'), end;
3247 /* 254 is the maximum DNS label length, see RFC 1035 */
3248 WCHAR component[255];
3249 DWORD len;
3250
3251 end = dot ? dot : ptr + strlenW(ptr);
3252 len = end - ptr;
3253 if (len >= sizeof(component) / sizeof(component[0]))
3254 {
3255 WARN_(chain)("domain component %s too long\n",
3256 debugstr_wn(ptr, len));
3257 matches = FALSE;
3258 }
3259 else
3260 {
3261 memcpy(component, ptr, len * sizeof(WCHAR));
3262 component[len] = 0;
3263 matches = find_matching_domain_component(name, component);
3264 }
3265 ptr = dot ? dot + 1 : end;
3266 } while (matches && ptr && *ptr);
3267 }
3268 else
3269 {
3270 PCERT_RDN_ATTR attr;
3271
3272 /* If the certificate isn't using a DN attribute in the name, make
3273 * make sure the common name matches.
3274 */
3275 if ((attr = CertFindRDNAttr(szOID_COMMON_NAME, name)))
3276 matches = match_common_name(server_name, attr);
3277 }
3278 LocalFree(name);
3279 }
3280 return matches;
3281 }
3282
3283 static BOOL WINAPI verify_ssl_policy(LPCSTR szPolicyOID,
3284 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
3285 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
3286 {
3287 pPolicyStatus->lChainIndex = pPolicyStatus->lElementIndex = -1;
3288 if (pChainContext->TrustStatus.dwErrorStatus &
3289 CERT_TRUST_IS_NOT_SIGNATURE_VALID)
3290 {
3291 pPolicyStatus->dwError = TRUST_E_CERT_SIGNATURE;
3292 find_element_with_error(pChainContext,
3293 CERT_TRUST_IS_NOT_SIGNATURE_VALID, &pPolicyStatus->lChainIndex,
3294 &pPolicyStatus->lElementIndex);
3295 }
3296 else if (pChainContext->TrustStatus.dwErrorStatus &
3297 CERT_TRUST_IS_UNTRUSTED_ROOT)
3298 {
3299 pPolicyStatus->dwError = CERT_E_UNTRUSTEDROOT;
3300 find_element_with_error(pChainContext,
3301 CERT_TRUST_IS_UNTRUSTED_ROOT, &pPolicyStatus->lChainIndex,
3302 &pPolicyStatus->lElementIndex);
3303 }
3304 else if (pChainContext->TrustStatus.dwErrorStatus & CERT_TRUST_IS_CYCLIC)
3305 {
3306 pPolicyStatus->dwError = CERT_E_UNTRUSTEDROOT;
3307 find_element_with_error(pChainContext,
3308 CERT_TRUST_IS_CYCLIC, &pPolicyStatus->lChainIndex,
3309 &pPolicyStatus->lElementIndex);
3310 /* For a cyclic chain, which element is a cycle isn't meaningful */
3311 pPolicyStatus->lElementIndex = -1;
3312 }
3313 else if (pChainContext->TrustStatus.dwErrorStatus &
3314 CERT_TRUST_IS_NOT_TIME_VALID)
3315 {
3316 pPolicyStatus->dwError = CERT_E_EXPIRED;
3317 find_element_with_error(pChainContext,
3318 CERT_TRUST_IS_NOT_TIME_VALID, &pPolicyStatus->lChainIndex,
3319 &pPolicyStatus->lElementIndex);
3320 }
3321 else
3322 pPolicyStatus->dwError = NO_ERROR;
3323 /* We only need bother checking whether the name in the end certificate
3324 * matches if the chain is otherwise okay.
3325 */
3326 if (!pPolicyStatus->dwError && pPolicyPara &&
3327 pPolicyPara->cbSize >= sizeof(CERT_CHAIN_POLICY_PARA))
3328 {
3329 HTTPSPolicyCallbackData *sslPara = pPolicyPara->pvExtraPolicyPara;
3330
3331 if (sslPara && sslPara->u.cbSize >= sizeof(HTTPSPolicyCallbackData))
3332 {
3333 if (sslPara->dwAuthType == AUTHTYPE_SERVER &&
3334 sslPara->pwszServerName)
3335 {
3336 PCCERT_CONTEXT cert;
3337 PCERT_EXTENSION altNameExt;
3338 BOOL matches;
3339
3340 cert = pChainContext->rgpChain[0]->rgpElement[0]->pCertContext;
3341 altNameExt = get_subject_alt_name_ext(cert->pCertInfo);
3342 /* If the alternate name extension exists, the name it contains
3343 * is bound to the certificate, so make sure the name matches
3344 * it. Otherwise, look for the server name in the subject
3345 * distinguished name. RFC5280, section 4.2.1.6:
3346 * "Whenever such identities are to be bound into a
3347 * certificate, the subject alternative name (or issuer
3348 * alternative name) extension MUST be used; however, a DNS
3349 * name MAY also be represented in the subject field using the
3350 * domainComponent attribute."
3351 */
3352 if (altNameExt)
3353 matches = match_dns_to_subject_alt_name(altNameExt,
3354 sslPara->pwszServerName);
3355 else
3356 matches = match_dns_to_subject_dn(cert,
3357 sslPara->pwszServerName);
3358 if (!matches)
3359 {
3360 pPolicyStatus->dwError = CERT_E_CN_NO_MATCH;
3361 pPolicyStatus->lChainIndex = 0;
3362 pPolicyStatus->lElementIndex = 0;
3363 }
3364 }
3365 }
3366 }
3367 return TRUE;
3368 }
3369
3370 static BYTE msPubKey1[] = {
3371 0x30,0x82,0x01,0x0a,0x02,0x82,0x01,0x01,0x00,0xdf,0x08,0xba,0xe3,0x3f,0x6e,
3372 0x64,0x9b,0xf5,0x89,0xaf,0x28,0x96,0x4a,0x07,0x8f,0x1b,0x2e,0x8b,0x3e,0x1d,
3373 0xfc,0xb8,0x80,0x69,0xa3,0xa1,0xce,0xdb,0xdf,0xb0,0x8e,0x6c,0x89,0x76,0x29,
3374 0x4f,0xca,0x60,0x35,0x39,0xad,0x72,0x32,0xe0,0x0b,0xae,0x29,0x3d,0x4c,0x16,
3375 0xd9,0x4b,0x3c,0x9d,0xda,0xc5,0xd3,0xd1,0x09,0xc9,0x2c,0x6f,0xa6,0xc2,0x60,
3376 0x53,0x45,0xdd,0x4b,0xd1,0x55,0xcd,0x03,0x1c,0xd2,0x59,0x56,0x24,0xf3,0xe5,
3377 0x78,0xd8,0x07,0xcc,0xd8,0xb3,0x1f,0x90,0x3f,0xc0,0x1a,0x71,0x50,0x1d,0x2d,
3378 0xa7,0x12,0x08,0x6d,0x7c,0xb0,0x86,0x6c,0xc7,0xba,0x85,0x32,0x07,0xe1,0x61,
3379 0x6f,0xaf,0x03,0xc5,0x6d,0xe5,0xd6,0xa1,0x8f,0x36,0xf6,0xc1,0x0b,0xd1,0x3e,
3380 0x69,0x97,0x48,0x72,0xc9,0x7f,0xa4,0xc8,0xc2,0x4a,0x4c,0x7e,0xa1,0xd1,0x94,
3381 0xa6,0xd7,0xdc,0xeb,0x05,0x46,0x2e,0xb8,0x18,0xb4,0x57,0x1d,0x86,0x49,0xdb,
3382 0x69,0x4a,0x2c,0x21,0xf5,0x5e,0x0f,0x54,0x2d,0x5a,0x43,0xa9,0x7a,0x7e,0x6a,
3383 0x8e,0x50,0x4d,0x25,0x57,0xa1,0xbf,0x1b,0x15,0x05,0x43,0x7b,0x2c,0x05,0x8d,
3384 0xbd,0x3d,0x03,0x8c,0x93,0x22,0x7d,0x63,0xea,0x0a,0x57,0x05,0x06,0x0a,0xdb,
3385 0x61,0x98,0x65,0x2d,0x47,0x49,0xa8,0xe7,0xe6,0x56,0x75,0x5c,0xb8,0x64,0x08,
3386 0x63,0xa9,0x30,0x40,0x66,0xb2,0xf9,0xb6,0xe3,0x34,0xe8,0x67,0x30,0xe1,0x43,
3387 0x0b,0x87,0xff,0xc9,0xbe,0x72,0x10,0x5e,0x23,0xf0,0x9b,0xa7,0x48,0x65,0xbf,
3388 0x09,0x88,0x7b,0xcd,0x72,0xbc,0x2e,0x79,0x9b,0x7b,0x02,0x03,0x01,0x00,0x01 };
3389 static BYTE msPubKey2[] = {
3390 0x30,0x82,0x01,0x0a,0x02,0x82,0x01,0x01,0x00,0xa9,0x02,0xbd,0xc1,0x70,0xe6,
3391 0x3b,0xf2,0x4e,0x1b,0x28,0x9f,0x97,0x78,0x5e,0x30,0xea,0xa2,0xa9,0x8d,0x25,
3392 0x5f,0xf8,0xfe,0x95,0x4c,0xa3,0xb7,0xfe,0x9d,0xa2,0x20,0x3e,0x7c,0x51,0xa2,
3393 0x9b,0xa2,0x8f,0x60,0x32,0x6b,0xd1,0x42,0x64,0x79,0xee,0xac,0x76,0xc9,0x54,
3394 0xda,0xf2,0xeb,0x9c,0x86,0x1c,0x8f,0x9f,0x84,0x66,0xb3,0xc5,0x6b,0x7a,0x62,
3395 0x23,0xd6,0x1d,0x3c,0xde,0x0f,0x01,0x92,0xe8,0x96,0xc4,0xbf,0x2d,0x66,0x9a,
3396 0x9a,0x68,0x26,0x99,0xd0,0x3a,0x2c,0xbf,0x0c,0xb5,0x58,0x26,0xc1,0x46,0xe7,
3397 0x0a,0x3e,0x38,0x96,0x2c,0xa9,0x28,0x39,0xa8,0xec,0x49,0x83,0x42,0xe3,0x84,
3398 0x0f,0xbb,0x9a,0x6c,0x55,0x61,0xac,0x82,0x7c,0xa1,0x60,0x2d,0x77,0x4c,0xe9,
3399 0x99,0xb4,0x64,0x3b,0x9a,0x50,0x1c,0x31,0x08,0x24,0x14,0x9f,0xa9,0xe7,0x91,
3400 0x2b,0x18,0xe6,0x3d,0x98,0x63,0x14,0x60,0x58,0x05,0x65,0x9f,0x1d,0x37,0x52,
3401 0x87,0xf7,0xa7,0xef,0x94,0x02,0xc6,0x1b,0xd3,0xbf,0x55,0x45,0xb3,0x89,0x80,
3402 0xbf,0x3a,0xec,0x54,0x94,0x4e,0xae,0xfd,0xa7,0x7a,0x6d,0x74,0x4e,0xaf,0x18,
3403 0xcc,0x96,0x09,0x28,0x21,0x00,0x57,0x90,0x60,0x69,0x37,0xbb,0x4b,0x12,0x07,
3404 0x3c,0x56,0xff,0x5b,0xfb,0xa4,0x66,0x0a,0x08,0xa6,0xd2,0x81,0x56,0x57,0xef,
3405 0xb6,0x3b,0x5e,0x16,0x81,0x77,0x04,0xda,0xf6,0xbe,0xae,0x80,0x95,0xfe,0xb0,
3406 0xcd,0x7f,0xd6,0xa7,0x1a,0x72,0x5c,0x3c,0xca,0xbc,0xf0,0x08,0xa3,0x22,0x30,
3407 0xb3,0x06,0x85,0xc9,0xb3,0x20,0x77,0x13,0x85,0xdf,0x02,0x03,0x01,0x00,0x01 };
3408 static BYTE msPubKey3[] = {
3409 0x30,0x82,0x02,0x0a,0x02,0x82,0x02,0x01,0x00,0xf3,0x5d,0xfa,0x80,0x67,0xd4,
3410 0x5a,0xa7,0xa9,0x0c,0x2c,0x90,0x20,0xd0,0x35,0x08,0x3c,0x75,0x84,0xcd,0xb7,
3411 0x07,0x89,0x9c,0x89,0xda,0xde,0xce,0xc3,0x60,0xfa,0x91,0x68,0x5a,0x9e,0x94,
3412 0x71,0x29,0x18,0x76,0x7c,0xc2,0xe0,0xc8,0x25,0x76,0x94,0x0e,0x58,0xfa,0x04,
3413 0x34,0x36,0xe6,0xdf,0xaf,0xf7,0x80,0xba,0xe9,0x58,0x0b,0x2b,0x93,0xe5,0x9d,
3414 0x05,0xe3,0x77,0x22,0x91,0xf7,0x34,0x64,0x3c,0x22,0x91,0x1d,0x5e,0xe1,0x09,
3415 0x90,0xbc,0x14,0xfe,0xfc,0x75,0x58,0x19,0xe1,0x79,0xb7,0x07,0x92,0xa3,0xae,
3416 0x88,0x59,0x08,0xd8,0x9f,0x07,0xca,0x03,0x58,0xfc,0x68,0x29,0x6d,0x32,0xd7,
3417 0xd2,0xa8,0xcb,0x4b,0xfc,0xe1,0x0b,0x48,0x32,0x4f,0xe6,0xeb,0xb8,0xad,0x4f,
3418 0xe4,0x5c,0x6f,0x13,0x94,0x99,0xdb,0x95,0xd5,0x75,0xdb,0xa8,0x1a,0xb7,0x94,
3419 0x91,0xb4,0x77,0x5b,0xf5,0x48,0x0c,0x8f,0x6a,0x79,0x7d,0x14,0x70,0x04,0x7d,
3420 0x6d,0xaf,0x90,0xf5,0xda,0x70,0xd8,0x47,0xb7,0xbf,0x9b,0x2f,0x6c,0xe7,0x05,
3421 0xb7,0xe1,0x11,0x60,0xac,0x79,0x91,0x14,0x7c,0xc5,0xd6,0xa6,0xe4,0xe1,0x7e,
3422 0xd5,0xc3,0x7e,0xe5,0x92,0xd2,0x3c,0x00,0xb5,0x36,0x82,0xde,0x79,0xe1,0x6d,
3423 0xf3,0xb5,0x6e,0xf8,0x9f,0x33,0xc9,0xcb,0x52,0x7d,0x73,0x98,0x36,0xdb,0x8b,
3424 0xa1,0x6b,0xa2,0x95,0x97,0x9b,0xa3,0xde,0xc2,0x4d,0x26,0xff,0x06,0x96,0x67,
3425 0x25,0x06,0xc8,0xe7,0xac,0xe4,0xee,0x12,0x33,0x95,0x31,0x99,0xc8,0x35,0x08,
3426 0x4e,0x34,0xca,0x79,0x53,0xd5,0xb5,0xbe,0x63,0x32,0x59,0x40,0x36,0xc0,0xa5,
3427 0x4e,0x04,0x4d,0x3d,0xdb,0x5b,0x07,0x33,0xe4,0x58,0xbf,0xef,0x3f,0x53,0x64,
3428 0xd8,0x42,0x59,0x35,0x57,0xfd,0x0f,0x45,0x7c,0x24,0x04,0x4d,0x9e,0xd6,0x38,
3429 0x74,0x11,0x97,0x22,0x90,0xce,0x68,0x44,0x74,0x92,0x6f,0xd5,0x4b,0x6f,0xb0,
3430 0x86,0xe3,0xc7,0x36,0x42,0xa0,0xd0,0xfc,0xc1,0xc0,0x5a,0xf9,0xa3,0x61,0xb9,
3431 0x30,0x47,0x71,0x96,0x0a,0x16,0xb0,0x91,0xc0,0x42,0x95,0xef,0x10,0x7f,0x28,
3432 0x6a,0xe3,0x2a,0x1f,0xb1,0xe4,0xcd,0x03,0x3f,0x77,0x71,0x04,0xc7,0x20,0xfc,
3433 0x49,0x0f,0x1d,0x45,0x88,0xa4,0xd7,0xcb,0x7e,0x88,0xad,0x8e,0x2d,0xec,0x45,
3434 0xdb,0xc4,0x51,0x04,0xc9,0x2a,0xfc,0xec,0x86,0x9e,0x9a,0x11,0x97,0x5b,0xde,
3435 0xce,0x53,0x88,0xe6,0xe2,0xb7,0xfd,0xac,0x95,0xc2,0x28,0x40,0xdb,0xef,0x04,
3436 0x90,0xdf,0x81,0x33,0x39,0xd9,0xb2,0x45,0xa5,0x23,0x87,0x06,0xa5,0x55,0x89,
3437 0x31,0xbb,0x06,0x2d,0x60,0x0e,0x41,0x18,0x7d,0x1f,0x2e,0xb5,0x97,0xcb,0x11,
3438 0xeb,0x15,0xd5,0x24,0xa5,0x94,0xef,0x15,0x14,0x89,0xfd,0x4b,0x73,0xfa,0x32,
3439 0x5b,0xfc,0xd1,0x33,0x00,0xf9,0x59,0x62,0x70,0x07,0x32,0xea,0x2e,0xab,0x40,
3440 0x2d,0x7b,0xca,0xdd,0x21,0x67,0x1b,0x30,0x99,0x8f,0x16,0xaa,0x23,0xa8,0x41,
3441 0xd1,0xb0,0x6e,0x11,0x9b,0x36,0xc4,0xde,0x40,0x74,0x9c,0xe1,0x58,0x65,0xc1,
3442 0x60,0x1e,0x7a,0x5b,0x38,0xc8,0x8f,0xbb,0x04,0x26,0x7c,0xd4,0x16,0x40,0xe5,
3443 0xb6,0x6b,0x6c,0xaa,0x86,0xfd,0x00,0xbf,0xce,0xc1,0x35,0x02,0x03,0x01,0x00,
3444 0x01 };
3445
3446 static BOOL WINAPI verify_ms_root_policy(LPCSTR szPolicyOID,
3447 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
3448 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
3449 {
3450 BOOL ret = verify_base_policy(szPolicyOID, pChainContext, pPolicyPara,
3451 pPolicyStatus);
3452
3453 if (ret && !pPolicyStatus->dwError)
3454 {
3455 CERT_PUBLIC_KEY_INFO msPubKey = { { 0 } };
3456 BOOL isMSRoot = FALSE;
3457 DWORD i;
3458 CRYPT_DATA_BLOB keyBlobs[] = {
3459 { sizeof(msPubKey1), msPubKey1 },
3460 { sizeof(msPubKey2), msPubKey2 },
3461 { sizeof(msPubKey3), msPubKey3 },
3462 };
3463 PCERT_SIMPLE_CHAIN rootChain =
3464 pChainContext->rgpChain[pChainContext->cChain -1 ];
3465 PCCERT_CONTEXT root =
3466 rootChain->rgpElement[rootChain->cElement - 1]->pCertContext;
3467
3468 for (i = 0; !isMSRoot && i < sizeof(keyBlobs) / sizeof(keyBlobs[0]);
3469 i++)
3470 {
3471 msPubKey.PublicKey.cbData = keyBlobs[i].cbData;
3472 msPubKey.PublicKey.pbData = keyBlobs[i].pbData;
3473 if (CertComparePublicKeyInfo(
3474 X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
3475 &root->pCertInfo->SubjectPublicKeyInfo, &msPubKey))
3476 isMSRoot = TRUE;
3477 }
3478 if (isMSRoot)
3479 pPolicyStatus->lChainIndex = pPolicyStatus->lElementIndex = 0;
3480 }
3481 return ret;
3482 }
3483
3484 typedef BOOL (WINAPI *CertVerifyCertificateChainPolicyFunc)(LPCSTR szPolicyOID,
3485 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
3486 PCERT_CHAIN_POLICY_STATUS pPolicyStatus);
3487
3488 BOOL WINAPI CertVerifyCertificateChainPolicy(LPCSTR szPolicyOID,
3489 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
3490 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
3491 {
3492 static HCRYPTOIDFUNCSET set = NULL;
3493 BOOL ret = FALSE;
3494 CertVerifyCertificateChainPolicyFunc verifyPolicy = NULL;
3495 HCRYPTOIDFUNCADDR hFunc = NULL;
3496
3497 TRACE("(%s, %p, %p, %p)\n", debugstr_a(szPolicyOID), pChainContext,
3498 pPolicyPara, pPolicyStatus);
3499
3500 if (IS_INTOID(szPolicyOID))
3501 {
3502 switch (LOWORD(szPolicyOID))
3503 {
3504 case LOWORD(CERT_CHAIN_POLICY_BASE):
3505 verifyPolicy = verify_base_policy;
3506 break;
3507 case LOWORD(CERT_CHAIN_POLICY_AUTHENTICODE):
3508 verifyPolicy = verify_authenticode_policy;
3509 break;
3510 case LOWORD(CERT_CHAIN_POLICY_SSL):
3511 verifyPolicy = verify_ssl_policy;
3512 break;
3513 case LOWORD(CERT_CHAIN_POLICY_BASIC_CONSTRAINTS):
3514 verifyPolicy = verify_basic_constraints_policy;
3515 break;
3516 case LOWORD(CERT_CHAIN_POLICY_MICROSOFT_ROOT):
3517 verifyPolicy = verify_ms_root_policy;
3518 break;
3519 default:
3520 FIXME("unimplemented for %d\n", LOWORD(szPolicyOID));
3521 }
3522 }
3523 if (!verifyPolicy)
3524 {
3525 if (!set)
3526 set = CryptInitOIDFunctionSet(
3527 CRYPT_OID_VERIFY_CERTIFICATE_CHAIN_POLICY_FUNC, 0);
3528 CryptGetOIDFunctionAddress(set, X509_ASN_ENCODING, szPolicyOID, 0,
3529 (void **)&verifyPolicy, &hFunc);
3530 }
3531 if (verifyPolicy)
3532 ret = verifyPolicy(szPolicyOID, pChainContext, pPolicyPara,
3533 pPolicyStatus);
3534 if (hFunc)
3535 CryptFreeOIDFunctionAddress(hFunc, 0);
3536 TRACE("returning %d (%08x)\n", ret, pPolicyStatus->dwError);
3537 return ret;
3538 }
useful hacks and other patches not (yet) suitable for mainline