RFC 5914

Trust Anchor Format

📅 published June 2010, from ietf

RFC 5914: Trust Anchor Format 🎀

Okay bestie, let's start with the header stuff 💅 This is RFC 5914 from the Internet Engineering Task Force (IETF), titled "Trust Anchor Format," and it's dated June 2010. The authors are R. Housley (Vigil Security, LLC), S. Ashmore (National Security Agency), and C. Wallace (Cygnacom Solutions). It's a Standards Track document with ISSN 2070-1721. The header doesn't list any RFCs that it obsoletes or updates 🦋

Abstract ✨

okay so this doc describes a structure for representing trust anchor info 🌸 A trust anchor is an authoritative entity represented by a public key and associated data. The public key is used to verify digital signatures, and the associated data is used to constrain the types of information or actions for which the trust anchor is authoritative. The structures defined here are meant to satisfy the format-related requirements in Trust Anchor Management Requirements, so it's all lined up 🫶

Status of This Memo 📜

This is an Internet Standards Track document.

This document is a product of the Internet Engineering Task Force (IETF). It represents the consensus of the IETF community. It has received public review and has been approved for publication by the Internet Engineering Steering Group (IESG). Further information on Internet Standards is available in Section 2 of RFC 5741.

Info about the current status of this document, any errata, and how to give feedback on it can be found at http://www.rfc-editor.org/info/rfc5914 🧚

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) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License.

This document may contain material from IETF Documents or IETF Contributions published or made publicly available before November 10, 2008. The person(s) controlling the copyright in some of this material may not have granted the IETF Trust the right to allow modifications of such material outside the IETF Standards Process. Without obtaining an adequate license from the person(s) controlling the copyright in such materials, 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, except to format it for publication as an RFC or to translate it into languages other than English.

Table of Contents 🗂️

   1.  Introduction . . . . . . . . . . . . . . . . . . . . . . . . .  3
     1.1.  Terminology  . . . . . . . . . . . . . . . . . . . . . . .  3
   2.  Trust Anchor Information Syntax  . . . . . . . . . . . . . . .  3
     2.1.  Version  . . . . . . . . . . . . . . . . . . . . . . . . .  3
     2.2.  Public Key . . . . . . . . . . . . . . . . . . . . . . . .  3
     2.3.  Key Identifier . . . . . . . . . . . . . . . . . . . . . .  4
     2.4.  Trust Anchor Title . . . . . . . . . . . . . . . . . . . .  4
     2.5.  Certification Path Controls  . . . . . . . . . . . . . . .  4
     2.6.  Extensions . . . . . . . . . . . . . . . . . . . . . . . .  8
   3.  Trust Anchor List  . . . . . . . . . . . . . . . . . . . . . .  8
   4.  Security Considerations  . . . . . . . . . . . . . . . . . . .  9
   5.  References . . . . . . . . . . . . . . . . . . . . . . . . . .  9
     5.1.  Normative References . . . . . . . . . . . . . . . . . . .  9
     5.2.  Informative References . . . . . . . . . . . . . . . . . . 10
   Appendix A.  ASN.1 Modules . . . . . . . . . . . . . . . . . . . . 11
     A.1.  ASN.1 Module Using 2002 Syntax . . . . . . . . . . . . . . 11
     A.2.  ASN.1 Module Using 1988 Syntax . . . . . . . . . . . . . . 12
       A.2.1.  ASN.1 Module . . . . . . . . . . . . . . . . . . . . . 12

1. Introduction 🌈

Trust anchors are everywhere, and they're used to verify digital signatures and validate certification paths [RFC5280][X.509]. They are required when validating certification paths. Even though they're so widely used, there's no standard format for representing trust anchor information 😭 This document describes the TrustAnchorInfo structure. It's meant to satisfy the format-related requirements expressed in Trust Anchor Management Requirements [TA-MGMT-REQS], and it's written in ASN.1 [X.680]. It can be a more compact alternative to X.509 certificates for exchanging trust anchor information, and it gives you a way to attach additional or alternative constraints to certificates without breaking the signature on the certificate 💖

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. Trust Anchor Information Syntax 🦋

