RFC 5937

Using Trust Anchor Constraints during Certification Path Processing

📅 published August 2010, from ietf

RFC 5937 🎀 Using Trust Anchor Constraints during Certification Path Processing

Okay bestie, this one is RFC 5937, titled Using Trust Anchor Constraints during Certification Path Processing 💅 It came from the IETF (Internet Engineering Task Force) as a Request for Comments in August 2010. Its category is Informational, so it's published for information and isn't an Internet Standards Track spec ✨ The authors are S. Ashmore from the National Security Agency and C. Wallace from Cygnacom Solutions 🦋 The ISSN is 2070-1721. It doesn't say what it obsoletes or updates, so I'm not going to make anything up 🙈

Abstract ✨

Okay so this doc is about using the info attached to a trust anchor public key when you validate certification paths 🔥 That info can put constraints on how the trust anchor gets used. Usually the constraints limit which certificate policies and names can show up in the paths validated with that trust anchor 💜

Status of This Memo 🌸

Quick vibe check: this is not an Internet Standards Track specification. It's published just for informational purposes 🧚

It's a product of the IETF, so it represents the consensus of the IETF community. It got public review and was approved for publication by the Internet Engineering Steering Group (IESG) ✨ Not every IESG-approved document is a candidate for any level of Internet Standard, so check out Section 2 of RFC 5741 if you want the details 🫶

For the current status, errata, and how to send feedback, go to http://www.rfc-editor.org/info/rfc5937 💖

Copyright Notice 🌈

This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info), as in effect on the date this document was published. Please read those carefully, because they describe your rights and restrictions for this document 👑 Code Components pulled out of this document must include Simplified BSD License text, as described in Section 4.e of the Trust Legal Provisions, and they come without warranty, as the Simplified BSD License describes 🔥

This document may contain material from IETF Documents or IETF Contributions published or made publicly available before November 10, 2008 🙈 The people controlling the copyright in some of that material may not have given the IETF Trust permission to allow modifications outside the IETF Standards Process. Unless you get a proper license from whoever controls that copyright, this document may not be modified outside the IETF Standards Process, and derivative works of it may not be created outside the IETF Standards Process. The exceptions are formatting it for publication as an RFC or translating it into languages other than English 💀

Table of Contents 🍓

   1. Introduction ....................................................3
      1.1. Terminology ................................................3
   2. Identifying Trust Anchor Constraints ............................3
   3. Using Trust Anchor Constraints during Certification Path
      Processing ......................................................4
      3.1. Inputs .....................................................4
      3.2. Initialization .............................................4
      3.3. Basic Certificate Processing ...............................6
      3.4. Preparation for Certificate i+1 ............................6
      3.5. Wrap-Up Procedure ..........................................6
   4. Relationship to RFC 5280 ........................................6
   5. Security Considerations .........................................7
   6. References ......................................................7
      6.1. Normative References .......................................7
      6.2. Informative References .....................................7

1. Introduction ✨

Okay so trust anchors get used a lot to verify digital signatures and validate certification paths [RFC5280] [X.509] 💖 They are required when you validate certification paths. The Trust Anchor Format (TAF) spec [RFC5914] defines a way to limit the scope where a trust anchor can be used 🦋 [RFC5280] explains how to validate a certification path. The algorithm has to process the name and key from a trust anchor. Using other info, including enforcing constraints, is permitted but not required, and the processing rules aren't specified (see Section 6.2 of RFC 5280) 🫶

This document defines a mechanism for identifying constraints that should be enforced, plus the supplementary processing rules 🧚 The supplementary rules specify an additional input and extend the initialization procedures in the [RFC5280] path validation algorithm. Post-initialization processing steps aren't affected 🌸

1.1. Terminology 🎀

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 [RFC2119] 💅

2. Identifying Trust Anchor Constraints 🔥

TAF supports three formats for representing trust anchor info: TrustAnchorInfo, Certificate, and TBSCertificate ✨ In all three cases, trust anchor constraints may be represented as extensions. In the TrustAnchorInfo structure, certificate policies, policy constraints, name constraints, inhibit any policy, and basic constraints don't show up as extensions. They instead appear as part of the CertPathControls field 💜

