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