This section describes the TrustAnchorInfo structure. Here's the whole thing 👑

   TrustAnchorInfo ::= SEQUENCE {
      version   TrustAnchorInfoVersion DEFAULT v1,
      pubKey    SubjectPublicKeyInfo,
      keyId     KeyIdentifier,
      taTitle   TrustAnchorTitle OPTIONAL,
      certPath  CertPathControls OPTIONAL,
      exts      [1] EXPLICIT Extensions   OPTIONAL,
      taTitleLangTag   [2] UTF8String OPTIONAL }

   TrustAnchorInfoVersion ::= INTEGER { v1(1) }

2.1. Version 🔢

version tells you which version of TrustAnchorInfo you're looking at. Future updates to this document may change the TrustAnchorInfo structure, in which case the version number should be incremented. However, the default value, v1, cannot be changed 🙈

2.2. Public Key 🔑

pubKey identifies the public key and algorithm associated with the trust anchor, using the SubjectPublicKeyInfo structure [RFC5280]. The SubjectPublicKeyInfo structure holds the algorithm identifier first and then the public key itself. The algorithm field is an AlgorithmIdentifier, which contains an object identifier and OPTIONAL parameters. The object identifier names the public key algorithm and indicates the syntax of the parameters, if any are present, as well as the format of the public key. The public key is encoded as a BIT STRING 🍓

2.3. Key Identifier 🗝️

keyId holds the public key identifier of the trust anchor public key. For a description of common key identifier calculation methods, see Section 4.2.1.2 of [RFC5280] ✨

2.4. Trust Anchor Title 🏷️

Here's how the title is defined 💅

    TrustAnchorTitle ::= UTF8String (SIZE (1..64))

taTitle is OPTIONAL. When it's there, it gives a human-readable name for the trust anchor. The text is encoded in UTF-8 [RFC3629], which covers most of the world's writing systems, so it's super inclusive 🌍 The taTitleLangTag field identifies the language used to express the taTitle. When taTitleLangTag is absent, English ("en" language tag) is used. The value of taTitleLangTag should be a language tag as described in [RFC5646] 🌸

2.5. Certification Path Controls ✨

Okay bestie, this is where CertPathControls shows up, and honestly it's the most main-character struct in the whole trust anchor situation 💅 Here's the shape:

CertPathControls ::= SEQUENCE {
  taName           Name,
  certificate      [0] Certificate OPTIONAL,
  policySet        [1] CertificatePolicies OPTIONAL,
  policyFlags      [2] CertPolicyFlags OPTIONAL,
  nameConstr       [3] NameConstraints OPTIONAL,
  pathLenConstraint[4] INTEGER (0..MAX) OPTIONAL}

So certPath is OPTIONAL 🌸 When it's there, it gives you the controls you need to set up an X.509 certification path validation algorithm implementation (see Section 6 of [RFC5280]). When it's missing, the trust anchor can't be used to validate the signature on an X.509 certificate. Not it. 🙈

taName holds the X.500 distinguished name for the trust anchor, and that name is what gets used to build and validate an X.509 certification path 🧚 The name MUST NOT be an empty sequence, so don't even try it.

certificate is an OPTIONAL X.509 certificate that some environments can use to represent the trust anchor during certification path development and validation 🦋 If it's present, the subject name in the certificate MUST exactly match the X.500 distinguished name in taName, the public key MUST exactly match the public key in pubKey, and the subjectKeyIdentifier extension (if it's there) MUST exactly match the key identifier in keyId. The full syntax and semantics of Certificate live in [RFC5280]. Now the tea ☕️: the constraints in policySet, policyFlags, nameConstr, pathLenConstraint, and exts inside TrustAnchorInfo either replace values in a certificate or fill in values for extensions the certificate doesn't have. TrustAnchorInfo values are always enforced 💜 Extensions in a certificate only get enforced when TrustAnchorInfo doesn't have a matching value. Here's how the matchups work:

an id-ce-certificatePolicies certificate extension corresponds to the CertPathControls.policySet field.
an id-ce-policyConstraints certificate extension corresponds to the CertPolicyFlags.inhibitPolicyMapping and CertPolicyFlags.requireExplicitPolicy fields.
an id-ce-inhibitAnyPolicy certificate extension corresponds to the CertPolicyFlags.inhibitAnyPolicy field.
an id-ce-nameConstraints certificate extension corresponds to the CertPathControls.nameConstr field.
the pathLenConstraint field of an id-ce-basicConstraints certificate extension corresponds to the CertPathControls.pathLenConstraint field (the presence of a CertPathControls structure corresponds to a TRUE value in the cA field of a BasicConstraints extension).
any other certificate extension corresponds to the same type of extension in the TrustAnchorInfo.exts field.

CertificatePolicies ::= SEQUENCE SIZE (1..MAX) OF PolicyInformation

PolicyInformation ::= SEQUENCE {
  policyIdentifier  CertPolicyId,
  policyQualifiers  SEQUENCE SIZE (1..MAX) OF
                          PolicyQualifierInfo OPTIONAL }

CertPolicyId ::= OBJECT IDENTIFIER

policySet is OPTIONAL 🎀 When it's there, it holds a sequence of certificate policy identifiers that get fed in as inputs to the certification path validation algorithm. When it's absent, the special value any-policy gets fed in instead. The full syntax and semantics of CertificatePolicies are in [RFC5280], including the syntax for PolicyInformation. In this context, the OPTIONAL policyQualifiers structure MUST NOT be included. No qualifiers, no drama 🙅‍♀️

CertPolicyFlags ::= BIT STRING {
  inhibitPolicyMapping   (0),
  requireExplicitPolicy  (1),
  inhibitAnyPolicy       (2) }

policyFlags is OPTIONAL. When it's present, three Boolean values get passed into the certification path validation algorithm as a BIT STRING. When it's absent, the input is { FALSE, FALSE, FALSE }, which is the most liberal setting for these flags 🦋 The three bits do the following:

inhibitPolicyMapping tells you whether policy mapping is allowed in the certification path. When it's set to TRUE, policy mapping is not permitted. This is the initial-policy-mapping-inhibit input value to the certification path validation algorithm described in Section 6.1.1 of [RFC5280].

requireExplicitPolicy tells you whether the certification path MUST be valid for at least one of the certificate policies in the policySet. When it's set to TRUE, every certificate in the certification path MUST contain an acceptable policy identifier in the certificate policies extension. This is the initial-explicit-policy input value to the certification path validation algorithm described in Section 6.1.1 of [RFC5280]. An acceptable policy identifier is either a member of the policySet or an identifier of a policy that's declared equivalent through policy mapping. This bit MUST be set to FALSE if policySet is absent 🙈

inhibitAnyPolicy tells you whether the special anyPolicy policy identifier, with the value { 2 5 29 32 0 }, counts as an explicit match for other certificate policies. This is the initial-any-policy-inhibit input value to the certification path validation algorithm described in Section 6.1.1 of [RFC5280] ✨

NameConstraints ::= SEQUENCE {
  permittedSubtrees  [0] GeneralSubtrees OPTIONAL,
  excludedSubtrees   [1] GeneralSubtrees OPTIONAL }

GeneralSubtrees ::= SEQUENCE SIZE (1..MAX) OF GeneralSubtree
GeneralSubtree ::= SEQUENCE {
  base     GeneralName,
  minimum  [0] BaseDistance DEFAULT 0,
  maximum  [1] BaseDistance OPTIONAL }

BaseDistance ::= INTEGER (0..MAX)

nameConstr is OPTIONAL 🌈 It has the exact same syntax and semantics as the Name Constraints certificate extension in [RFC5280], which means a list of permitted names and a list of excluded names. The GeneralName definition is also in [RFC5280]. When it's present, you get constraints on the names (alternative names included) that might show up in later X.509 certificates in a certification path. It's what sets the initial-permitted-subtrees and initial-excluded-subtrees input values for the algorithm in Section 6.1.1 of [RFC5280]. When it's absent, initial-permitted-subtrees is unbounded and initial-excluded-subtrees is empty, so basically no limits 🫶