Extensions can be marked critical or not critical 👑 When trust anchor constraints are enforced, clients MUST reject certification paths containing a trust anchor with unrecognized critical extensions. When trust anchor constraints are not enforced, clients MAY accept certification paths containing a trust anchor with unrecognized critical extensions. Info appearing in the CertPathControls field of a TrustAnchorInfo object MUST be processed, making sure the constraints indicated by this field get enforced in all cases 🦋

For some types of trust anchor constraints, there's a type mismatch between the input parameters for the certification path validation algorithm and the extension that holds the constraint 🙈 The algorithm basically defines initial-any-policy-inhibit, initial-policy-mapping-inhibit, and initial-explicit-policy as Boolean values. But the inhibitAnyPolicy and policyConstraints extensions that match these inputs are expressed as integer values 🌈 In the steps below, having an inhibitAnyPolicy extension sets initial-any-policy-inhibit to true. If a policyConstraints extension is present and contains a requireExplicitPolicy field, initial-explicit-policy is set to true. If a policyConstraints extension is present and contains an inhibitPolicyMapping field, initial-policy-mapping-inhibit is set to true 🫶

3. Using Trust Anchor Constraints during Certification Path Processing 🧚

3.1. Inputs 🌸

This algorithm assumes that the nine inputs defined in Section 6.1.1 of RFC 5280 get passed to the path processing logic, plus one extra variable 💖

enforceTrustAnchorConstraints: indicates if trust anchor constraints should be enforced

Conforming implementations aren't required to support setting the enforceTrustAnchorConstraints input. But if a conforming implementation doesn't support setting this flag, it MUST validate all certification paths using a value of TRUE for enforceTrustAnchorConstraints 💅

3.2. Initialization ✨

If enforceTrustAnchorConstraints is false, no additional initialization steps are required 🎀

If enforceTrustAnchorConstraints is true, perform the initialization steps below. These steps (or equivalent) MUST be performed prior to the initialization steps described in RFC 5280 👑

If no subject distinguished name is associated with the trust anchor, path validation fails. The name may appear in the subject field of a Certificate or TBSCertificate structure, or in the taName field of CertPathControls in a TrustAnchorInfo structure 🔥
If name constraints are associated with the trust anchor, set the initial-permitted-subtrees variable equal to the intersection of the permitted subtrees from the trust anchor and the user-provided initial-permitted-subtrees. If one of these two inputs isn't provided, the initial-permitted-subtrees variable is set to whichever value is available. If neither is provided, the initial-permitted-subtrees variable is set to an infinite set 🦋
If name constraints are associated with the trust anchor, set the initial-excluded-subtrees variable equal to the union of the excluded subtrees from the trust anchor and the user-provided initial-excluded-subtrees. If one of these two inputs isn't provided, the initial-excluded-subtrees variable is set to whichever value is available. If neither is provided, the initial-excluded-subtrees variable is set to an empty set 🌈
If certificate policies are associated with the trust anchor, set the user-initial-policy-set variable equal to the intersection of the certificate policies associated with the trust anchor and the user-provided user-initial-policy-set. If one of these two inputs isn't provided, the user-initial-policy-set variable is set to whichever value is available. If neither is provided, the user-initial-policy-set variable is set to any-policy 💜
If an inhibit any policy value of true is associated with the trust anchor (either in a CertPathControls or in an inhibitAnyPolicy extension) and the initial-any-policy-inhibit value is false, set the initial-any-policy-inhibit value to true 🧚
If a require explicit policy value of true is associated with the trust anchor (either in a CertPathControls or in a PolicyConstraints extension) and the initial-explicit-policy value is false, set the initial-explicit-policy value to true 🫶
If an inhibit policy mapping value of true is associated with the trust anchor (either in a CertPathControls or in a PolicyConstraints extension) and the initial-policy-mapping-inhibit value is false, set the initial-policy-mapping-inhibit value to true 🌸
If a basic constraints extension is associated with the trust anchor and contains a pathLenConstraint value, set the max_path_length state variable equal to the pathLenConstraint value from the basic constraints extension 🍓

