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