The pathLenConstraint field gives the maximum number of non-self-issued intermediate certificates that may follow this certificate in a valid certification path. (Quick note: the last certificate in the path isn't an intermediate certificate and doesn't count toward this limit. Usually that last one is an end entity certificate, but it can also be a CA certificate.) A pathLenConstraint of zero means no non-self-issued intermediate certification authority (CA) certificates may follow in a valid certification path. Where it appears, pathLenConstraint MUST be greater than or equal to zero. Where it doesn't appear, no limit is imposed 🍓

When the trust anchor is used to validate a certification path, CertPathControls puts limits on which certification paths will successfully validate 👑 An application validating a certification path SHOULD NOT ignore these limits, but it can add extra limits so the validated path actually fits its intended application context. As input to the certification path validation algorithm, an application MAY:

Provide a subset of the certification policies provided in the policySet;
Provide a TRUE value, if appropriate, for any of the flags in the policyFlags;
Provide a subset of the permitted names provided in the nameConstr;
Provide additional excluded names to the ones that are provided in the nameConstr;
Provide a smaller value for pathLenConstraint.

2.6. Extensions 🧚

exts is OPTIONAL 💖 When it's present, you can use it to attach extra information to the trust anchor through the standard Extensions structure. The extensions people are expected to use a lot already got their own spot in CertPathControls, so nobody has to pay the overhead of the Extensions structure for them. To avoid duplicating the CertPathControls field, the following types of extensions MUST NOT appear in the exts field, and they get ignored if they do show up: id-ce-certificatePolicies, id-ce-policyConstraints, id-ce-inhibitAnyPolicy, or id-ce-nameConstraints 🚫💅

3. Trust Anchor List 🦋

TrustAnchorInfo only lets you represent a single trust anchor, but honestly you'll usually have a whole crew of them 🫶 That's why the TrustAnchorList structure exists. TrustAnchorList is a sequence of one or more TrustAnchorChoice objects, and TrustAnchorChoice gives you three ways to represent a trust anchor. The certificate option lets you use a certificate with no extra associated constraints. The tbsCert option lets you attach constraints by removing the signature from a certificate and changing its extensions field. The taInfo option lets you use the TrustAnchorInfo structure defined in this document ✨

TrustAnchorList ::= SEQUENCE SIZE (1..MAX) OF TrustAnchorChoice

TrustAnchorChoice ::= CHOICE {
   certificate  Certificate,
   tbsCert      [1] EXPLICIT TBSCertificate,
   taInfo       [2] EXPLICIT TrustAnchorInfo }

 trust-anchor-list PKCS7-CONTENT-TYPE ::=
    { TrustAnchorList IDENTIFIED BY id-ct-trustAnchorList }

The TrustAnchorList structure can be protected using the SignedData structure from the Cryptographic Message Syntax (CMS) in [RFC5652] 🔥 The id-ct-trustAnchorList object identifier has been defined to represent TrustAnchorList payloads inside CMS structures.

4. Security Considerations 💀

Okay, this section is serious, so buckle up 😭 If someone gets a hold of a trust anchor private key, they can pretend to be the trust anchor, and the consequences can be seriously bad. When TA-based constraints are enforced, the unauthorized holder of the trust anchor private key is still limited by the certification path controls tied to the trust anchor, as expressed in the certPath and exts fields. For example, name constraints in the trust anchor decide which name space gets accepted in certificates validated using the compromised trust anchor. Relying on an inappropriate or incorrect trust anchor public key has similarly serious consequences 🌸

Compromising a CA's private key causes the same kinds of problems as compromising a trust anchor private key. The unauthorized holder of the CA private key is still limited by the certification path controls tied to the trust anchor, as expressed in the certPath field or as an extension 🙈

