?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
crypt32: Forbid minimum or maximum fields in name constraints.
[wine/multimedia.git] / dlls / crypt32 / chain.c
blob76052b22d15c4fc22a0e5cb79783db1b0a67bf14
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 inline BOOL CRYPT_IsCertificateSelfSigned(PCCERT_CONTEXT cert)
234 {
235 return CertCompareCertificateName(cert->dwCertEncodingType,
236 &cert->pCertInfo->Subject, &cert->pCertInfo->Issuer);
237 }
238
239 static void CRYPT_FreeChainElement(PCERT_CHAIN_ELEMENT element)
240 {
241 CertFreeCertificateContext(element->pCertContext);
242 CryptMemFree(element);
243 }
244
245 static void CRYPT_CheckSimpleChainForCycles(PCERT_SIMPLE_CHAIN chain)
246 {
247 DWORD i, j, cyclicCertIndex = 0;
248
249 /* O(n^2) - I don't think there's a faster way */
250 for (i = 0; !cyclicCertIndex && i < chain->cElement; i++)
251 for (j = i + 1; !cyclicCertIndex && j < chain->cElement; j++)
252 if (CertCompareCertificate(X509_ASN_ENCODING,
253 chain->rgpElement[i]->pCertContext->pCertInfo,
254 chain->rgpElement[j]->pCertContext->pCertInfo))
255 cyclicCertIndex = j;
256 if (cyclicCertIndex)
257 {
258 chain->rgpElement[cyclicCertIndex]->TrustStatus.dwErrorStatus
259 |= CERT_TRUST_IS_CYCLIC | CERT_TRUST_INVALID_BASIC_CONSTRAINTS;
260 /* Release remaining certs */
261 for (i = cyclicCertIndex + 1; i < chain->cElement; i++)
262 CRYPT_FreeChainElement(chain->rgpElement[i]);
263 /* Truncate chain */
264 chain->cElement = cyclicCertIndex + 1;
265 }
266 }
267
268 /* Checks whether the chain is cyclic by examining the last element's status */
269 static inline BOOL CRYPT_IsSimpleChainCyclic(const CERT_SIMPLE_CHAIN *chain)
270 {
271 if (chain->cElement)
272 return chain->rgpElement[chain->cElement - 1]->TrustStatus.dwErrorStatus
273 & CERT_TRUST_IS_CYCLIC;
274 else
275 return FALSE;
276 }
277
278 static inline void CRYPT_CombineTrustStatus(CERT_TRUST_STATUS *chainStatus,
279 const CERT_TRUST_STATUS *elementStatus)
280 {
281 /* Any error that applies to an element also applies to a chain.. */
282 chainStatus->dwErrorStatus |= elementStatus->dwErrorStatus;
283 /* but the bottom nibble of an element's info status doesn't apply to the
284 * chain.
285 */
286 chainStatus->dwInfoStatus |= (elementStatus->dwInfoStatus & 0xfffffff0);
287 }
288
289 static BOOL CRYPT_AddCertToSimpleChain(const CertificateChainEngine *engine,
290 PCERT_SIMPLE_CHAIN chain, PCCERT_CONTEXT cert, DWORD subjectInfoStatus)
291 {
292 BOOL ret = FALSE;
293 PCERT_CHAIN_ELEMENT element = CryptMemAlloc(sizeof(CERT_CHAIN_ELEMENT));
294
295 if (element)
296 {
297 if (!chain->cElement)
298 chain->rgpElement = CryptMemAlloc(sizeof(PCERT_CHAIN_ELEMENT));
299 else
300 chain->rgpElement = CryptMemRealloc(chain->rgpElement,
301 (chain->cElement + 1) * sizeof(PCERT_CHAIN_ELEMENT));
302 if (chain->rgpElement)
303 {
304 chain->rgpElement[chain->cElement++] = element;
305 memset(element, 0, sizeof(CERT_CHAIN_ELEMENT));
306 element->cbSize = sizeof(CERT_CHAIN_ELEMENT);
307 element->pCertContext = CertDuplicateCertificateContext(cert);
308 if (chain->cElement > 1)
309 chain->rgpElement[chain->cElement - 2]->TrustStatus.dwInfoStatus
310 = subjectInfoStatus;
311 /* FIXME: initialize the rest of element */
312 if (!(chain->cElement % engine->CycleDetectionModulus))
313 {
314 CRYPT_CheckSimpleChainForCycles(chain);
315 /* Reinitialize the element pointer in case the chain is
316 * cyclic, in which case the chain is truncated.
317 */
318 element = chain->rgpElement[chain->cElement - 1];
319 }
320 CRYPT_CombineTrustStatus(&chain->TrustStatus,
321 &element->TrustStatus);
322 ret = TRUE;
323 }
324 else
325 CryptMemFree(element);
326 }
327 return ret;
328 }
329
330 static void CRYPT_FreeSimpleChain(PCERT_SIMPLE_CHAIN chain)
331 {
332 DWORD i;
333
334 for (i = 0; i < chain->cElement; i++)
335 CRYPT_FreeChainElement(chain->rgpElement[i]);
336 CryptMemFree(chain->rgpElement);
337 CryptMemFree(chain);
338 }
339
340 static void CRYPT_CheckTrustedStatus(HCERTSTORE hRoot,
341 PCERT_CHAIN_ELEMENT rootElement)
342 {
343 PCCERT_CONTEXT trustedRoot = CRYPT_FindCertInStore(hRoot,
344 rootElement->pCertContext);
345
346 if (!trustedRoot)
347 rootElement->TrustStatus.dwErrorStatus |=
348 CERT_TRUST_IS_UNTRUSTED_ROOT;
349 else
350 CertFreeCertificateContext(trustedRoot);
351 }
352
353 static void CRYPT_CheckRootCert(HCERTCHAINENGINE hRoot,
354 PCERT_CHAIN_ELEMENT rootElement)
355 {
356 PCCERT_CONTEXT root = rootElement->pCertContext;
357
358 if (!CryptVerifyCertificateSignatureEx(0, root->dwCertEncodingType,
359 CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT, (void *)root,
360 CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT, (void *)root, 0, NULL))
361 {
362 TRACE_(chain)("Last certificate's signature is invalid\n");
363 rootElement->TrustStatus.dwErrorStatus |=
364 CERT_TRUST_IS_NOT_SIGNATURE_VALID;
365 }
366 CRYPT_CheckTrustedStatus(hRoot, rootElement);
367 }
368
369 /* Decodes a cert's basic constraints extension (either szOID_BASIC_CONSTRAINTS
370 * or szOID_BASIC_CONSTRAINTS2, whichever is present) into a
371 * CERT_BASIC_CONSTRAINTS2_INFO. If it neither extension is present, sets
372 * constraints->fCA to defaultIfNotSpecified.
373 * Returns FALSE if the extension is present but couldn't be decoded.
374 */
375 static BOOL CRYPT_DecodeBasicConstraints(PCCERT_CONTEXT cert,
376 CERT_BASIC_CONSTRAINTS2_INFO *constraints, BOOL defaultIfNotSpecified)
377 {
378 BOOL ret = TRUE;
379 PCERT_EXTENSION ext = CertFindExtension(szOID_BASIC_CONSTRAINTS,
380 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
381
382 constraints->fPathLenConstraint = FALSE;
383 if (ext)
384 {
385 CERT_BASIC_CONSTRAINTS_INFO *info;
386 DWORD size = 0;
387
388 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
389 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
390 NULL, &info, &size);
391 if (ret)
392 {
393 if (info->SubjectType.cbData == 1)
394 constraints->fCA =
395 info->SubjectType.pbData[0] & CERT_CA_SUBJECT_FLAG;
396 LocalFree(info);
397 }
398 }
399 else
400 {
401 ext = CertFindExtension(szOID_BASIC_CONSTRAINTS2,
402 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
403 if (ext)
404 {
405 DWORD size = sizeof(CERT_BASIC_CONSTRAINTS2_INFO);
406
407 ret = CryptDecodeObjectEx(X509_ASN_ENCODING,
408 szOID_BASIC_CONSTRAINTS2, ext->Value.pbData, ext->Value.cbData,
409 0, NULL, constraints, &size);
410 }
411 else
412 constraints->fCA = defaultIfNotSpecified;
413 }
414 return ret;
415 }
416
417 /* Checks element's basic constraints to see if it can act as a CA, with
418 * remainingCAs CAs left in this chain. In general, a cert must include the
419 * basic constraints extension, with the CA flag asserted, in order to be
420 * allowed to be a CA. A V1 or V2 cert, which has no extensions, is also
421 * allowed to be a CA if it's installed locally (in the engine's world store.)
422 * This matches the expected usage in RFC 5280, section 4.2.1.9: a conforming
423 * CA MUST include the basic constraints extension in all certificates that are
424 * used to validate digital signatures on certificates. It also matches
425 * section 6.1.4(k): "If a certificate is a v1 or v2 certificate, then the
426 * application MUST either verify that the certificate is a CA certificate
427 * through out-of-band means or reject the certificate." Rejecting the
428 * certificate prohibits a large number of commonly used certificates, so
429 * accepting locally installed ones is a compromise.
430 * Root certificates are also allowed to be CAs even without a basic
431 * constraints extension. This is implied by RFC 5280, section 6.1: the
432 * root of a certificate chain's only requirement is that it was used to issue
433 * the next certificate in the chain.
434 * Updates chainConstraints with the element's constraints, if:
435 * 1. chainConstraints doesn't have a path length constraint, or
436 * 2. element's path length constraint is smaller than chainConstraints's
437 * Sets *pathLengthConstraintViolated to TRUE if a path length violation
438 * occurs.
439 * Returns TRUE if the element can be a CA, and the length of the remaining
440 * chain is valid.
441 */
442 static BOOL CRYPT_CheckBasicConstraintsForCA(PCertificateChainEngine engine,
443 PCCERT_CONTEXT cert, CERT_BASIC_CONSTRAINTS2_INFO *chainConstraints,
444 DWORD remainingCAs, BOOL isRoot, BOOL *pathLengthConstraintViolated)
445 {
446 BOOL validBasicConstraints, implicitCA = FALSE;
447 CERT_BASIC_CONSTRAINTS2_INFO constraints;
448
449 if (isRoot)
450 implicitCA = TRUE;
451 else if (cert->pCertInfo->dwVersion == CERT_V1 ||
452 cert->pCertInfo->dwVersion == CERT_V2)
453 {
454 BYTE hash[20];
455 DWORD size = sizeof(hash);
456
457 if (CertGetCertificateContextProperty(cert, CERT_HASH_PROP_ID,
458 hash, &size))
459 {
460 CRYPT_HASH_BLOB blob = { sizeof(hash), hash };
461 PCCERT_CONTEXT localCert = CertFindCertificateInStore(
462 engine->hWorld, cert->dwCertEncodingType, 0, CERT_FIND_SHA1_HASH,
463 &blob, NULL);
464
465 if (localCert)
466 {
467 CertFreeCertificateContext(localCert);
468 implicitCA = TRUE;
469 }
470 }
471 }
472 if ((validBasicConstraints = CRYPT_DecodeBasicConstraints(cert,
473 &constraints, implicitCA)))
474 {
475 chainConstraints->fCA = constraints.fCA;
476 if (!constraints.fCA)
477 {
478 TRACE_(chain)("chain element %d can't be a CA\n", remainingCAs + 1);
479 validBasicConstraints = FALSE;
480 }
481 else if (constraints.fPathLenConstraint)
482 {
483 /* If the element has path length constraints, they apply to the
484 * entire remaining chain.
485 */
486 if (!chainConstraints->fPathLenConstraint ||
487 constraints.dwPathLenConstraint <
488 chainConstraints->dwPathLenConstraint)
489 {
490 TRACE_(chain)("setting path length constraint to %d\n",
491 chainConstraints->dwPathLenConstraint);
492 chainConstraints->fPathLenConstraint = TRUE;
493 chainConstraints->dwPathLenConstraint =
494 constraints.dwPathLenConstraint;
495 }
496 }
497 }
498 if (chainConstraints->fPathLenConstraint &&
499 remainingCAs > chainConstraints->dwPathLenConstraint)
500 {
501 TRACE_(chain)("remaining CAs %d exceed max path length %d\n",
502 remainingCAs, chainConstraints->dwPathLenConstraint);
503 validBasicConstraints = FALSE;
504 *pathLengthConstraintViolated = TRUE;
505 }
506 return validBasicConstraints;
507 }
508
509 static BOOL url_matches(LPCWSTR constraint, LPCWSTR name,
510 DWORD *trustErrorStatus)
511 {
512 BOOL match = FALSE;
513
514 TRACE("%s, %s\n", debugstr_w(constraint), debugstr_w(name));
515
516 if (!constraint)
517 *trustErrorStatus |= CERT_TRUST_INVALID_NAME_CONSTRAINTS;
518 else if (!name)
519 ; /* no match */
520 else if (constraint[0] == '.')
521 {
522 if (lstrlenW(name) > lstrlenW(constraint))
523 match = !lstrcmpiW(name + lstrlenW(name) - lstrlenW(constraint),
524 constraint);
525 }
526 else
527 match = !lstrcmpiW(constraint, name);
528 return match;
529 }
530
531 static BOOL rfc822_name_matches(LPCWSTR constraint, LPCWSTR name,
532 DWORD *trustErrorStatus)
533 {
534 BOOL match = FALSE;
535 LPCWSTR at;
536
537 TRACE("%s, %s\n", debugstr_w(constraint), debugstr_w(name));
538
539 if (!constraint)
540 *trustErrorStatus |= CERT_TRUST_INVALID_NAME_CONSTRAINTS;
541 else if (!name)
542 ; /* no match */
543 else if ((at = strchrW(constraint, '@')))
544 match = !lstrcmpiW(constraint, name);
545 else
546 {
547 if ((at = strchrW(name, '@')))
548 match = url_matches(constraint, at + 1, trustErrorStatus);
549 else
550 match = !lstrcmpiW(constraint, name);
551 }
552 return match;
553 }
554
555 static BOOL dns_name_matches(LPCWSTR constraint, LPCWSTR name,
556 DWORD *trustErrorStatus)
557 {
558 BOOL match = FALSE;
559
560 TRACE("%s, %s\n", debugstr_w(constraint), debugstr_w(name));
561
562 if (!constraint)
563 *trustErrorStatus |= CERT_TRUST_INVALID_NAME_CONSTRAINTS;
564 else if (!name)
565 ; /* no match */
566 else if (lstrlenW(name) >= lstrlenW(constraint))
567 match = !lstrcmpiW(name + lstrlenW(name) - lstrlenW(constraint),
568 constraint);
569 /* else: name is too short, no match */
570
571 return match;
572 }
573
574 static BOOL ip_address_matches(const CRYPT_DATA_BLOB *constraint,
575 const CRYPT_DATA_BLOB *name, DWORD *trustErrorStatus)
576 {
577 BOOL match = FALSE;
578
579 TRACE("(%d, %p), (%d, %p)\n", constraint->cbData, constraint->pbData,
580 name->cbData, name->pbData);
581
582 /* RFC5280, section 4.2.1.10, iPAddress syntax: either 8 or 32 bytes, for
583 * IPv4 or IPv6 addresses, respectively.
584 */
585 if (constraint->cbData != sizeof(DWORD) * 2 && constraint->cbData != 32)
586 *trustErrorStatus |= CERT_TRUST_INVALID_NAME_CONSTRAINTS;
587 else if (name->cbData == sizeof(DWORD) &&
588 constraint->cbData == sizeof(DWORD) * 2)
589 {
590 DWORD subnet, mask, addr;
591
592 memcpy(&subnet, constraint->pbData, sizeof(subnet));
593 memcpy(&mask, constraint->pbData + sizeof(subnet), sizeof(mask));
594 memcpy(&addr, name->pbData, sizeof(addr));
595 /* These are really in big-endian order, but for equality matching we
596 * don't need to swap to host order
597 */
598 match = (subnet & mask) == (addr & mask);
599 }
600 else if (name->cbData == 16 && constraint->cbData == 32)
601 {
602 const BYTE *subnet, *mask, *addr;
603 DWORD i;
604
605 subnet = constraint->pbData;
606 mask = constraint->pbData + 16;
607 addr = name->pbData;
608 match = TRUE;
609 for (i = 0; match && i < 16; i++)
610 if ((subnet[i] & mask[i]) != (addr[i] & mask[i]))
611 match = FALSE;
612 }
613 /* else: name is wrong size, no match */
614
615 return match;
616 }
617
618 static void CRYPT_FindMatchingNameEntry(const CERT_ALT_NAME_ENTRY *constraint,
619 const CERT_ALT_NAME_INFO *subjectName, DWORD *trustErrorStatus,
620 DWORD errorIfFound, DWORD errorIfNotFound)
621 {
622 DWORD i;
623 BOOL match = FALSE;
624
625 for (i = 0; i < subjectName->cAltEntry; i++)
626 {
627 if (subjectName->rgAltEntry[i].dwAltNameChoice ==
628 constraint->dwAltNameChoice)
629 {
630 switch (constraint->dwAltNameChoice)
631 {
632 case CERT_ALT_NAME_RFC822_NAME:
633 match = rfc822_name_matches(constraint->u.pwszURL,
634 subjectName->rgAltEntry[i].u.pwszURL, trustErrorStatus);
635 break;
636 case CERT_ALT_NAME_DNS_NAME:
637 match = dns_name_matches(constraint->u.pwszURL,
638 subjectName->rgAltEntry[i].u.pwszURL, trustErrorStatus);
639 break;
640 case CERT_ALT_NAME_URL:
641 match = url_matches(constraint->u.pwszURL,
642 subjectName->rgAltEntry[i].u.pwszURL, trustErrorStatus);
643 break;
644 case CERT_ALT_NAME_IP_ADDRESS:
645 match = ip_address_matches(&constraint->u.IPAddress,
646 &subjectName->rgAltEntry[i].u.IPAddress, trustErrorStatus);
647 break;
648 case CERT_ALT_NAME_DIRECTORY_NAME:
649 default:
650 ERR("name choice %d unsupported in this context\n",
651 constraint->dwAltNameChoice);
652 *trustErrorStatus |=
653 CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT;
654 }
655 }
656 }
657 *trustErrorStatus |= match ? errorIfFound : errorIfNotFound;
658 }
659
660 static void CRYPT_CheckNameConstraints(
661 const CERT_NAME_CONSTRAINTS_INFO *nameConstraints, const CERT_INFO *cert,
662 DWORD *trustErrorStatus)
663 {
664 /* If there aren't any existing constraints, don't bother checking */
665 if (nameConstraints->cPermittedSubtree || nameConstraints->cExcludedSubtree)
666 {
667 CERT_EXTENSION *ext;
668
669 ext = CertFindExtension(szOID_SUBJECT_ALT_NAME2, cert->cExtension,
670 cert->rgExtension);
671 if (!ext)
672 ext = CertFindExtension(szOID_SUBJECT_ALT_NAME, cert->cExtension,
673 cert->rgExtension);
674 if (ext)
675 {
676 CERT_ALT_NAME_INFO *subjectName;
677 DWORD size;
678
679 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_ALTERNATE_NAME,
680 ext->Value.pbData, ext->Value.cbData,
681 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
682 &subjectName, &size))
683 {
684 DWORD i;
685
686 for (i = 0; i < nameConstraints->cExcludedSubtree; i++)
687 CRYPT_FindMatchingNameEntry(
688 &nameConstraints->rgExcludedSubtree[i].Base, subjectName,
689 trustErrorStatus,
690 CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT, 0);
691 for (i = 0; i < nameConstraints->cPermittedSubtree; i++)
692 CRYPT_FindMatchingNameEntry(
693 &nameConstraints->rgPermittedSubtree[i].Base, subjectName,
694 trustErrorStatus,
695 0, CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT);
696 LocalFree(subjectName);
697 }
698 }
699 else
700 {
701 if (nameConstraints->cPermittedSubtree)
702 *trustErrorStatus |=
703 CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT;
704 if (nameConstraints->cExcludedSubtree)
705 *trustErrorStatus |=
706 CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT;
707 }
708 }
709 }
710
711 /* Gets cert's name constraints, if any. Free with LocalFree. */
712 static CERT_NAME_CONSTRAINTS_INFO *CRYPT_GetNameConstraints(CERT_INFO *cert)
713 {
714 CERT_NAME_CONSTRAINTS_INFO *info = NULL;
715
716 CERT_EXTENSION *ext;
717
718 if ((ext = CertFindExtension(szOID_NAME_CONSTRAINTS, cert->cExtension,
719 cert->rgExtension)))
720 {
721 DWORD size;
722
723 CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME_CONSTRAINTS,
724 ext->Value.pbData, ext->Value.cbData,
725 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL, &info,
726 &size);
727 }
728 return info;
729 }
730
731 static BOOL CRYPT_IsValidNameConstraint(const CERT_NAME_CONSTRAINTS_INFO *info)
732 {
733 DWORD i;
734 BOOL ret = TRUE;
735
736 /* Check that none of the constraints specifies a minimum or a maximum.
737 * See RFC 5280, section 4.2.1.10:
738 * "Within this profile, the minimum and maximum fields are not used with
739 * any name forms, thus, the minimum MUST be zero, and maximum MUST be
740 * absent. However, if an application encounters a critical name
741 * constraints extension that specifies other values for minimum or
742 * maximum for a name form that appears in a subsequent certificate, the
743 * application MUST either process these fields or reject the
744 * certificate."
745 * Since it gives no guidance as to how to process these fields, we
746 * reject any name constraint that contains them.
747 */
748 for (i = 0; ret && i < info->cPermittedSubtree; i++)
749 if (info->rgPermittedSubtree[i].dwMinimum ||
750 info->rgPermittedSubtree[i].fMaximum)
751 {
752 TRACE_(chain)("found a minimum or maximum in permitted subtrees\n");
753 ret = FALSE;
754 }
755 for (i = 0; ret && i < info->cExcludedSubtree; i++)
756 if (info->rgExcludedSubtree[i].dwMinimum ||
757 info->rgExcludedSubtree[i].fMaximum)
758 {
759 TRACE_(chain)("found a minimum or maximum in excluded subtrees\n");
760 ret = FALSE;
761 }
762 return ret;
763 }
764
765 static void CRYPT_CheckChainNameConstraints(PCERT_SIMPLE_CHAIN chain)
766 {
767 int i, j;
768
769 /* Microsoft's implementation appears to violate RFC 3280: according to
770 * MSDN, the various CERT_TRUST_*_NAME_CONSTRAINT errors are set if a CA's
771 * name constraint is violated in the end cert. According to RFC 3280,
772 * the constraints should be checked against every subsequent certificate
773 * in the chain, not just the end cert.
774 * Microsoft's implementation also sets the name constraint errors on the
775 * certs whose constraints were violated, not on the certs that violated
776 * them.
777 * In order to be error-compatible with Microsoft's implementation, while
778 * still adhering to RFC 3280, I use a O(n ^ 2) algorithm to check name
779 * constraints.
780 */
781 for (i = chain->cElement - 1; i > 0; i--)
782 {
783 CERT_NAME_CONSTRAINTS_INFO *nameConstraints;
784
785 if ((nameConstraints = CRYPT_GetNameConstraints(
786 chain->rgpElement[i]->pCertContext->pCertInfo)))
787 {
788 if (!CRYPT_IsValidNameConstraint(nameConstraints))
789 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
790 CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT;
791 else
792 {
793 for (j = i - 1; j >= 0; j--)
794 {
795 DWORD errorStatus = 0;
796
797 /* According to RFC 3280, self-signed certs don't have name
798 * constraints checked unless they're the end cert.
799 */
800 if (j == 0 || !CRYPT_IsCertificateSelfSigned(
801 chain->rgpElement[j]->pCertContext))
802 {
803 CRYPT_CheckNameConstraints(nameConstraints,
804 chain->rgpElement[i]->pCertContext->pCertInfo,
805 &errorStatus);
806 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
807 errorStatus;
808 }
809 }
810 }
811 LocalFree(nameConstraints);
812 }
813 }
814 }
815
816 static LPWSTR name_value_to_str(const CERT_NAME_BLOB *name)
817 {
818 DWORD len = cert_name_to_str_with_indent(X509_ASN_ENCODING, 0, name,
819 CERT_SIMPLE_NAME_STR, NULL, 0);
820 LPWSTR str = NULL;
821
822 if (len)
823 {
824 str = CryptMemAlloc(len * sizeof(WCHAR));
825 if (str)
826 cert_name_to_str_with_indent(X509_ASN_ENCODING, 0, name,
827 CERT_SIMPLE_NAME_STR, str, len);
828 }
829 return str;
830 }
831
832 static void dump_alt_name_entry(const CERT_ALT_NAME_ENTRY *entry)
833 {
834 LPWSTR str;
835
836 switch (entry->dwAltNameChoice)
837 {
838 case CERT_ALT_NAME_OTHER_NAME:
839 TRACE_(chain)("CERT_ALT_NAME_OTHER_NAME, oid = %s\n",
840 debugstr_a(entry->u.pOtherName->pszObjId));
841 break;
842 case CERT_ALT_NAME_RFC822_NAME:
843 TRACE_(chain)("CERT_ALT_NAME_RFC822_NAME: %s\n",
844 debugstr_w(entry->u.pwszRfc822Name));
845 break;
846 case CERT_ALT_NAME_DNS_NAME:
847 TRACE_(chain)("CERT_ALT_NAME_DNS_NAME: %s\n",
848 debugstr_w(entry->u.pwszDNSName));
849 break;
850 case CERT_ALT_NAME_DIRECTORY_NAME:
851 str = name_value_to_str(&entry->u.DirectoryName);
852 TRACE_(chain)("CERT_ALT_NAME_DIRECTORY_NAME: %s\n", debugstr_w(str));
853 CryptMemFree(str);
854 break;
855 case CERT_ALT_NAME_URL:
856 TRACE_(chain)("CERT_ALT_NAME_URL: %s\n", debugstr_w(entry->u.pwszURL));
857 break;
858 case CERT_ALT_NAME_IP_ADDRESS:
859 TRACE_(chain)("CERT_ALT_NAME_IP_ADDRESS: %d bytes\n",
860 entry->u.IPAddress.cbData);
861 break;
862 case CERT_ALT_NAME_REGISTERED_ID:
863 TRACE_(chain)("CERT_ALT_NAME_REGISTERED_ID: %s\n",
864 debugstr_a(entry->u.pszRegisteredID));
865 break;
866 default:
867 TRACE_(chain)("dwAltNameChoice = %d\n", entry->dwAltNameChoice);
868 }
869 }
870
871 static void dump_alt_name(LPCSTR type, const CERT_EXTENSION *ext)
872 {
873 CERT_ALT_NAME_INFO *name;
874 DWORD size;
875
876 TRACE_(chain)("%s:\n", type);
877 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_ALTERNATE_NAME,
878 ext->Value.pbData, ext->Value.cbData,
879 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL, &name, &size))
880 {
881 DWORD i;
882
883 TRACE_(chain)("%d alt name entries:\n", name->cAltEntry);
884 for (i = 0; i < name->cAltEntry; i++)
885 dump_alt_name_entry(&name->rgAltEntry[i]);
886 LocalFree(name);
887 }
888 }
889
890 static void dump_basic_constraints(const CERT_EXTENSION *ext)
891 {
892 CERT_BASIC_CONSTRAINTS_INFO *info;
893 DWORD size = 0;
894
895 if (CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
896 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
897 NULL, &info, &size))
898 {
899 TRACE_(chain)("SubjectType: %02x\n", info->SubjectType.pbData[0]);
900 TRACE_(chain)("%s path length constraint\n",
901 info->fPathLenConstraint ? "has" : "doesn't have");
902 TRACE_(chain)("path length=%d\n", info->dwPathLenConstraint);
903 LocalFree(info);
904 }
905 }
906
907 static void dump_basic_constraints2(const CERT_EXTENSION *ext)
908 {
909 CERT_BASIC_CONSTRAINTS2_INFO constraints;
910 DWORD size = sizeof(CERT_BASIC_CONSTRAINTS2_INFO);
911
912 if (CryptDecodeObjectEx(X509_ASN_ENCODING,
913 szOID_BASIC_CONSTRAINTS2, ext->Value.pbData, ext->Value.cbData,
914 0, NULL, &constraints, &size))
915 {
916 TRACE_(chain)("basic constraints:\n");
917 TRACE_(chain)("can%s be a CA\n", constraints.fCA ? "" : "not");
918 TRACE_(chain)("%s path length constraint\n",
919 constraints.fPathLenConstraint ? "has" : "doesn't have");
920 TRACE_(chain)("path length=%d\n", constraints.dwPathLenConstraint);
921 }
922 }
923
924 static void dump_key_usage(const CERT_EXTENSION *ext)
925 {
926 CRYPT_BIT_BLOB usage;
927 DWORD size = sizeof(usage);
928
929 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_BITS, ext->Value.pbData,
930 ext->Value.cbData, CRYPT_DECODE_NOCOPY_FLAG, NULL, &usage, &size))
931 {
932 #define trace_usage_bit(bits, bit) \
933 if ((bits) & (bit)) TRACE_(chain)("%s\n", #bit)
934 if (usage.cbData)
935 {
936 trace_usage_bit(usage.pbData[0], CERT_DIGITAL_SIGNATURE_KEY_USAGE);
937 trace_usage_bit(usage.pbData[0], CERT_NON_REPUDIATION_KEY_USAGE);
938 trace_usage_bit(usage.pbData[0], CERT_KEY_ENCIPHERMENT_KEY_USAGE);
939 trace_usage_bit(usage.pbData[0], CERT_DATA_ENCIPHERMENT_KEY_USAGE);
940 trace_usage_bit(usage.pbData[0], CERT_KEY_AGREEMENT_KEY_USAGE);
941 trace_usage_bit(usage.pbData[0], CERT_KEY_CERT_SIGN_KEY_USAGE);
942 trace_usage_bit(usage.pbData[0], CERT_CRL_SIGN_KEY_USAGE);
943 trace_usage_bit(usage.pbData[0], CERT_ENCIPHER_ONLY_KEY_USAGE);
944 }
945 #undef trace_usage_bit
946 if (usage.cbData > 1 && usage.pbData[1] & CERT_DECIPHER_ONLY_KEY_USAGE)
947 TRACE_(chain)("CERT_DECIPHER_ONLY_KEY_USAGE\n");
948 }
949 }
950
951 static void dump_general_subtree(const CERT_GENERAL_SUBTREE *subtree)
952 {
953 dump_alt_name_entry(&subtree->Base);
954 TRACE_(chain)("dwMinimum = %d, fMaximum = %d, dwMaximum = %d\n",
955 subtree->dwMinimum, subtree->fMaximum, subtree->dwMaximum);
956 }
957
958 static void dump_name_constraints(const CERT_EXTENSION *ext)
959 {
960 CERT_NAME_CONSTRAINTS_INFO *nameConstraints;
961 DWORD size;
962
963 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME_CONSTRAINTS,
964 ext->Value.pbData, ext->Value.cbData,
965 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL, &nameConstraints,
966 &size))
967 {
968 DWORD i;
969
970 TRACE_(chain)("%d permitted subtrees:\n",
971 nameConstraints->cPermittedSubtree);
972 for (i = 0; i < nameConstraints->cPermittedSubtree; i++)
973 dump_general_subtree(&nameConstraints->rgPermittedSubtree[i]);
974 TRACE_(chain)("%d excluded subtrees:\n",
975 nameConstraints->cExcludedSubtree);
976 for (i = 0; i < nameConstraints->cExcludedSubtree; i++)
977 dump_general_subtree(&nameConstraints->rgExcludedSubtree[i]);
978 LocalFree(nameConstraints);
979 }
980 }
981
982 static void dump_cert_policies(const CERT_EXTENSION *ext)
983 {
984 CERT_POLICIES_INFO *policies;
985 DWORD size;
986
987 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_POLICIES,
988 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
989 &policies, &size))
990 {
991 DWORD i, j;
992
993 TRACE_(chain)("%d policies:\n", policies->cPolicyInfo);
994 for (i = 0; i < policies->cPolicyInfo; i++)
995 {
996 TRACE_(chain)("policy identifier: %s\n",
997 debugstr_a(policies->rgPolicyInfo[i].pszPolicyIdentifier));
998 TRACE_(chain)("%d policy qualifiers:\n",
999 policies->rgPolicyInfo[i].cPolicyQualifier);
1000 for (j = 0; j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
1001 TRACE_(chain)("%s\n", debugstr_a(
1002 policies->rgPolicyInfo[i].rgPolicyQualifier[j].
1003 pszPolicyQualifierId));
1004 }
1005 LocalFree(policies);
1006 }
1007 }
1008
1009 static void dump_enhanced_key_usage(const CERT_EXTENSION *ext)
1010 {
1011 CERT_ENHKEY_USAGE *usage;
1012 DWORD size;
1013
1014 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_ENHANCED_KEY_USAGE,
1015 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
1016 &usage, &size))
1017 {
1018 DWORD i;
1019
1020 TRACE_(chain)("%d usages:\n", usage->cUsageIdentifier);
1021 for (i = 0; i < usage->cUsageIdentifier; i++)
1022 TRACE_(chain)("%s\n", usage->rgpszUsageIdentifier[i]);
1023 LocalFree(usage);
1024 }
1025 }
1026
1027 static void dump_netscape_cert_type(const CERT_EXTENSION *ext)
1028 {
1029 CRYPT_BIT_BLOB usage;
1030 DWORD size = sizeof(usage);
1031
1032 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_BITS, ext->Value.pbData,
1033 ext->Value.cbData, CRYPT_DECODE_NOCOPY_FLAG, NULL, &usage, &size))
1034 {
1035 #define trace_cert_type_bit(bits, bit) \
1036 if ((bits) & (bit)) TRACE_(chain)("%s\n", #bit)
1037 if (usage.cbData)
1038 {
1039 trace_cert_type_bit(usage.pbData[0],
1040 NETSCAPE_SSL_CLIENT_AUTH_CERT_TYPE);
1041 trace_cert_type_bit(usage.pbData[0],
1042 NETSCAPE_SSL_SERVER_AUTH_CERT_TYPE);
1043 trace_cert_type_bit(usage.pbData[0], NETSCAPE_SMIME_CERT_TYPE);
1044 trace_cert_type_bit(usage.pbData[0], NETSCAPE_SIGN_CERT_TYPE);
1045 trace_cert_type_bit(usage.pbData[0], NETSCAPE_SSL_CA_CERT_TYPE);
1046 trace_cert_type_bit(usage.pbData[0], NETSCAPE_SMIME_CA_CERT_TYPE);
1047 trace_cert_type_bit(usage.pbData[0], NETSCAPE_SIGN_CA_CERT_TYPE);
1048 }
1049 #undef trace_cert_type_bit
1050 }
1051 }
1052
1053 static void dump_extension(const CERT_EXTENSION *ext)
1054 {
1055 TRACE_(chain)("%s (%scritical)\n", debugstr_a(ext->pszObjId),
1056 ext->fCritical ? "" : "not ");
1057 if (!strcmp(ext->pszObjId, szOID_SUBJECT_ALT_NAME))
1058 dump_alt_name("subject alt name", ext);
1059 else if (!strcmp(ext->pszObjId, szOID_ISSUER_ALT_NAME))
1060 dump_alt_name("issuer alt name", ext);
1061 else if (!strcmp(ext->pszObjId, szOID_BASIC_CONSTRAINTS))
1062 dump_basic_constraints(ext);
1063 else if (!strcmp(ext->pszObjId, szOID_KEY_USAGE))
1064 dump_key_usage(ext);
1065 else if (!strcmp(ext->pszObjId, szOID_SUBJECT_ALT_NAME2))
1066 dump_alt_name("subject alt name 2", ext);
1067 else if (!strcmp(ext->pszObjId, szOID_ISSUER_ALT_NAME2))
1068 dump_alt_name("issuer alt name 2", ext);
1069 else if (!strcmp(ext->pszObjId, szOID_BASIC_CONSTRAINTS2))
1070 dump_basic_constraints2(ext);
1071 else if (!strcmp(ext->pszObjId, szOID_NAME_CONSTRAINTS))
1072 dump_name_constraints(ext);
1073 else if (!strcmp(ext->pszObjId, szOID_CERT_POLICIES))
1074 dump_cert_policies(ext);
1075 else if (!strcmp(ext->pszObjId, szOID_ENHANCED_KEY_USAGE))
1076 dump_enhanced_key_usage(ext);
1077 else if (!strcmp(ext->pszObjId, szOID_NETSCAPE_CERT_TYPE))
1078 dump_netscape_cert_type(ext);
1079 }
1080
1081 static LPCWSTR filetime_to_str(const FILETIME *time)
1082 {
1083 static WCHAR date[80];
1084 WCHAR dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
1085 SYSTEMTIME sysTime;
1086
1087 if (!time) return NULL;
1088
1089 GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
1090 sizeof(dateFmt) / sizeof(dateFmt[0]));
1091 FileTimeToSystemTime(time, &sysTime);
1092 GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
1093 sizeof(date) / sizeof(date[0]));
1094 return date;
1095 }
1096
1097 static void dump_element(PCCERT_CONTEXT cert)
1098 {
1099 LPWSTR name = NULL;
1100 DWORD len, i;
1101
1102 TRACE_(chain)("%p\n", cert);
1103 len = CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1104 CERT_NAME_ISSUER_FLAG, NULL, NULL, 0);
1105 name = CryptMemAlloc(len * sizeof(WCHAR));
1106 if (name)
1107 {
1108 CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1109 CERT_NAME_ISSUER_FLAG, NULL, name, len);
1110 TRACE_(chain)("issued by %s\n", debugstr_w(name));
1111 CryptMemFree(name);
1112 }
1113 len = CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL,
1114 NULL, 0);
1115 name = CryptMemAlloc(len * sizeof(WCHAR));
1116 if (name)
1117 {
1118 CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL,
1119 name, len);
1120 TRACE_(chain)("issued to %s\n", debugstr_w(name));
1121 CryptMemFree(name);
1122 }
1123 TRACE_(chain)("valid from %s to %s\n",
1124 debugstr_w(filetime_to_str(&cert->pCertInfo->NotBefore)),
1125 debugstr_w(filetime_to_str(&cert->pCertInfo->NotAfter)));
1126 TRACE_(chain)("%d extensions\n", cert->pCertInfo->cExtension);
1127 for (i = 0; i < cert->pCertInfo->cExtension; i++)
1128 dump_extension(&cert->pCertInfo->rgExtension[i]);
1129 }
1130
1131 static BOOL CRYPT_KeyUsageValid(PCertificateChainEngine engine,
1132 PCCERT_CONTEXT cert, BOOL isRoot, BOOL isCA, DWORD index)
1133 {
1134 PCERT_EXTENSION ext;
1135 BOOL ret;
1136 BYTE usageBits = 0;
1137
1138 ext = CertFindExtension(szOID_KEY_USAGE, cert->pCertInfo->cExtension,
1139 cert->pCertInfo->rgExtension);
1140 if (ext)
1141 {
1142 CRYPT_BIT_BLOB usage;
1143 DWORD size = sizeof(usage);
1144
1145 ret = CryptDecodeObjectEx(cert->dwCertEncodingType, X509_BITS,
1146 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_NOCOPY_FLAG, NULL,
1147 &usage, &size);
1148 if (!ret)
1149 return FALSE;
1150 else if (usage.cbData > 2)
1151 {
1152 /* The key usage extension only defines 9 bits => no more than 2
1153 * bytes are needed to encode all known usages.
1154 */
1155 return FALSE;
1156 }
1157 else
1158 {
1159 /* The only bit relevant to chain validation is the keyCertSign
1160 * bit, which is always in the least significant byte of the
1161 * key usage bits.
1162 */
1163 usageBits = usage.pbData[usage.cbData - 1];
1164 }
1165 }
1166 if (isCA)
1167 {
1168 if (!ext)
1169 {
1170 /* MS appears to violate RFC 5280, section 4.2.1.3 (Key Usage)
1171 * here. Quoting the RFC:
1172 * "This [key usage] extension MUST appear in certificates that
1173 * contain public keys that are used to validate digital signatures
1174 * on other public key certificates or CRLs."
1175 * MS appears to accept certs that do not contain key usage
1176 * extensions as CA certs. V1 and V2 certificates did not have
1177 * extensions, and many root certificates are V1 certificates, so
1178 * perhaps this is prudent. On the other hand, MS also accepts V3
1179 * certs without key usage extensions. We are more restrictive:
1180 * we accept locally installed V1 or V2 certs as CA certs.
1181 * We also accept a lack of key usage extension on root certs,
1182 * which is implied in RFC 5280, section 6.1: the trust anchor's
1183 * only requirement is that it was used to issue the next
1184 * certificate in the chain.
1185 */
1186 if (isRoot)
1187 ret = TRUE;
1188 else if (cert->pCertInfo->dwVersion == CERT_V1 ||
1189 cert->pCertInfo->dwVersion == CERT_V2)
1190 {
1191 PCCERT_CONTEXT localCert = CRYPT_FindCertInStore(
1192 engine->hWorld, cert);
1193
1194 ret = localCert != NULL;
1195 CertFreeCertificateContext(localCert);
1196 }
1197 else
1198 ret = FALSE;
1199 if (!ret)
1200 WARN_(chain)("no key usage extension on a CA cert\n");
1201 }
1202 else
1203 {
1204 if (!(usageBits & CERT_KEY_CERT_SIGN_KEY_USAGE))
1205 {
1206 WARN_(chain)("keyCertSign not asserted on a CA cert\n");
1207 ret = FALSE;
1208 }
1209 else
1210 ret = TRUE;
1211 }
1212 }
1213 else
1214 {
1215 if (ext && (usageBits & CERT_KEY_CERT_SIGN_KEY_USAGE))
1216 {
1217 WARN_(chain)("keyCertSign asserted on a non-CA cert\n");
1218 ret = FALSE;
1219 }
1220 else
1221 ret = TRUE;
1222 }
1223 return ret;
1224 }
1225
1226 static BOOL CRYPT_ExtendedKeyUsageValidForCA(PCCERT_CONTEXT cert)
1227 {
1228 PCERT_EXTENSION ext;
1229 BOOL ret;
1230
1231 /* RFC 5280, section 4.2.1.12: "In general, this extension will only
1232 * appear in end entity certificates." And, "If a certificate contains
1233 * both a key usage extension and an extended key usage extension, then
1234 * both extensions MUST be processed independently and the certificate MUST
1235 * only be used for a purpose consistent with both extensions." This seems
1236 * to imply that it should be checked if present, and ignored if not.
1237 * Unfortunately some CAs, e.g. the Thawte SGC CA, don't include the code
1238 * signing extended key usage, whereas they do include the keyCertSign
1239 * key usage. Thus, when checking for a CA, we only require the
1240 * code signing extended key usage if the extended key usage is critical.
1241 */
1242 ext = CertFindExtension(szOID_ENHANCED_KEY_USAGE,
1243 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
1244 if (ext && ext->fCritical)
1245 {
1246 CERT_ENHKEY_USAGE *usage;
1247 DWORD size;
1248
1249 ret = CryptDecodeObjectEx(cert->dwCertEncodingType,
1250 X509_ENHANCED_KEY_USAGE, ext->Value.pbData, ext->Value.cbData,
1251 CRYPT_DECODE_ALLOC_FLAG, NULL, &usage, &size);
1252 if (ret)
1253 {
1254 DWORD i;
1255
1256 /* Explicitly require the code signing extended key usage for a CA
1257 * with an extended key usage extension. That is, don't assume
1258 * a cert is allowed to be a CA if it specifies the
1259 * anyExtendedKeyUsage usage oid. See again RFC 5280, section
1260 * 4.2.1.12: "Applications that require the presence of a
1261 * particular purpose MAY reject certificates that include the
1262 * anyExtendedKeyUsage OID but not the particular OID expected for
1263 * the application."
1264 */
1265 ret = FALSE;
1266 for (i = 0; !ret && i < usage->cUsageIdentifier; i++)
1267 if (!strcmp(usage->rgpszUsageIdentifier[i],
1268 szOID_PKIX_KP_CODE_SIGNING))
1269 ret = TRUE;
1270 LocalFree(usage);
1271 }
1272 }
1273 else
1274 ret = TRUE;
1275 return ret;
1276 }
1277
1278 static BOOL CRYPT_CriticalExtensionsSupported(PCCERT_CONTEXT cert)
1279 {
1280 BOOL ret = TRUE;
1281 DWORD i;
1282
1283 for (i = 0; ret && i < cert->pCertInfo->cExtension; i++)
1284 {
1285 if (cert->pCertInfo->rgExtension[i].fCritical)
1286 {
1287 LPCSTR oid = cert->pCertInfo->rgExtension[i].pszObjId;
1288
1289 if (!strcmp(oid, szOID_BASIC_CONSTRAINTS))
1290 ret = TRUE;
1291 else if (!strcmp(oid, szOID_BASIC_CONSTRAINTS2))
1292 ret = TRUE;
1293 else if (!strcmp(oid, szOID_NAME_CONSTRAINTS))
1294 ret = TRUE;
1295 else if (!strcmp(oid, szOID_KEY_USAGE))
1296 ret = TRUE;
1297 else if (!strcmp(oid, szOID_SUBJECT_ALT_NAME))
1298 ret = TRUE;
1299 else if (!strcmp(oid, szOID_SUBJECT_ALT_NAME2))
1300 ret = TRUE;
1301 else if (!strcmp(oid, szOID_ENHANCED_KEY_USAGE))
1302 ret = TRUE;
1303 else
1304 {
1305 FIXME("unsupported critical extension %s\n",
1306 debugstr_a(oid));
1307 ret = FALSE;
1308 }
1309 }
1310 }
1311 return ret;
1312 }
1313
1314 static void CRYPT_CheckSimpleChain(PCertificateChainEngine engine,
1315 PCERT_SIMPLE_CHAIN chain, LPFILETIME time)
1316 {
1317 PCERT_CHAIN_ELEMENT rootElement = chain->rgpElement[chain->cElement - 1];
1318 int i;
1319 BOOL pathLengthConstraintViolated = FALSE;
1320 CERT_BASIC_CONSTRAINTS2_INFO constraints = { FALSE, FALSE, 0 };
1321
1322 TRACE_(chain)("checking chain with %d elements for time %s\n",
1323 chain->cElement, debugstr_w(filetime_to_str(time)));
1324 for (i = chain->cElement - 1; i >= 0; i--)
1325 {
1326 BOOL isRoot;
1327
1328 if (TRACE_ON(chain))
1329 dump_element(chain->rgpElement[i]->pCertContext);
1330 if (i == chain->cElement - 1)
1331 isRoot = CRYPT_IsCertificateSelfSigned(
1332 chain->rgpElement[i]->pCertContext);
1333 else
1334 isRoot = FALSE;
1335 if (CertVerifyTimeValidity(time,
1336 chain->rgpElement[i]->pCertContext->pCertInfo) != 0)
1337 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1338 CERT_TRUST_IS_NOT_TIME_VALID;
1339 if (i != 0)
1340 {
1341 /* Check the signature of the cert this issued */
1342 if (!CryptVerifyCertificateSignatureEx(0, X509_ASN_ENCODING,
1343 CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT,
1344 (void *)chain->rgpElement[i - 1]->pCertContext,
1345 CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT,
1346 (void *)chain->rgpElement[i]->pCertContext, 0, NULL))
1347 chain->rgpElement[i - 1]->TrustStatus.dwErrorStatus |=
1348 CERT_TRUST_IS_NOT_SIGNATURE_VALID;
1349 /* Once a path length constraint has been violated, every remaining
1350 * CA cert's basic constraints is considered invalid.
1351 */
1352 if (pathLengthConstraintViolated)
1353 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1354 CERT_TRUST_INVALID_BASIC_CONSTRAINTS;
1355 else if (!CRYPT_CheckBasicConstraintsForCA(engine,
1356 chain->rgpElement[i]->pCertContext, &constraints, i - 1, isRoot,
1357 &pathLengthConstraintViolated))
1358 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1359 CERT_TRUST_INVALID_BASIC_CONSTRAINTS;
1360 else if (constraints.fPathLenConstraint &&
1361 constraints.dwPathLenConstraint)
1362 {
1363 /* This one's valid - decrement max length */
1364 constraints.dwPathLenConstraint--;
1365 }
1366 }
1367 else
1368 {
1369 /* Check whether end cert has a basic constraints extension */
1370 if (!CRYPT_DecodeBasicConstraints(
1371 chain->rgpElement[i]->pCertContext, &constraints, FALSE))
1372 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1373 CERT_TRUST_INVALID_BASIC_CONSTRAINTS;
1374 }
1375 if (!CRYPT_KeyUsageValid(engine, chain->rgpElement[i]->pCertContext,
1376 isRoot, constraints.fCA, i))
1377 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1378 CERT_TRUST_IS_NOT_VALID_FOR_USAGE;
1379 if (i != 0)
1380 if (!CRYPT_ExtendedKeyUsageValidForCA(
1381 chain->rgpElement[i]->pCertContext))
1382 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1383 CERT_TRUST_IS_NOT_VALID_FOR_USAGE;
1384 if (CRYPT_IsSimpleChainCyclic(chain))
1385 {
1386 /* If the chain is cyclic, then the path length constraints
1387 * are violated, because the chain is infinitely long.
1388 */
1389 pathLengthConstraintViolated = TRUE;
1390 chain->TrustStatus.dwErrorStatus |=
1391 CERT_TRUST_IS_PARTIAL_CHAIN |
1392 CERT_TRUST_INVALID_BASIC_CONSTRAINTS;
1393 }
1394 /* Check whether every critical extension is supported */
1395 if (!CRYPT_CriticalExtensionsSupported(
1396 chain->rgpElement[i]->pCertContext))
1397 chain->rgpElement[i]->TrustStatus.dwErrorStatus |=
1398 CERT_TRUST_INVALID_EXTENSION;
1399 CRYPT_CombineTrustStatus(&chain->TrustStatus,
1400 &chain->rgpElement[i]->TrustStatus);
1401 }
1402 CRYPT_CheckChainNameConstraints(chain);
1403 if (CRYPT_IsCertificateSelfSigned(rootElement->pCertContext))
1404 {
1405 rootElement->TrustStatus.dwInfoStatus |=
1406 CERT_TRUST_IS_SELF_SIGNED | CERT_TRUST_HAS_NAME_MATCH_ISSUER;
1407 CRYPT_CheckRootCert(engine->hRoot, rootElement);
1408 }
1409 CRYPT_CombineTrustStatus(&chain->TrustStatus, &rootElement->TrustStatus);
1410 }
1411
1412 static PCCERT_CONTEXT CRYPT_GetIssuer(HCERTSTORE store, PCCERT_CONTEXT subject,
1413 PCCERT_CONTEXT prevIssuer, DWORD *infoStatus)
1414 {
1415 PCCERT_CONTEXT issuer = NULL;
1416 PCERT_EXTENSION ext;
1417 DWORD size;
1418
1419 *infoStatus = 0;
1420 if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER,
1421 subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)))
1422 {
1423 CERT_AUTHORITY_KEY_ID_INFO *info;
1424 BOOL ret;
1425
1426 ret = CryptDecodeObjectEx(subject->dwCertEncodingType,
1427 X509_AUTHORITY_KEY_ID, ext->Value.pbData, ext->Value.cbData,
1428 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
1429 &info, &size);
1430 if (ret)
1431 {
1432 CERT_ID id;
1433
1434 if (info->CertIssuer.cbData && info->CertSerialNumber.cbData)
1435 {
1436 id.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
1437 memcpy(&id.u.IssuerSerialNumber.Issuer, &info->CertIssuer,
1438 sizeof(CERT_NAME_BLOB));
1439 memcpy(&id.u.IssuerSerialNumber.SerialNumber,
1440 &info->CertSerialNumber, sizeof(CRYPT_INTEGER_BLOB));
1441 issuer = CertFindCertificateInStore(store,
1442 subject->dwCertEncodingType, 0, CERT_FIND_CERT_ID, &id,
1443 prevIssuer);
1444 if (issuer)
1445 *infoStatus = CERT_TRUST_HAS_EXACT_MATCH_ISSUER;
1446 }
1447 else if (info->KeyId.cbData)
1448 {
1449 id.dwIdChoice = CERT_ID_KEY_IDENTIFIER;
1450 memcpy(&id.u.KeyId, &info->KeyId, sizeof(CRYPT_HASH_BLOB));
1451 issuer = CertFindCertificateInStore(store,
1452 subject->dwCertEncodingType, 0, CERT_FIND_CERT_ID, &id,
1453 prevIssuer);
1454 if (issuer)
1455 *infoStatus = CERT_TRUST_HAS_KEY_MATCH_ISSUER;
1456 }
1457 LocalFree(info);
1458 }
1459 }
1460 else if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER2,
1461 subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)))
1462 {
1463 CERT_AUTHORITY_KEY_ID2_INFO *info;
1464 BOOL ret;
1465
1466 ret = CryptDecodeObjectEx(subject->dwCertEncodingType,
1467 X509_AUTHORITY_KEY_ID2, ext->Value.pbData, ext->Value.cbData,
1468 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
1469 &info, &size);
1470 if (ret)
1471 {
1472 CERT_ID id;
1473
1474 if (info->AuthorityCertIssuer.cAltEntry &&
1475 info->AuthorityCertSerialNumber.cbData)
1476 {
1477 PCERT_ALT_NAME_ENTRY directoryName = NULL;
1478 DWORD i;
1479
1480 for (i = 0; !directoryName &&
1481 i < info->AuthorityCertIssuer.cAltEntry; i++)
1482 if (info->AuthorityCertIssuer.rgAltEntry[i].dwAltNameChoice
1483 == CERT_ALT_NAME_DIRECTORY_NAME)
1484 directoryName =
1485 &info->AuthorityCertIssuer.rgAltEntry[i];
1486 if (directoryName)
1487 {
1488 id.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
1489 memcpy(&id.u.IssuerSerialNumber.Issuer,
1490 &directoryName->u.DirectoryName, sizeof(CERT_NAME_BLOB));
1491 memcpy(&id.u.IssuerSerialNumber.SerialNumber,
1492 &info->AuthorityCertSerialNumber,
1493 sizeof(CRYPT_INTEGER_BLOB));
1494 issuer = CertFindCertificateInStore(store,
1495 subject->dwCertEncodingType, 0, CERT_FIND_CERT_ID, &id,
1496 prevIssuer);
1497 if (issuer)
1498 *infoStatus = CERT_TRUST_HAS_EXACT_MATCH_ISSUER;
1499 }
1500 else
1501 FIXME("no supported name type in authority key id2\n");
1502 }
1503 else if (info->KeyId.cbData)
1504 {
1505 id.dwIdChoice = CERT_ID_KEY_IDENTIFIER;
1506 memcpy(&id.u.KeyId, &info->KeyId, sizeof(CRYPT_HASH_BLOB));
1507 issuer = CertFindCertificateInStore(store,
1508 subject->dwCertEncodingType, 0, CERT_FIND_CERT_ID, &id,
1509 prevIssuer);
1510 if (issuer)
1511 *infoStatus = CERT_TRUST_HAS_KEY_MATCH_ISSUER;
1512 }
1513 LocalFree(info);
1514 }
1515 }
1516 else
1517 {
1518 issuer = CertFindCertificateInStore(store,
1519 subject->dwCertEncodingType, 0, CERT_FIND_SUBJECT_NAME,
1520 &subject->pCertInfo->Issuer, prevIssuer);
1521 *infoStatus = CERT_TRUST_HAS_NAME_MATCH_ISSUER;
1522 }
1523 return issuer;
1524 }
1525
1526 /* Builds a simple chain by finding an issuer for the last cert in the chain,
1527 * until reaching a self-signed cert, or until no issuer can be found.
1528 */
1529 static BOOL CRYPT_BuildSimpleChain(const CertificateChainEngine *engine,
1530 HCERTSTORE world, PCERT_SIMPLE_CHAIN chain)
1531 {
1532 BOOL ret = TRUE;
1533 PCCERT_CONTEXT cert = chain->rgpElement[chain->cElement - 1]->pCertContext;
1534
1535 while (ret && !CRYPT_IsSimpleChainCyclic(chain) &&
1536 !CRYPT_IsCertificateSelfSigned(cert))
1537 {
1538 PCCERT_CONTEXT issuer = CRYPT_GetIssuer(world, cert, NULL,
1539 &chain->rgpElement[chain->cElement - 1]->TrustStatus.dwInfoStatus);
1540
1541 if (issuer)
1542 {
1543 ret = CRYPT_AddCertToSimpleChain(engine, chain, issuer,
1544 chain->rgpElement[chain->cElement - 1]->TrustStatus.dwInfoStatus);
1545 /* CRYPT_AddCertToSimpleChain add-ref's the issuer, so free it to
1546 * close the enumeration that found it
1547 */
1548 CertFreeCertificateContext(issuer);
1549 cert = issuer;
1550 }
1551 else
1552 {
1553 TRACE_(chain)("Couldn't find issuer, halting chain creation\n");
1554 chain->TrustStatus.dwErrorStatus |= CERT_TRUST_IS_PARTIAL_CHAIN;
1555 break;
1556 }
1557 }
1558 return ret;
1559 }
1560
1561 static BOOL CRYPT_GetSimpleChainForCert(PCertificateChainEngine engine,
1562 HCERTSTORE world, PCCERT_CONTEXT cert, LPFILETIME pTime,
1563 PCERT_SIMPLE_CHAIN *ppChain)
1564 {
1565 BOOL ret = FALSE;
1566 PCERT_SIMPLE_CHAIN chain;
1567
1568 TRACE("(%p, %p, %p, %p)\n", engine, world, cert, pTime);
1569
1570 chain = CryptMemAlloc(sizeof(CERT_SIMPLE_CHAIN));
1571 if (chain)
1572 {
1573 memset(chain, 0, sizeof(CERT_SIMPLE_CHAIN));
1574 chain->cbSize = sizeof(CERT_SIMPLE_CHAIN);
1575 ret = CRYPT_AddCertToSimpleChain(engine, chain, cert, 0);
1576 if (ret)
1577 {
1578 ret = CRYPT_BuildSimpleChain(engine, world, chain);
1579 if (ret)
1580 CRYPT_CheckSimpleChain(engine, chain, pTime);
1581 }
1582 if (!ret)
1583 {
1584 CRYPT_FreeSimpleChain(chain);
1585 chain = NULL;
1586 }
1587 *ppChain = chain;
1588 }
1589 return ret;
1590 }
1591
1592 static BOOL CRYPT_BuildCandidateChainFromCert(HCERTCHAINENGINE hChainEngine,
1593 PCCERT_CONTEXT cert, LPFILETIME pTime, HCERTSTORE hAdditionalStore,
1594 PCertificateChain *ppChain)
1595 {
1596 PCertificateChainEngine engine = (PCertificateChainEngine)hChainEngine;
1597 PCERT_SIMPLE_CHAIN simpleChain = NULL;
1598 HCERTSTORE world;
1599 BOOL ret;
1600
1601 world = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0,
1602 CERT_STORE_CREATE_NEW_FLAG, NULL);
1603 CertAddStoreToCollection(world, engine->hWorld, 0, 0);
1604 if (hAdditionalStore)
1605 CertAddStoreToCollection(world, hAdditionalStore, 0, 0);
1606 /* FIXME: only simple chains are supported for now, as CTLs aren't
1607 * supported yet.
1608 */
1609 if ((ret = CRYPT_GetSimpleChainForCert(engine, world, cert, pTime,
1610 &simpleChain)))
1611 {
1612 PCertificateChain chain = CryptMemAlloc(sizeof(CertificateChain));
1613
1614 if (chain)
1615 {
1616 chain->ref = 1;
1617 chain->world = world;
1618 chain->context.cbSize = sizeof(CERT_CHAIN_CONTEXT);
1619 chain->context.TrustStatus = simpleChain->TrustStatus;
1620 chain->context.cChain = 1;
1621 chain->context.rgpChain = CryptMemAlloc(sizeof(PCERT_SIMPLE_CHAIN));
1622 chain->context.rgpChain[0] = simpleChain;
1623 chain->context.cLowerQualityChainContext = 0;
1624 chain->context.rgpLowerQualityChainContext = NULL;
1625 chain->context.fHasRevocationFreshnessTime = FALSE;
1626 chain->context.dwRevocationFreshnessTime = 0;
1627 }
1628 else
1629 ret = FALSE;
1630 *ppChain = chain;
1631 }
1632 return ret;
1633 }
1634
1635 /* Makes and returns a copy of chain, up to and including element iElement. */
1636 static PCERT_SIMPLE_CHAIN CRYPT_CopySimpleChainToElement(
1637 const CERT_SIMPLE_CHAIN *chain, DWORD iElement)
1638 {
1639 PCERT_SIMPLE_CHAIN copy = CryptMemAlloc(sizeof(CERT_SIMPLE_CHAIN));
1640
1641 if (copy)
1642 {
1643 memset(copy, 0, sizeof(CERT_SIMPLE_CHAIN));
1644 copy->cbSize = sizeof(CERT_SIMPLE_CHAIN);
1645 copy->rgpElement =
1646 CryptMemAlloc((iElement + 1) * sizeof(PCERT_CHAIN_ELEMENT));
1647 if (copy->rgpElement)
1648 {
1649 DWORD i;
1650 BOOL ret = TRUE;
1651
1652 memset(copy->rgpElement, 0,
1653 (iElement + 1) * sizeof(PCERT_CHAIN_ELEMENT));
1654 for (i = 0; ret && i <= iElement; i++)
1655 {
1656 PCERT_CHAIN_ELEMENT element =
1657 CryptMemAlloc(sizeof(CERT_CHAIN_ELEMENT));
1658
1659 if (element)
1660 {
1661 *element = *chain->rgpElement[i];
1662 element->pCertContext = CertDuplicateCertificateContext(
1663 chain->rgpElement[i]->pCertContext);
1664 /* Reset the trust status of the copied element, it'll get
1665 * rechecked after the new chain is done.
1666 */
1667 memset(&element->TrustStatus, 0, sizeof(CERT_TRUST_STATUS));
1668 copy->rgpElement[copy->cElement++] = element;
1669 }
1670 else
1671 ret = FALSE;
1672 }
1673 if (!ret)
1674 {
1675 for (i = 0; i <= iElement; i++)
1676 CryptMemFree(copy->rgpElement[i]);
1677 CryptMemFree(copy->rgpElement);
1678 CryptMemFree(copy);
1679 copy = NULL;
1680 }
1681 }
1682 else
1683 {
1684 CryptMemFree(copy);
1685 copy = NULL;
1686 }
1687 }
1688 return copy;
1689 }
1690
1691 static void CRYPT_FreeLowerQualityChains(PCertificateChain chain)
1692 {
1693 DWORD i;
1694
1695 for (i = 0; i < chain->context.cLowerQualityChainContext; i++)
1696 CertFreeCertificateChain(chain->context.rgpLowerQualityChainContext[i]);
1697 CryptMemFree(chain->context.rgpLowerQualityChainContext);
1698 chain->context.cLowerQualityChainContext = 0;
1699 chain->context.rgpLowerQualityChainContext = NULL;
1700 }
1701
1702 static void CRYPT_FreeChainContext(PCertificateChain chain)
1703 {
1704 DWORD i;
1705
1706 CRYPT_FreeLowerQualityChains(chain);
1707 for (i = 0; i < chain->context.cChain; i++)
1708 CRYPT_FreeSimpleChain(chain->context.rgpChain[i]);
1709 CryptMemFree(chain->context.rgpChain);
1710 CertCloseStore(chain->world, 0);
1711 CryptMemFree(chain);
1712 }
1713
1714 /* Makes and returns a copy of chain, up to and including element iElement of
1715 * simple chain iChain.
1716 */
1717 static PCertificateChain CRYPT_CopyChainToElement(PCertificateChain chain,
1718 DWORD iChain, DWORD iElement)
1719 {
1720 PCertificateChain copy = CryptMemAlloc(sizeof(CertificateChain));
1721
1722 if (copy)
1723 {
1724 copy->ref = 1;
1725 copy->world = CertDuplicateStore(chain->world);
1726 copy->context.cbSize = sizeof(CERT_CHAIN_CONTEXT);
1727 /* Leave the trust status of the copied chain unset, it'll get
1728 * rechecked after the new chain is done.
1729 */
1730 memset(&copy->context.TrustStatus, 0, sizeof(CERT_TRUST_STATUS));
1731 copy->context.cLowerQualityChainContext = 0;
1732 copy->context.rgpLowerQualityChainContext = NULL;
1733 copy->context.fHasRevocationFreshnessTime = FALSE;
1734 copy->context.dwRevocationFreshnessTime = 0;
1735 copy->context.rgpChain = CryptMemAlloc(
1736 (iChain + 1) * sizeof(PCERT_SIMPLE_CHAIN));
1737 if (copy->context.rgpChain)
1738 {
1739 BOOL ret = TRUE;
1740 DWORD i;
1741
1742 memset(copy->context.rgpChain, 0,
1743 (iChain + 1) * sizeof(PCERT_SIMPLE_CHAIN));
1744 if (iChain)
1745 {
1746 for (i = 0; ret && iChain && i < iChain - 1; i++)
1747 {
1748 copy->context.rgpChain[i] =
1749 CRYPT_CopySimpleChainToElement(chain->context.rgpChain[i],
1750 chain->context.rgpChain[i]->cElement - 1);
1751 if (!copy->context.rgpChain[i])
1752 ret = FALSE;
1753 }
1754 }
1755 else
1756 i = 0;
1757 if (ret)
1758 {
1759 copy->context.rgpChain[i] =
1760 CRYPT_CopySimpleChainToElement(chain->context.rgpChain[i],
1761 iElement);
1762 if (!copy->context.rgpChain[i])
1763 ret = FALSE;
1764 }
1765 if (!ret)
1766 {
1767 CRYPT_FreeChainContext(copy);
1768 copy = NULL;
1769 }
1770 else
1771 copy->context.cChain = iChain + 1;
1772 }
1773 else
1774 {
1775 CryptMemFree(copy);
1776 copy = NULL;
1777 }
1778 }
1779 return copy;
1780 }
1781
1782 static PCertificateChain CRYPT_BuildAlternateContextFromChain(
1783 HCERTCHAINENGINE hChainEngine, LPFILETIME pTime, HCERTSTORE hAdditionalStore,
1784 PCertificateChain chain)
1785 {
1786 PCertificateChainEngine engine = (PCertificateChainEngine)hChainEngine;
1787 PCertificateChain alternate;
1788
1789 TRACE("(%p, %p, %p, %p)\n", hChainEngine, pTime, hAdditionalStore, chain);
1790
1791 /* Always start with the last "lower quality" chain to ensure a consistent
1792 * order of alternate creation:
1793 */
1794 if (chain->context.cLowerQualityChainContext)
1795 chain = (PCertificateChain)chain->context.rgpLowerQualityChainContext[
1796 chain->context.cLowerQualityChainContext - 1];
1797 /* A chain with only one element can't have any alternates */
1798 if (chain->context.cChain <= 1 && chain->context.rgpChain[0]->cElement <= 1)
1799 alternate = NULL;
1800 else
1801 {
1802 DWORD i, j, infoStatus;
1803 PCCERT_CONTEXT alternateIssuer = NULL;
1804
1805 alternate = NULL;
1806 for (i = 0; !alternateIssuer && i < chain->context.cChain; i++)
1807 for (j = 0; !alternateIssuer &&
1808 j < chain->context.rgpChain[i]->cElement - 1; j++)
1809 {
1810 PCCERT_CONTEXT subject =
1811 chain->context.rgpChain[i]->rgpElement[j]->pCertContext;
1812 PCCERT_CONTEXT prevIssuer = CertDuplicateCertificateContext(
1813 chain->context.rgpChain[i]->rgpElement[j + 1]->pCertContext);
1814
1815 alternateIssuer = CRYPT_GetIssuer(prevIssuer->hCertStore,
1816 subject, prevIssuer, &infoStatus);
1817 }
1818 if (alternateIssuer)
1819 {
1820 i--;
1821 j--;
1822 alternate = CRYPT_CopyChainToElement(chain, i, j);
1823 if (alternate)
1824 {
1825 BOOL ret = CRYPT_AddCertToSimpleChain(engine,
1826 alternate->context.rgpChain[i], alternateIssuer, infoStatus);
1827
1828 /* CRYPT_AddCertToSimpleChain add-ref's the issuer, so free it
1829 * to close the enumeration that found it
1830 */
1831 CertFreeCertificateContext(alternateIssuer);
1832 if (ret)
1833 {
1834 ret = CRYPT_BuildSimpleChain(engine, alternate->world,
1835 alternate->context.rgpChain[i]);
1836 if (ret)
1837 CRYPT_CheckSimpleChain(engine,
1838 alternate->context.rgpChain[i], pTime);
1839 CRYPT_CombineTrustStatus(&alternate->context.TrustStatus,
1840 &alternate->context.rgpChain[i]->TrustStatus);
1841 }
1842 if (!ret)
1843 {
1844 CRYPT_FreeChainContext(alternate);
1845 alternate = NULL;
1846 }
1847 }
1848 }
1849 }
1850 TRACE("%p\n", alternate);
1851 return alternate;
1852 }
1853
1854 #define CHAIN_QUALITY_SIGNATURE_VALID 0x16
1855 #define CHAIN_QUALITY_TIME_VALID 8
1856 #define CHAIN_QUALITY_COMPLETE_CHAIN 4
1857 #define CHAIN_QUALITY_BASIC_CONSTRAINTS 2
1858 #define CHAIN_QUALITY_TRUSTED_ROOT 1
1859
1860 #define CHAIN_QUALITY_HIGHEST \
1861 CHAIN_QUALITY_SIGNATURE_VALID | CHAIN_QUALITY_TIME_VALID | \
1862 CHAIN_QUALITY_COMPLETE_CHAIN | CHAIN_QUALITY_BASIC_CONSTRAINTS | \
1863 CHAIN_QUALITY_TRUSTED_ROOT
1864
1865 #define IS_TRUST_ERROR_SET(TrustStatus, bits) \
1866 (TrustStatus)->dwErrorStatus & (bits)
1867
1868 static DWORD CRYPT_ChainQuality(const CertificateChain *chain)
1869 {
1870 DWORD quality = CHAIN_QUALITY_HIGHEST;
1871
1872 if (IS_TRUST_ERROR_SET(&chain->context.TrustStatus,
1873 CERT_TRUST_IS_UNTRUSTED_ROOT))
1874 quality &= ~CHAIN_QUALITY_TRUSTED_ROOT;
1875 if (IS_TRUST_ERROR_SET(&chain->context.TrustStatus,
1876 CERT_TRUST_INVALID_BASIC_CONSTRAINTS))
1877 quality &= ~CHAIN_QUALITY_BASIC_CONSTRAINTS;
1878 if (IS_TRUST_ERROR_SET(&chain->context.TrustStatus,
1879 CERT_TRUST_IS_PARTIAL_CHAIN))
1880 quality &= ~CHAIN_QUALITY_COMPLETE_CHAIN;
1881 if (IS_TRUST_ERROR_SET(&chain->context.TrustStatus,
1882 CERT_TRUST_IS_NOT_TIME_VALID | CERT_TRUST_IS_NOT_TIME_NESTED))
1883 quality &= ~CHAIN_QUALITY_TIME_VALID;
1884 if (IS_TRUST_ERROR_SET(&chain->context.TrustStatus,
1885 CERT_TRUST_IS_NOT_SIGNATURE_VALID))
1886 quality &= ~CHAIN_QUALITY_SIGNATURE_VALID;
1887 return quality;
1888 }
1889
1890 /* Chooses the highest quality chain among chain and its "lower quality"
1891 * alternate chains. Returns the highest quality chain, with all other
1892 * chains as lower quality chains of it.
1893 */
1894 static PCertificateChain CRYPT_ChooseHighestQualityChain(
1895 PCertificateChain chain)
1896 {
1897 DWORD i;
1898
1899 /* There are always only two chains being considered: chain, and an
1900 * alternate at chain->rgpLowerQualityChainContext[i]. If the alternate
1901 * has a higher quality than chain, the alternate gets assigned the lower
1902 * quality contexts, with chain taking the alternate's place among the
1903 * lower quality contexts.
1904 */
1905 for (i = 0; i < chain->context.cLowerQualityChainContext; i++)
1906 {
1907 PCertificateChain alternate =
1908 (PCertificateChain)chain->context.rgpLowerQualityChainContext[i];
1909
1910 if (CRYPT_ChainQuality(alternate) > CRYPT_ChainQuality(chain))
1911 {
1912 alternate->context.cLowerQualityChainContext =
1913 chain->context.cLowerQualityChainContext;
1914 alternate->context.rgpLowerQualityChainContext =
1915 chain->context.rgpLowerQualityChainContext;
1916 alternate->context.rgpLowerQualityChainContext[i] =
1917 (PCCERT_CHAIN_CONTEXT)chain;
1918 chain->context.cLowerQualityChainContext = 0;
1919 chain->context.rgpLowerQualityChainContext = NULL;
1920 chain = alternate;
1921 }
1922 }
1923 return chain;
1924 }
1925
1926 static BOOL CRYPT_AddAlternateChainToChain(PCertificateChain chain,
1927 const CertificateChain *alternate)
1928 {
1929 BOOL ret;
1930
1931 if (chain->context.cLowerQualityChainContext)
1932 chain->context.rgpLowerQualityChainContext =
1933 CryptMemRealloc(chain->context.rgpLowerQualityChainContext,
1934 (chain->context.cLowerQualityChainContext + 1) *
1935 sizeof(PCCERT_CHAIN_CONTEXT));
1936 else
1937 chain->context.rgpLowerQualityChainContext =
1938 CryptMemAlloc(sizeof(PCCERT_CHAIN_CONTEXT));
1939 if (chain->context.rgpLowerQualityChainContext)
1940 {
1941 chain->context.rgpLowerQualityChainContext[
1942 chain->context.cLowerQualityChainContext++] =
1943 (PCCERT_CHAIN_CONTEXT)alternate;
1944 ret = TRUE;
1945 }
1946 else
1947 ret = FALSE;
1948 return ret;
1949 }
1950
1951 static PCERT_CHAIN_ELEMENT CRYPT_FindIthElementInChain(
1952 const CERT_CHAIN_CONTEXT *chain, DWORD i)
1953 {
1954 DWORD j, iElement;
1955 PCERT_CHAIN_ELEMENT element = NULL;
1956
1957 for (j = 0, iElement = 0; !element && j < chain->cChain; j++)
1958 {
1959 if (iElement + chain->rgpChain[j]->cElement < i)
1960 iElement += chain->rgpChain[j]->cElement;
1961 else
1962 element = chain->rgpChain[j]->rgpElement[i - iElement];
1963 }
1964 return element;
1965 }
1966
1967 typedef struct _CERT_CHAIN_PARA_NO_EXTRA_FIELDS {
1968 DWORD cbSize;
1969 CERT_USAGE_MATCH RequestedUsage;
1970 } CERT_CHAIN_PARA_NO_EXTRA_FIELDS, *PCERT_CHAIN_PARA_NO_EXTRA_FIELDS;
1971
1972 static void CRYPT_VerifyChainRevocation(PCERT_CHAIN_CONTEXT chain,
1973 LPFILETIME pTime, const CERT_CHAIN_PARA *pChainPara, DWORD chainFlags)
1974 {
1975 DWORD cContext;
1976
1977 if (chainFlags & CERT_CHAIN_REVOCATION_CHECK_END_CERT)
1978 cContext = 1;
1979 else if ((chainFlags & CERT_CHAIN_REVOCATION_CHECK_CHAIN) ||
1980 (chainFlags & CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT))
1981 {
1982 DWORD i;
1983
1984 for (i = 0, cContext = 0; i < chain->cChain; i++)
1985 {
1986 if (i < chain->cChain - 1 ||
1987 chainFlags & CERT_CHAIN_REVOCATION_CHECK_CHAIN)
1988 cContext += chain->rgpChain[i]->cElement;
1989 else
1990 cContext += chain->rgpChain[i]->cElement - 1;
1991 }
1992 }
1993 else
1994 cContext = 0;
1995 if (cContext)
1996 {
1997 PCCERT_CONTEXT *contexts =
1998 CryptMemAlloc(cContext * sizeof(PCCERT_CONTEXT *));
1999
2000 if (contexts)
2001 {
2002 DWORD i, j, iContext, revocationFlags;
2003 CERT_REVOCATION_PARA revocationPara = { sizeof(revocationPara), 0 };
2004 CERT_REVOCATION_STATUS revocationStatus =
2005 { sizeof(revocationStatus), 0 };
2006 BOOL ret;
2007
2008 for (i = 0, iContext = 0; iContext < cContext && i < chain->cChain;
2009 i++)
2010 {
2011 for (j = 0; iContext < cContext &&
2012 j < chain->rgpChain[i]->cElement; j++)
2013 contexts[iContext++] =
2014 chain->rgpChain[i]->rgpElement[j]->pCertContext;
2015 }
2016 revocationFlags = CERT_VERIFY_REV_CHAIN_FLAG;
2017 if (chainFlags & CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY)
2018 revocationFlags |= CERT_VERIFY_CACHE_ONLY_BASED_REVOCATION;
2019 if (chainFlags & CERT_CHAIN_REVOCATION_ACCUMULATIVE_TIMEOUT)
2020 revocationFlags |= CERT_VERIFY_REV_ACCUMULATIVE_TIMEOUT_FLAG;
2021 revocationPara.pftTimeToUse = pTime;
2022 if (pChainPara->cbSize == sizeof(CERT_CHAIN_PARA))
2023 {
2024 revocationPara.dwUrlRetrievalTimeout =
2025 pChainPara->dwUrlRetrievalTimeout;
2026 revocationPara.fCheckFreshnessTime =
2027 pChainPara->fCheckRevocationFreshnessTime;
2028 revocationPara.dwFreshnessTime =
2029 pChainPara->dwRevocationFreshnessTime;
2030 }
2031 ret = CertVerifyRevocation(X509_ASN_ENCODING,
2032 CERT_CONTEXT_REVOCATION_TYPE, cContext, (void **)contexts,
2033 revocationFlags, &revocationPara, &revocationStatus);
2034 if (!ret)
2035 {
2036 PCERT_CHAIN_ELEMENT element =
2037 CRYPT_FindIthElementInChain(chain, revocationStatus.dwIndex);
2038 DWORD error;
2039
2040 switch (revocationStatus.dwError)
2041 {
2042 case CRYPT_E_NO_REVOCATION_CHECK:
2043 case CRYPT_E_NO_REVOCATION_DLL:
2044 case CRYPT_E_NOT_IN_REVOCATION_DATABASE:
2045 error = CERT_TRUST_REVOCATION_STATUS_UNKNOWN;
2046 break;
2047 case CRYPT_E_REVOCATION_OFFLINE:
2048 error = CERT_TRUST_IS_OFFLINE_REVOCATION;
2049 break;
2050 case CRYPT_E_REVOKED:
2051 error = CERT_TRUST_IS_REVOKED;
2052 break;
2053 default:
2054 WARN("unmapped error %08x\n", revocationStatus.dwError);
2055 error = 0;
2056 }
2057 if (element)
2058 {
2059 /* FIXME: set element's pRevocationInfo member */
2060 element->TrustStatus.dwErrorStatus |= error;
2061 }
2062 chain->TrustStatus.dwErrorStatus |= error;
2063 }
2064 CryptMemFree(contexts);
2065 }
2066 }
2067 }
2068
2069 static void dump_usage_match(LPCSTR name, const CERT_USAGE_MATCH *usageMatch)
2070 {
2071 DWORD i;
2072
2073 TRACE_(chain)("%s: %s\n", name,
2074 usageMatch->dwType == USAGE_MATCH_TYPE_AND ? "AND" : "OR");
2075 for (i = 0; i < usageMatch->Usage.cUsageIdentifier; i++)
2076 TRACE_(chain)("%s\n", usageMatch->Usage.rgpszUsageIdentifier[i]);
2077 }
2078
2079 static void dump_chain_para(const CERT_CHAIN_PARA *pChainPara)
2080 {
2081 TRACE_(chain)("%d\n", pChainPara->cbSize);
2082 if (pChainPara->cbSize >= sizeof(CERT_CHAIN_PARA_NO_EXTRA_FIELDS))
2083 dump_usage_match("RequestedUsage", &pChainPara->RequestedUsage);
2084 if (pChainPara->cbSize >= sizeof(CERT_CHAIN_PARA))
2085 {
2086 dump_usage_match("RequestedIssuancePolicy",
2087 &pChainPara->RequestedIssuancePolicy);
2088 TRACE_(chain)("%d\n", pChainPara->dwUrlRetrievalTimeout);
2089 TRACE_(chain)("%d\n", pChainPara->fCheckRevocationFreshnessTime);
2090 TRACE_(chain)("%d\n", pChainPara->dwRevocationFreshnessTime);
2091 }
2092 }
2093
2094 BOOL WINAPI CertGetCertificateChain(HCERTCHAINENGINE hChainEngine,
2095 PCCERT_CONTEXT pCertContext, LPFILETIME pTime, HCERTSTORE hAdditionalStore,
2096 PCERT_CHAIN_PARA pChainPara, DWORD dwFlags, LPVOID pvReserved,
2097 PCCERT_CHAIN_CONTEXT* ppChainContext)
2098 {
2099 BOOL ret;
2100 PCertificateChain chain = NULL;
2101
2102 TRACE("(%p, %p, %p, %p, %p, %08x, %p, %p)\n", hChainEngine, pCertContext,
2103 pTime, hAdditionalStore, pChainPara, dwFlags, pvReserved, ppChainContext);
2104
2105 if (ppChainContext)
2106 *ppChainContext = NULL;
2107 if (!pChainPara)
2108 {
2109 SetLastError(E_INVALIDARG);
2110 return FALSE;
2111 }
2112 if (!pCertContext->pCertInfo->SignatureAlgorithm.pszObjId)
2113 {
2114 SetLastError(ERROR_INVALID_DATA);
2115 return FALSE;
2116 }
2117
2118 if (!hChainEngine)
2119 hChainEngine = CRYPT_GetDefaultChainEngine();
2120 if (TRACE_ON(chain))
2121 dump_chain_para(pChainPara);
2122 /* FIXME: what about HCCE_LOCAL_MACHINE? */
2123 ret = CRYPT_BuildCandidateChainFromCert(hChainEngine, pCertContext, pTime,
2124 hAdditionalStore, &chain);
2125 if (ret)
2126 {
2127 PCertificateChain alternate = NULL;
2128 PCERT_CHAIN_CONTEXT pChain;
2129
2130 do {
2131 alternate = CRYPT_BuildAlternateContextFromChain(hChainEngine,
2132 pTime, hAdditionalStore, chain);
2133
2134 /* Alternate contexts are added as "lower quality" contexts of
2135 * chain, to avoid loops in alternate chain creation.
2136 * The highest-quality chain is chosen at the end.
2137 */
2138 if (alternate)
2139 ret = CRYPT_AddAlternateChainToChain(chain, alternate);
2140 } while (ret && alternate);
2141 chain = CRYPT_ChooseHighestQualityChain(chain);
2142 if (!(dwFlags & CERT_CHAIN_RETURN_LOWER_QUALITY_CONTEXTS))
2143 CRYPT_FreeLowerQualityChains(chain);
2144 pChain = (PCERT_CHAIN_CONTEXT)chain;
2145 CRYPT_VerifyChainRevocation(pChain, pTime, pChainPara, dwFlags);
2146 if (ppChainContext)
2147 *ppChainContext = pChain;
2148 else
2149 CertFreeCertificateChain(pChain);
2150 }
2151 TRACE("returning %d\n", ret);
2152 return ret;
2153 }
2154
2155 PCCERT_CHAIN_CONTEXT WINAPI CertDuplicateCertificateChain(
2156 PCCERT_CHAIN_CONTEXT pChainContext)
2157 {
2158 PCertificateChain chain = (PCertificateChain)pChainContext;
2159
2160 TRACE("(%p)\n", pChainContext);
2161
2162 if (chain)
2163 InterlockedIncrement(&chain->ref);
2164 return pChainContext;
2165 }
2166
2167 VOID WINAPI CertFreeCertificateChain(PCCERT_CHAIN_CONTEXT pChainContext)
2168 {
2169 PCertificateChain chain = (PCertificateChain)pChainContext;
2170
2171 TRACE("(%p)\n", pChainContext);
2172
2173 if (chain)
2174 {
2175 if (InterlockedDecrement(&chain->ref) == 0)
2176 CRYPT_FreeChainContext(chain);
2177 }
2178 }
2179
2180 static void find_element_with_error(PCCERT_CHAIN_CONTEXT chain, DWORD error,
2181 LONG *iChain, LONG *iElement)
2182 {
2183 DWORD i, j;
2184
2185 for (i = 0; i < chain->cChain; i++)
2186 for (j = 0; j < chain->rgpChain[i]->cElement; j++)
2187 if (chain->rgpChain[i]->rgpElement[j]->TrustStatus.dwErrorStatus &
2188 error)
2189 {
2190 *iChain = i;
2191 *iElement = j;
2192 return;
2193 }
2194 }
2195
2196 static BOOL WINAPI verify_base_policy(LPCSTR szPolicyOID,
2197 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
2198 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
2199 {
2200 pPolicyStatus->lChainIndex = pPolicyStatus->lElementIndex = -1;
2201 if (pChainContext->TrustStatus.dwErrorStatus &
2202 CERT_TRUST_IS_NOT_SIGNATURE_VALID)
2203 {
2204 pPolicyStatus->dwError = TRUST_E_CERT_SIGNATURE;
2205 find_element_with_error(pChainContext,
2206 CERT_TRUST_IS_NOT_SIGNATURE_VALID, &pPolicyStatus->lChainIndex,
2207 &pPolicyStatus->lElementIndex);
2208 }
2209 else if (pChainContext->TrustStatus.dwErrorStatus &
2210 CERT_TRUST_IS_UNTRUSTED_ROOT)
2211 {
2212 pPolicyStatus->dwError = CERT_E_UNTRUSTEDROOT;
2213 find_element_with_error(pChainContext,
2214 CERT_TRUST_IS_UNTRUSTED_ROOT, &pPolicyStatus->lChainIndex,
2215 &pPolicyStatus->lElementIndex);
2216 }
2217 else if (pChainContext->TrustStatus.dwErrorStatus & CERT_TRUST_IS_CYCLIC)
2218 {
2219 pPolicyStatus->dwError = CERT_E_CHAINING;
2220 find_element_with_error(pChainContext, CERT_TRUST_IS_CYCLIC,
2221 &pPolicyStatus->lChainIndex, &pPolicyStatus->lElementIndex);
2222 /* For a cyclic chain, which element is a cycle isn't meaningful */
2223 pPolicyStatus->lElementIndex = -1;
2224 }
2225 else
2226 pPolicyStatus->dwError = NO_ERROR;
2227 return TRUE;
2228 }
2229
2230 static BYTE msTestPubKey1[] = {
2231 0x30,0x47,0x02,0x40,0x81,0x55,0x22,0xb9,0x8a,0xa4,0x6f,0xed,0xd6,0xe7,0xd9,
2232 0x66,0x0f,0x55,0xbc,0xd7,0xcd,0xd5,0xbc,0x4e,0x40,0x02,0x21,0xa2,0xb1,0xf7,
2233 0x87,0x30,0x85,0x5e,0xd2,0xf2,0x44,0xb9,0xdc,0x9b,0x75,0xb6,0xfb,0x46,0x5f,
2234 0x42,0xb6,0x9d,0x23,0x36,0x0b,0xde,0x54,0x0f,0xcd,0xbd,0x1f,0x99,0x2a,0x10,
2235 0x58,0x11,0xcb,0x40,0xcb,0xb5,0xa7,0x41,0x02,0x03,0x01,0x00,0x01 };
2236 static BYTE msTestPubKey2[] = {
2237 0x30,0x47,0x02,0x40,0x9c,0x50,0x05,0x1d,0xe2,0x0e,0x4c,0x53,0xd8,0xd9,0xb5,
2238 0xe5,0xfd,0xe9,0xe3,0xad,0x83,0x4b,0x80,0x08,0xd9,0xdc,0xe8,0xe8,0x35,0xf8,
2239 0x11,0xf1,0xe9,0x9b,0x03,0x7a,0x65,0x64,0x76,0x35,0xce,0x38,0x2c,0xf2,0xb6,
2240 0x71,0x9e,0x06,0xd9,0xbf,0xbb,0x31,0x69,0xa3,0xf6,0x30,0xa0,0x78,0x7b,0x18,
2241 0xdd,0x50,0x4d,0x79,0x1e,0xeb,0x61,0xc1,0x02,0x03,0x01,0x00,0x01 };
2242
2243 static BOOL WINAPI verify_authenticode_policy(LPCSTR szPolicyOID,
2244 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
2245 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
2246 {
2247 BOOL ret = verify_base_policy(szPolicyOID, pChainContext, pPolicyPara,
2248 pPolicyStatus);
2249
2250 if (ret && pPolicyStatus->dwError == CERT_E_UNTRUSTEDROOT)
2251 {
2252 CERT_PUBLIC_KEY_INFO msPubKey = { { 0 } };
2253 BOOL isMSTestRoot = FALSE;
2254 PCCERT_CONTEXT failingCert =
2255 pChainContext->rgpChain[pPolicyStatus->lChainIndex]->
2256 rgpElement[pPolicyStatus->lElementIndex]->pCertContext;
2257 DWORD i;
2258 CRYPT_DATA_BLOB keyBlobs[] = {
2259 { sizeof(msTestPubKey1), msTestPubKey1 },
2260 { sizeof(msTestPubKey2), msTestPubKey2 },
2261 };
2262
2263 /* Check whether the root is an MS test root */
2264 for (i = 0; !isMSTestRoot && i < sizeof(keyBlobs) / sizeof(keyBlobs[0]);
2265 i++)
2266 {
2267 msPubKey.PublicKey.cbData = keyBlobs[i].cbData;
2268 msPubKey.PublicKey.pbData = keyBlobs[i].pbData;
2269 if (CertComparePublicKeyInfo(
2270 X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
2271 &failingCert->pCertInfo->SubjectPublicKeyInfo, &msPubKey))
2272 isMSTestRoot = TRUE;
2273 }
2274 if (isMSTestRoot)
2275 pPolicyStatus->dwError = CERT_E_UNTRUSTEDTESTROOT;
2276 }
2277 return ret;
2278 }
2279
2280 static BOOL WINAPI verify_basic_constraints_policy(LPCSTR szPolicyOID,
2281 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
2282 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
2283 {
2284 pPolicyStatus->lChainIndex = pPolicyStatus->lElementIndex = -1;
2285 if (pChainContext->TrustStatus.dwErrorStatus &
2286 CERT_TRUST_INVALID_BASIC_CONSTRAINTS)
2287 {
2288 pPolicyStatus->dwError = TRUST_E_BASIC_CONSTRAINTS;
2289 find_element_with_error(pChainContext,
2290 CERT_TRUST_INVALID_BASIC_CONSTRAINTS, &pPolicyStatus->lChainIndex,
2291 &pPolicyStatus->lElementIndex);
2292 }
2293 else
2294 pPolicyStatus->dwError = NO_ERROR;
2295 return TRUE;
2296 }
2297
2298 static inline PCERT_EXTENSION get_subject_alt_name_ext(PCCERT_CONTEXT cert)
2299 {
2300 PCERT_EXTENSION ext;
2301
2302 ext = CertFindExtension(szOID_SUBJECT_ALT_NAME2,
2303 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
2304 if (!ext)
2305 ext = CertFindExtension(szOID_SUBJECT_ALT_NAME,
2306 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
2307 return ext;
2308 }
2309
2310 static BOOL match_dns_to_subject_alt_name(PCERT_EXTENSION ext,
2311 LPCWSTR server_name)
2312 {
2313 BOOL matches = FALSE;
2314 CERT_ALT_NAME_INFO *subjectName;
2315 DWORD size;
2316
2317 TRACE_(chain)("%s\n", debugstr_w(server_name));
2318 /* FIXME: This can be spoofed by the embedded NULL vulnerability. The
2319 * returned CERT_ALT_NAME_INFO doesn't have a way to indicate the
2320 * encoded length of a name, so a certificate issued to
2321 * winehq.org\0badsite.com will get treated as having been issued to
2322 * winehq.org.
2323 */
2324 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_ALTERNATE_NAME,
2325 ext->Value.pbData, ext->Value.cbData,
2326 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
2327 &subjectName, &size))
2328 {
2329 DWORD i;
2330 BOOL found = FALSE;
2331
2332 for (i = 0; !found && i < subjectName->cAltEntry; i++)
2333 {
2334 if (subjectName->rgAltEntry[i].dwAltNameChoice ==
2335 CERT_ALT_NAME_DNS_NAME)
2336 {
2337 TRACE_(chain)("dNSName: %s\n", debugstr_w(
2338 subjectName->rgAltEntry[i].u.pwszDNSName));
2339 found = TRUE;
2340 if (!strcmpiW(server_name,
2341 subjectName->rgAltEntry[i].u.pwszDNSName))
2342 matches = TRUE;
2343 }
2344 }
2345 LocalFree(subjectName);
2346 }
2347 return matches;
2348 }
2349
2350 static BOOL find_matching_domain_component(CERT_NAME_INFO *name,
2351 LPCWSTR component)
2352 {
2353 BOOL matches = FALSE;
2354 DWORD i, j;
2355
2356 for (i = 0; !matches && i < name->cRDN; i++)
2357 for (j = 0; j < name->rgRDN[i].cRDNAttr; j++)
2358 if (!strcmp(szOID_DOMAIN_COMPONENT,
2359 name->rgRDN[i].rgRDNAttr[j].pszObjId))
2360 {
2361 PCERT_RDN_ATTR attr;
2362
2363 attr = &name->rgRDN[i].rgRDNAttr[j];
2364 /* Compare with memicmpW rather than strcmpiW in order to avoid
2365 * a match with a string with an embedded NULL. The component
2366 * must match one domain component attribute's entire string
2367 * value with a case-insensitive match.
2368 */
2369 matches = !memicmpW(component, (LPWSTR)attr->Value.pbData,
2370 attr->Value.cbData / sizeof(WCHAR));
2371 }
2372 return matches;
2373 }
2374
2375 static BOOL match_dns_to_subject_dn(PCCERT_CONTEXT cert, LPCWSTR server_name)
2376 {
2377 BOOL matches = FALSE;
2378 CERT_NAME_INFO *name;
2379 DWORD size;
2380
2381 TRACE_(chain)("%s\n", debugstr_w(server_name));
2382 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_UNICODE_NAME,
2383 cert->pCertInfo->Subject.pbData, cert->pCertInfo->Subject.cbData,
2384 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
2385 &name, &size))
2386 {
2387 /* If the subject distinguished name contains any name components,
2388 * make sure all of them are present.
2389 */
2390 if (CertFindRDNAttr(szOID_DOMAIN_COMPONENT, name))
2391 {
2392 LPCWSTR ptr = server_name;
2393
2394 matches = TRUE;
2395 do {
2396 LPCWSTR dot = strchrW(ptr, '.'), end;
2397 /* 254 is the maximum DNS label length, see RFC 1035 */
2398 WCHAR component[255];
2399 DWORD len;
2400
2401 end = dot ? dot : ptr + strlenW(ptr);
2402 len = end - ptr;
2403 if (len >= sizeof(component) / sizeof(component[0]))
2404 {
2405 WARN_(chain)("domain component %s too long\n",
2406 debugstr_wn(ptr, len));
2407 matches = FALSE;
2408 }
2409 else
2410 {
2411 memcpy(component, ptr, len * sizeof(WCHAR));
2412 component[len] = 0;
2413 matches = find_matching_domain_component(name, component);
2414 }
2415 ptr = dot ? dot + 1 : end;
2416 } while (matches && ptr && *ptr);
2417 }
2418 else
2419 {
2420 PCERT_RDN_ATTR attr;
2421
2422 /* If the certificate isn't using a DN attribute in the name, make
2423 * make sure the common name matches. Again, use memicmpW rather
2424 * than strcmpiW in order to avoid being fooled by an embedded NULL.
2425 */
2426 if ((attr = CertFindRDNAttr(szOID_COMMON_NAME, name)))
2427 {
2428 TRACE_(chain)("CN = %s\n", debugstr_w(
2429 (LPWSTR)attr->Value.pbData));
2430 matches = !memicmpW(server_name, (LPWSTR)attr->Value.pbData,
2431 attr->Value.cbData / sizeof(WCHAR));
2432 }
2433 }
2434 LocalFree(name);
2435 }
2436 return matches;
2437 }
2438
2439 static BOOL WINAPI verify_ssl_policy(LPCSTR szPolicyOID,
2440 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
2441 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
2442 {
2443 pPolicyStatus->lChainIndex = pPolicyStatus->lElementIndex = -1;
2444 if (pChainContext->TrustStatus.dwErrorStatus &
2445 CERT_TRUST_IS_NOT_SIGNATURE_VALID)
2446 {
2447 pPolicyStatus->dwError = TRUST_E_CERT_SIGNATURE;
2448 find_element_with_error(pChainContext,
2449 CERT_TRUST_IS_NOT_SIGNATURE_VALID, &pPolicyStatus->lChainIndex,
2450 &pPolicyStatus->lElementIndex);
2451 }
2452 else if (pChainContext->TrustStatus.dwErrorStatus &
2453 CERT_TRUST_IS_UNTRUSTED_ROOT)
2454 {
2455 pPolicyStatus->dwError = CERT_E_UNTRUSTEDROOT;
2456 find_element_with_error(pChainContext,
2457 CERT_TRUST_IS_UNTRUSTED_ROOT, &pPolicyStatus->lChainIndex,
2458 &pPolicyStatus->lElementIndex);
2459 }
2460 else if (pChainContext->TrustStatus.dwErrorStatus & CERT_TRUST_IS_CYCLIC)
2461 {
2462 pPolicyStatus->dwError = CERT_E_UNTRUSTEDROOT;
2463 find_element_with_error(pChainContext,
2464 CERT_TRUST_IS_CYCLIC, &pPolicyStatus->lChainIndex,
2465 &pPolicyStatus->lElementIndex);
2466 /* For a cyclic chain, which element is a cycle isn't meaningful */
2467 pPolicyStatus->lElementIndex = -1;
2468 }
2469 else if (pChainContext->TrustStatus.dwErrorStatus &
2470 CERT_TRUST_IS_NOT_TIME_VALID)
2471 {
2472 pPolicyStatus->dwError = CERT_E_EXPIRED;
2473 find_element_with_error(pChainContext,
2474 CERT_TRUST_IS_NOT_TIME_VALID, &pPolicyStatus->lChainIndex,
2475 &pPolicyStatus->lElementIndex);
2476 }
2477 else
2478 pPolicyStatus->dwError = NO_ERROR;
2479 /* We only need bother checking whether the name in the end certificate
2480 * matches if the chain is otherwise okay.
2481 */
2482 if (!pPolicyStatus->dwError && pPolicyPara &&
2483 pPolicyPara->cbSize >= sizeof(CERT_CHAIN_POLICY_PARA))
2484 {
2485 HTTPSPolicyCallbackData *sslPara = pPolicyPara->pvExtraPolicyPara;
2486
2487 if (sslPara && sslPara->u.cbSize >= sizeof(HTTPSPolicyCallbackData))
2488 {
2489 if (sslPara->dwAuthType == AUTHTYPE_SERVER &&
2490 sslPara->pwszServerName)
2491 {
2492 PCCERT_CONTEXT cert;
2493 PCERT_EXTENSION altNameExt;
2494 BOOL matches;
2495
2496 cert = pChainContext->rgpChain[0]->rgpElement[0]->pCertContext;
2497 altNameExt = get_subject_alt_name_ext(cert);
2498 /* If the alternate name extension exists, the name it contains
2499 * is bound to the certificate, so make sure the name matches
2500 * it. Otherwise, look for the server name in the subject
2501 * distinguished name. RFC5280, section 4.2.1.6:
2502 * "Whenever such identities are to be bound into a
2503 * certificate, the subject alternative name (or issuer
2504 * alternative name) extension MUST be used; however, a DNS
2505 * name MAY also be represented in the subject field using the
2506 * domainComponent attribute."
2507 */
2508 if (altNameExt)
2509 matches = match_dns_to_subject_alt_name(altNameExt,
2510 sslPara->pwszServerName);
2511 else
2512 matches = match_dns_to_subject_dn(cert,
2513 sslPara->pwszServerName);
2514 if (!matches)
2515 {
2516 pPolicyStatus->dwError = CERT_E_CN_NO_MATCH;
2517 pPolicyStatus->lChainIndex = 0;
2518 pPolicyStatus->lElementIndex = 0;
2519 }
2520 }
2521 }
2522 }
2523 return TRUE;
2524 }
2525
2526 static BYTE msPubKey1[] = {
2527 0x30,0x82,0x01,0x0a,0x02,0x82,0x01,0x01,0x00,0xdf,0x08,0xba,0xe3,0x3f,0x6e,
2528 0x64,0x9b,0xf5,0x89,0xaf,0x28,0x96,0x4a,0x07,0x8f,0x1b,0x2e,0x8b,0x3e,0x1d,
2529 0xfc,0xb8,0x80,0x69,0xa3,0xa1,0xce,0xdb,0xdf,0xb0,0x8e,0x6c,0x89,0x76,0x29,
2530 0x4f,0xca,0x60,0x35,0x39,0xad,0x72,0x32,0xe0,0x0b,0xae,0x29,0x3d,0x4c,0x16,
2531 0xd9,0x4b,0x3c,0x9d,0xda,0xc5,0xd3,0xd1,0x09,0xc9,0x2c,0x6f,0xa6,0xc2,0x60,
2532 0x53,0x45,0xdd,0x4b,0xd1,0x55,0xcd,0x03,0x1c,0xd2,0x59,0x56,0x24,0xf3,0xe5,
2533 0x78,0xd8,0x07,0xcc,0xd8,0xb3,0x1f,0x90,0x3f,0xc0,0x1a,0x71,0x50,0x1d,0x2d,
2534 0xa7,0x12,0x08,0x6d,0x7c,0xb0,0x86,0x6c,0xc7,0xba,0x85,0x32,0x07,0xe1,0x61,
2535 0x6f,0xaf,0x03,0xc5,0x6d,0xe5,0xd6,0xa1,0x8f,0x36,0xf6,0xc1,0x0b,0xd1,0x3e,
2536 0x69,0x97,0x48,0x72,0xc9,0x7f,0xa4,0xc8,0xc2,0x4a,0x4c,0x7e,0xa1,0xd1,0x94,
2537 0xa6,0xd7,0xdc,0xeb,0x05,0x46,0x2e,0xb8,0x18,0xb4,0x57,0x1d,0x86,0x49,0xdb,
2538 0x69,0x4a,0x2c,0x21,0xf5,0x5e,0x0f,0x54,0x2d,0x5a,0x43,0xa9,0x7a,0x7e,0x6a,
2539 0x8e,0x50,0x4d,0x25,0x57,0xa1,0xbf,0x1b,0x15,0x05,0x43,0x7b,0x2c,0x05,0x8d,
2540 0xbd,0x3d,0x03,0x8c,0x93,0x22,0x7d,0x63,0xea,0x0a,0x57,0x05,0x06,0x0a,0xdb,
2541 0x61,0x98,0x65,0x2d,0x47,0x49,0xa8,0xe7,0xe6,0x56,0x75,0x5c,0xb8,0x64,0x08,
2542 0x63,0xa9,0x30,0x40,0x66,0xb2,0xf9,0xb6,0xe3,0x34,0xe8,0x67,0x30,0xe1,0x43,
2543 0x0b,0x87,0xff,0xc9,0xbe,0x72,0x10,0x5e,0x23,0xf0,0x9b,0xa7,0x48,0x65,0xbf,
2544 0x09,0x88,0x7b,0xcd,0x72,0xbc,0x2e,0x79,0x9b,0x7b,0x02,0x03,0x01,0x00,0x01 };
2545 static BYTE msPubKey2[] = {
2546 0x30,0x82,0x01,0x0a,0x02,0x82,0x01,0x01,0x00,0xa9,0x02,0xbd,0xc1,0x70,0xe6,
2547 0x3b,0xf2,0x4e,0x1b,0x28,0x9f,0x97,0x78,0x5e,0x30,0xea,0xa2,0xa9,0x8d,0x25,
2548 0x5f,0xf8,0xfe,0x95,0x4c,0xa3,0xb7,0xfe,0x9d,0xa2,0x20,0x3e,0x7c,0x51,0xa2,
2549 0x9b,0xa2,0x8f,0x60,0x32,0x6b,0xd1,0x42,0x64,0x79,0xee,0xac,0x76,0xc9,0x54,
2550 0xda,0xf2,0xeb,0x9c,0x86,0x1c,0x8f,0x9f,0x84,0x66,0xb3,0xc5,0x6b,0x7a,0x62,
2551 0x23,0xd6,0x1d,0x3c,0xde,0x0f,0x01,0x92,0xe8,0x96,0xc4,0xbf,0x2d,0x66,0x9a,
2552 0x9a,0x68,0x26,0x99,0xd0,0x3a,0x2c,0xbf,0x0c,0xb5,0x58,0x26,0xc1,0x46,0xe7,
2553 0x0a,0x3e,0x38,0x96,0x2c,0xa9,0x28,0x39,0xa8,0xec,0x49,0x83,0x42,0xe3,0x84,
2554 0x0f,0xbb,0x9a,0x6c,0x55,0x61,0xac,0x82,0x7c,0xa1,0x60,0x2d,0x77,0x4c,0xe9,
2555 0x99,0xb4,0x64,0x3b,0x9a,0x50,0x1c,0x31,0x08,0x24,0x14,0x9f,0xa9,0xe7,0x91,
2556 0x2b,0x18,0xe6,0x3d,0x98,0x63,0x14,0x60,0x58,0x05,0x65,0x9f,0x1d,0x37,0x52,
2557 0x87,0xf7,0xa7,0xef,0x94,0x02,0xc6,0x1b,0xd3,0xbf,0x55,0x45,0xb3,0x89,0x80,
2558 0xbf,0x3a,0xec,0x54,0x94,0x4e,0xae,0xfd,0xa7,0x7a,0x6d,0x74,0x4e,0xaf,0x18,
2559 0xcc,0x96,0x09,0x28,0x21,0x00,0x57,0x90,0x60,0x69,0x37,0xbb,0x4b,0x12,0x07,
2560 0x3c,0x56,0xff,0x5b,0xfb,0xa4,0x66,0x0a,0x08,0xa6,0xd2,0x81,0x56,0x57,0xef,
2561 0xb6,0x3b,0x5e,0x16,0x81,0x77,0x04,0xda,0xf6,0xbe,0xae,0x80,0x95,0xfe,0xb0,
2562 0xcd,0x7f,0xd6,0xa7,0x1a,0x72,0x5c,0x3c,0xca,0xbc,0xf0,0x08,0xa3,0x22,0x30,
2563 0xb3,0x06,0x85,0xc9,0xb3,0x20,0x77,0x13,0x85,0xdf,0x02,0x03,0x01,0x00,0x01 };
2564 static BYTE msPubKey3[] = {
2565 0x30,0x82,0x02,0x0a,0x02,0x82,0x02,0x01,0x00,0xf3,0x5d,0xfa,0x80,0x67,0xd4,
2566 0x5a,0xa7,0xa9,0x0c,0x2c,0x90,0x20,0xd0,0x35,0x08,0x3c,0x75,0x84,0xcd,0xb7,
2567 0x07,0x89,0x9c,0x89,0xda,0xde,0xce,0xc3,0x60,0xfa,0x91,0x68,0x5a,0x9e,0x94,
2568 0x71,0x29,0x18,0x76,0x7c,0xc2,0xe0,0xc8,0x25,0x76,0x94,0x0e,0x58,0xfa,0x04,
2569 0x34,0x36,0xe6,0xdf,0xaf,0xf7,0x80,0xba,0xe9,0x58,0x0b,0x2b,0x93,0xe5,0x9d,
2570 0x05,0xe3,0x77,0x22,0x91,0xf7,0x34,0x64,0x3c,0x22,0x91,0x1d,0x5e,0xe1,0x09,
2571 0x90,0xbc,0x14,0xfe,0xfc,0x75,0x58,0x19,0xe1,0x79,0xb7,0x07,0x92,0xa3,0xae,
2572 0x88,0x59,0x08,0xd8,0x9f,0x07,0xca,0x03,0x58,0xfc,0x68,0x29,0x6d,0x32,0xd7,
2573 0xd2,0xa8,0xcb,0x4b,0xfc,0xe1,0x0b,0x48,0x32,0x4f,0xe6,0xeb,0xb8,0xad,0x4f,
2574 0xe4,0x5c,0x6f,0x13,0x94,0x99,0xdb,0x95,0xd5,0x75,0xdb,0xa8,0x1a,0xb7,0x94,
2575 0x91,0xb4,0x77,0x5b,0xf5,0x48,0x0c,0x8f,0x6a,0x79,0x7d,0x14,0x70,0x04,0x7d,
2576 0x6d,0xaf,0x90,0xf5,0xda,0x70,0xd8,0x47,0xb7,0xbf,0x9b,0x2f,0x6c,0xe7,0x05,
2577 0xb7,0xe1,0x11,0x60,0xac,0x79,0x91,0x14,0x7c,0xc5,0xd6,0xa6,0xe4,0xe1,0x7e,
2578 0xd5,0xc3,0x7e,0xe5,0x92,0xd2,0x3c,0x00,0xb5,0x36,0x82,0xde,0x79,0xe1,0x6d,
2579 0xf3,0xb5,0x6e,0xf8,0x9f,0x33,0xc9,0xcb,0x52,0x7d,0x73,0x98,0x36,0xdb,0x8b,
2580 0xa1,0x6b,0xa2,0x95,0x97,0x9b,0xa3,0xde,0xc2,0x4d,0x26,0xff,0x06,0x96,0x67,
2581 0x25,0x06,0xc8,0xe7,0xac,0xe4,0xee,0x12,0x33,0x95,0x31,0x99,0xc8,0x35,0x08,
2582 0x4e,0x34,0xca,0x79,0x53,0xd5,0xb5,0xbe,0x63,0x32,0x59,0x40,0x36,0xc0,0xa5,
2583 0x4e,0x04,0x4d,0x3d,0xdb,0x5b,0x07,0x33,0xe4,0x58,0xbf,0xef,0x3f,0x53,0x64,
2584 0xd8,0x42,0x59,0x35,0x57,0xfd,0x0f,0x45,0x7c,0x24,0x04,0x4d,0x9e,0xd6,0x38,
2585 0x74,0x11,0x97,0x22,0x90,0xce,0x68,0x44,0x74,0x92,0x6f,0xd5,0x4b,0x6f,0xb0,
2586 0x86,0xe3,0xc7,0x36,0x42,0xa0,0xd0,0xfc,0xc1,0xc0,0x5a,0xf9,0xa3,0x61,0xb9,
2587 0x30,0x47,0x71,0x96,0x0a,0x16,0xb0,0x91,0xc0,0x42,0x95,0xef,0x10,0x7f,0x28,
2588 0x6a,0xe3,0x2a,0x1f,0xb1,0xe4,0xcd,0x03,0x3f,0x77,0x71,0x04,0xc7,0x20,0xfc,
2589 0x49,0x0f,0x1d,0x45,0x88,0xa4,0xd7,0xcb,0x7e,0x88,0xad,0x8e,0x2d,0xec,0x45,
2590 0xdb,0xc4,0x51,0x04,0xc9,0x2a,0xfc,0xec,0x86,0x9e,0x9a,0x11,0x97,0x5b,0xde,
2591 0xce,0x53,0x88,0xe6,0xe2,0xb7,0xfd,0xac,0x95,0xc2,0x28,0x40,0xdb,0xef,0x04,
2592 0x90,0xdf,0x81,0x33,0x39,0xd9,0xb2,0x45,0xa5,0x23,0x87,0x06,0xa5,0x55,0x89,
2593 0x31,0xbb,0x06,0x2d,0x60,0x0e,0x41,0x18,0x7d,0x1f,0x2e,0xb5,0x97,0xcb,0x11,
2594 0xeb,0x15,0xd5,0x24,0xa5,0x94,0xef,0x15,0x14,0x89,0xfd,0x4b,0x73,0xfa,0x32,
2595 0x5b,0xfc,0xd1,0x33,0x00,0xf9,0x59,0x62,0x70,0x07,0x32,0xea,0x2e,0xab,0x40,
2596 0x2d,0x7b,0xca,0xdd,0x21,0x67,0x1b,0x30,0x99,0x8f,0x16,0xaa,0x23,0xa8,0x41,
2597 0xd1,0xb0,0x6e,0x11,0x9b,0x36,0xc4,0xde,0x40,0x74,0x9c,0xe1,0x58,0x65,0xc1,
2598 0x60,0x1e,0x7a,0x5b,0x38,0xc8,0x8f,0xbb,0x04,0x26,0x7c,0xd4,0x16,0x40,0xe5,
2599 0xb6,0x6b,0x6c,0xaa,0x86,0xfd,0x00,0xbf,0xce,0xc1,0x35,0x02,0x03,0x01,0x00,
2600 0x01 };
2601
2602 static BOOL WINAPI verify_ms_root_policy(LPCSTR szPolicyOID,
2603 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
2604 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
2605 {
2606 BOOL ret = verify_base_policy(szPolicyOID, pChainContext, pPolicyPara,
2607 pPolicyStatus);
2608
2609 if (ret && !pPolicyStatus->dwError)
2610 {
2611 CERT_PUBLIC_KEY_INFO msPubKey = { { 0 } };
2612 BOOL isMSRoot = FALSE;
2613 DWORD i;
2614 CRYPT_DATA_BLOB keyBlobs[] = {
2615 { sizeof(msPubKey1), msPubKey1 },
2616 { sizeof(msPubKey2), msPubKey2 },
2617 { sizeof(msPubKey3), msPubKey3 },
2618 };
2619 PCERT_SIMPLE_CHAIN rootChain =
2620 pChainContext->rgpChain[pChainContext->cChain -1 ];
2621 PCCERT_CONTEXT root =
2622 rootChain->rgpElement[rootChain->cElement - 1]->pCertContext;
2623
2624 for (i = 0; !isMSRoot && i < sizeof(keyBlobs) / sizeof(keyBlobs[0]);
2625 i++)
2626 {
2627 msPubKey.PublicKey.cbData = keyBlobs[i].cbData;
2628 msPubKey.PublicKey.pbData = keyBlobs[i].pbData;
2629 if (CertComparePublicKeyInfo(
2630 X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
2631 &root->pCertInfo->SubjectPublicKeyInfo, &msPubKey))
2632 isMSRoot = TRUE;
2633 }
2634 if (isMSRoot)
2635 pPolicyStatus->lChainIndex = pPolicyStatus->lElementIndex = 0;
2636 }
2637 return ret;
2638 }
2639
2640 typedef BOOL (WINAPI *CertVerifyCertificateChainPolicyFunc)(LPCSTR szPolicyOID,
2641 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
2642 PCERT_CHAIN_POLICY_STATUS pPolicyStatus);
2643
2644 BOOL WINAPI CertVerifyCertificateChainPolicy(LPCSTR szPolicyOID,
2645 PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara,
2646 PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
2647 {
2648 static HCRYPTOIDFUNCSET set = NULL;
2649 BOOL ret = FALSE;
2650 CertVerifyCertificateChainPolicyFunc verifyPolicy = NULL;
2651 HCRYPTOIDFUNCADDR hFunc = NULL;
2652
2653 TRACE("(%s, %p, %p, %p)\n", debugstr_a(szPolicyOID), pChainContext,
2654 pPolicyPara, pPolicyStatus);
2655
2656 if (!HIWORD(szPolicyOID))
2657 {
2658 switch (LOWORD(szPolicyOID))
2659 {
2660 case LOWORD(CERT_CHAIN_POLICY_BASE):
2661 verifyPolicy = verify_base_policy;
2662 break;
2663 case LOWORD(CERT_CHAIN_POLICY_AUTHENTICODE):
2664 verifyPolicy = verify_authenticode_policy;
2665 break;
2666 case LOWORD(CERT_CHAIN_POLICY_SSL):
2667 verifyPolicy = verify_ssl_policy;
2668 break;
2669 case LOWORD(CERT_CHAIN_POLICY_BASIC_CONSTRAINTS):
2670 verifyPolicy = verify_basic_constraints_policy;
2671 break;
2672 case LOWORD(CERT_CHAIN_POLICY_MICROSOFT_ROOT):
2673 verifyPolicy = verify_ms_root_policy;
2674 break;
2675 default:
2676 FIXME("unimplemented for %d\n", LOWORD(szPolicyOID));
2677 }
2678 }
2679 if (!verifyPolicy)
2680 {
2681 if (!set)
2682 set = CryptInitOIDFunctionSet(
2683 CRYPT_OID_VERIFY_CERTIFICATE_CHAIN_POLICY_FUNC, 0);
2684 CryptGetOIDFunctionAddress(set, X509_ASN_ENCODING, szPolicyOID, 0,
2685 (void **)&verifyPolicy, &hFunc);
2686 }
2687 if (verifyPolicy)
2688 ret = verifyPolicy(szPolicyOID, pChainContext, pPolicyPara,
2689 pPolicyStatus);
2690 if (hFunc)
2691 CryptFreeOIDFunctionAddress(hFunc, 0);
2692 TRACE("returning %d (%08x)\n", ret, pPolicyStatus->dwError);
2693 return ret;
2694 }
Maarten's multimedia branch