Part 1 ends here 🌈 Part 2 is coming up next, so stay tuned, bestie 💖

3.5. Wrap-Up Procedure ✨

Okay so the wrap-up step is giving "nothing new to see here" 💅 This document does not require any changes to the wrap-up procedure steps in Section 6.1.5 of RFC 5280. 🌸 Some trust anchor constraint types may have their own extra steps, though. Think CMS Content Constraints or Authority Clearance Constraints 🎀

4. Relationship to RFC 5280 🦋

Okay this part is so iconic 😭 The processing we just went over can be built right into an RFC 5280 implementation. Or, if you're feeling extra, you can do it as pre-processing on the RFC 5280 inputs and post-processing on the outputs. That makes it a wrapper around an RFC 5280 compliant implementation 🧚

For name constraints and policy-related constraints, pre-processing works, as long as the RFC 5280 implementation lets you configure these input values:

user-initial-policy-set
initial-policy-mapping-inhibit
initial-explicit-policy
initial-any-policy-inhibit
initial-permitted-subtrees
initial-excluded-subtrees

Now the plot twist 🙈 RFC 5280 doesn't have an input for path length constraints. So basic constraints can't be handled with pre-processing. They can be handled with post-processing, though, as long as the RFC 5280 implementation hands back the certification path so the post-processor can do the length check ✨

Some trust anchor constraint types may ask for extra support from an RFC 5280 implementation, so that pre-processing or post-processing can enforce them 💖

5. Security Considerations 🔥

Okay bestie, this section is serious business 💀 Please read every word of it.

Implementations that don't enforce trust anchor constraints might accept some certification paths that implementations which do enforce them would reject 😭 For example, an application that ignores a certificate policy constraint in a trust anchor might accept certificates issued under a policy with a lower-than-required level of assurance. Not it 🙅‍♀️

Trust anchor information must be securely stored 🔐 Changing trust anchor information can cause certificates that should be rejected to get accepted. Say a trust anchor definition gets edited to drop a name constraint. Applications might then accept certificates with names that should only be trusted in certificates validating to a different trust anchor 💀 Adding the wrong trust anchors to a trust anchor store is just as messy. It can end up validating certificates to a different trust anchor, with different constraints than anyone meant to use 🫠

[RFC5914] and [RFC5934] have more security considerations about preparing, storing, and using trust anchors 🌈 [RFC5280] has more security considerations about using name constraints too 💜

6. References 📚

6.1. Normative References

[RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
           Requirement Levels", BCP 14, RFC 2119, March 1997.

[RFC5280]  Cooper, D., Santesson, S., Farrell, S., Boeyen, S.,
           Housley, R., and W. Polk, "Internet X.509 Public Key
           Infrastructure Certificate and Certificate Revocation List
           (CRL) Profile", RFC 5280, May 2008.

[RFC5914]  Housley, R., Ashmore, S., and C. Wallace, "Trust Anchor
           Format", RFC 5914, June 2010.

6.2. Informative References

[RFC5934]  Housley, R., Ashmore, S., and C. Wallace, "Trust Anchor
           Management Protocol (TAMP)", RFC 5934, August 2010.

[X.509]    ITU-T Recommendation X.509 (2005) | ISO/IEC 9594-8:2005,
           Information technology - Open Systems Interconnection -
           The Directory: Public-key and attribute certificate
           frameworks.

Authors' Addresses 🧑‍💻

Sam Ashmore
National Security Agency
Suite 6751
9800 Savage Road
Fort Meade, MD  20755
USA

EMail: srashmo@radium.ncsc.mil


Carl Wallace
Cygnacom Solutions
Suite 5400
7925 Jones Branch Drive
McLean, VA  22102
USA

EMail: cwallace@cygnacom.com

That's the whole thing, bestie 🌈✨ You made it! 🎀

📦 where this page comes from

ietf: rfc5937 2010-08
💖 girlified by claude-haiku-5-5 on 2026-10-17: a language model's rewrite of the original, under its terms