Using a certificate apart from the TrustAnchorInfo structure that envelopes it has to be carefully managed, so you don't break the constraints expressed in the TrustAnchorInfo. When you envelope a certificate in a TrustAnchorInfo structure, you should evaluate the values included in the certificate to make sure there's no confusion or conflict with values in the TrustAnchorInfo structure 🔥

5. References 📚✨

5.1. Normative References 💅

okay so these are the docs this spec literally can't function without, bestie 🫶

[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997. 🎀
[RFC3629] Yergeau, F., "UTF-8, a transformation format of ISO 10646", STD 63, RFC 3629, November 2003. 🌈
[RFC5652] Housley, R., "Cryptographic Message Syntax (CMS)", RFC 5652, September 2009. 🦋
[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. 🔥
[RFC5646] Phillips, A. and M. Davis, "Tags for Identifying Languages", BCP 47, RFC 5646, September 2009. 🌸
[RFC5912] Hoffman, P. and J. Schaad, "New ASN.1 Modules for the Public Key Infrastructure Using X.509 (PKIX)", RFC 5912, June 2010. 👑
[X.680] "ITU-T Recommendation X.680: Information Technology - Abstract Syntax Notation One", 2002. 🧚

5.2. Informative References 🍓

these ones are more like extra reading, no cap 🤓

[TA-MGMT-REQS] Reddy, R. and C. Wallace, "Trust Anchor Management Requirements", Work in Progress, March 2010. 💜
[X.509] "ITU-T Recommendation X.509 - The Directory - Authentication Framework", 2000. ⭐

Appendix A. ASN.1 Modules 🎀

A.1. ASN.1 Module Using 2002 Syntax 🦋

okay this is the big one, the full 2002 ASN.1 module, and it is SO good 😭💖

Appendix A.1 provides the normative ASN.1 definitions for the structures described in this specification using ASN.1 as defined in [X.680]. It includes definitions imported from [RFC5280] and [RFC5912].

TrustAnchorInfoModule
{ joint-iso-ccitt(2) country(16) us(840) organization(1)
   gov(101) dod(2) infosec(1) modules(0) 33 }

DEFINITIONS IMPLICIT TAGS ::=
BEGIN

IMPORTS
Certificate, Name, SubjectPublicKeyInfo, TBSCertificate
FROM PKIX1Explicit-2009 -- from [RFC5912]
    {iso(1) identified-organization(3) dod(6) internet(1) security(5)
    mechanisms(5) pkix(7) id-mod(0) id-mod-pkix1-explicit-02(51)}
CertificatePolicies, KeyIdentifier, NameConstraints
FROM PKIX1Implicit-2009 -- from [RFC5912]
    {iso(1) identified-organization(3) dod(6) internet(1) security(5)
    mechanisms(5) pkix(7) id-mod(0) id-mod-pkix1-implicit-02(59)}
Extensions{}
FROM PKIX-CommonTypes-2009 -- from [RFC5912]
    { iso(1) identified-organization(3) dod(6) internet(1)
    security(5) mechanisms(5) pkix(7) id-mod(0)
    id-mod-pkixCommon-02(57) }         ;

TrustAnchorInfo ::= SEQUENCE {
   version   TrustAnchorInfoVersion DEFAULT v1,
   pubKey    SubjectPublicKeyInfo,
   keyId     KeyIdentifier,
   taTitle   TrustAnchorTitle OPTIONAL,
   certPath  CertPathControls OPTIONAL,
   exts      [1] EXPLICIT Extensions {{...}}   OPTIONAL,
   taTitleLangTag   [2] UTF8String OPTIONAL }

TrustAnchorInfoVersion ::= INTEGER { v1(1) }

TrustAnchorTitle ::= UTF8String (SIZE (1..64))

CertPathControls ::= SEQUENCE {
  taName           Name,
  certificate      [0] Certificate OPTIONAL,
  policySet        [1] CertificatePolicies OPTIONAL,
  policyFlags      [2] CertPolicyFlags OPTIONAL,
  nameConstr       [3] NameConstraints OPTIONAL,
  pathLenConstraint[4] INTEGER (0..MAX) OPTIONAL}

CertPolicyFlags ::= BIT STRING {
  inhibitPolicyMapping    (0),
  requireExplicitPolicy   (1),
  inhibitAnyPolicy        (2) }

TrustAnchorList ::= SEQUENCE SIZE (1..MAX) OF TrustAnchorChoice

TrustAnchorChoice ::= CHOICE {
  certificate  Certificate,
  tbsCert      [1] EXPLICIT TBSCertificate,
  taInfo       [2] EXPLICIT TrustAnchorInfo }

id-ct-trustAnchorList      OBJECT IDENTIFIER ::= { iso(1)
    member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs9(9)
    id-smime(16) id-ct(1) 34 }

PKCS7-CONTENT-TYPE ::= TYPE-IDENTIFIER

trust-anchor-list PKCS7-CONTENT-TYPE ::=
    { TrustAnchorList IDENTIFIED BY id-ct-trustAnchorList }

END

A.2. ASN.1 Module Using 1988 Syntax 🌈

Appendix A.2 provides the normative ASN.1 definitions for the structures described in this specification using ASN.1 as defined in [X.680].

A.2.1. ASN.1 Module 💖

TrustAnchorInfoModule-88
    { joint-iso-ccitt(2) country(16) us(840) organization(1)
      gov(101) dod(2) infosec(1) modules(0) 37 }

DEFINITIONS IMPLICIT TAGS ::=
BEGIN

IMPORTS
Certificate, Name, Extensions,
SubjectPublicKeyInfo, TBSCertificate
   FROM PKIX1Explicit88 -- from [RFC5280]
        { iso(1) identified-organization(3) dod(6) internet(1)
          security(5) mechanisms(5) pkix(7) id-mod(0)
          id-pkix1-explicit(18) }
CertificatePolicies, KeyIdentifier, NameConstraints
   FROM PKIX1Implicit88 -- [RFC5280]
        { iso(1) identified-organization(3) dod(6) internet(1)
          security(5) mechanisms(5) pkix(7) id-mod(0)
          id-pkix1-implicit(19) }
 ;

TrustAnchorInfo ::= SEQUENCE {
   version   TrustAnchorInfoVersion DEFAULT v1,
   pubKey    SubjectPublicKeyInfo,
   keyId     KeyIdentifier,
   taTitle   TrustAnchorTitle OPTIONAL,
   certPath  CertPathControls OPTIONAL,
   exts      [1] EXPLICIT Extensions   OPTIONAL,
   taTitleLangTag   [2] UTF8String OPTIONAL }

TrustAnchorInfoVersion ::= INTEGER { v1(1) }

TrustAnchorTitle ::= UTF8String (SIZE (1..64))

CertPathControls ::= SEQUENCE {
  taName           Name,
  certificate      [0] Certificate OPTIONAL,
  policySet        [1] CertificatePolicies OPTIONAL,
  policyFlags      [2] CertPolicyFlags OPTIONAL,
  nameConstr       [3] NameConstraints OPTIONAL,
  pathLenConstraint[4] INTEGER (0..MAX) OPTIONAL}

CertPolicyFlags ::= BIT STRING {
  inhibitPolicyMapping    (0),
  requireExplicitPolicy   (1),
  inhibitAnyPolicy        (2) }

TrustAnchorList ::= SEQUENCE SIZE (1..MAX) OF TrustAnchorChoice

TrustAnchorChoice ::= CHOICE {
  certificate  Certificate,
  tbsCert      [1] EXPLICIT TBSCertificate,
  taInfo       [2] EXPLICIT TrustAnchorInfo }

id-ct-trustAnchorList      OBJECT IDENTIFIER ::= { iso(1)
    member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs9(9)
    id-smime(16) id-ct(1) 34 }

END

Authors' Addresses 🫶

Russ Housley
Vigil Security, LLC
918 Spring Knoll Drive
Herndon, VA  20170

EMail: housley@vigilsec.com

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

EMail: srashmo@radium.ncsc.mil

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

EMail: cwallace@cygnacom.com

📦 where this page comes from

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