RFC 5752

Multiple Signatures in Cryptographic Message Syntax (CMS)

📅 published January 2010, from ietf

RFC 5752: Multiple Signatures in Cryptographic Message Syntax (CMS) 🎀

Number: RFC 5752 💖
Published by: Internet Engineering Task Force (IETF) 🌸
Authors: S. Turner (IECA) and J. Schaad (Soaring Hawk) 🦋
Category: Standards Track 👑
ISSN: 2070-1721 ✨
Date: January 2010 📅
Obsoletes / Updates: the title block doesn't list anything this one obsoletes or updates 🌈

Abstract ✨

Okay so, CMS SignedData has a SignerInfo structure for sharing each signer's info, and it can hold multiple signers, each using multiple signature algorithms, with a separate SignerInfo for each one. 💅 The lowkey scary part is that if a signer attaches more than one SignerInfo, an attacker could run a downgrade attack by deleting the SignerInfo(s) using the 'strong' algorithm(s). 😭 This doc defines the multiple-signatures attribute, plus the rules for generating it and processing it, so signers can share multiple SignerInfo objects while staying protected from downgrade attacks. 🫶 It might also help during periods of algorithm migration. 🔥

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 went through public review and got approved for publication by the Internet Engineering Steering Group (IESG). 🌸 More info on Internet Standards is in Section 2 of RFC 5741. 💅

Current status info, any errata, and how to send feedback can be found at http://www.rfc-editor.org/info/rfc5752. 🦋

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 these carefully, because they explain 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 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 people who control the copyright in some of that material may not have granted the IETF Trust the right to allow modifications outside the IETF Standards Process. Unless you get an adequate license from the people controlling the copyright in those 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. The only 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. Conventions Used in This Document ..........................3
   2. Rationale .......................................................3
      2.1. Attribute Design Requirements ..............................4
   3. Multiple Signature Indication ...................................5
   4. Message Generation and Processing ...............................6
      4.1. SignedData Type ............................................6
      4.2. EncapsulatedContentInfo Type ...............................7
      4.3. SignerInfo Type ............................................7
      4.4. Message Digest Calculation Process .........................7
           4.4.1. multiple-signatures Signed Attribute Generation .....7
           4.4.2. Message Digest Calculation Process ..................7
      4.5. Signature Generation Process ...............................8
      4.6. Signature Verification Process .............................8
   5. Signature Evaluation Processing .................................8
      5.1. Evaluation of a SignerInfo Object ..........................9
      5.2. Evaluation of a SignerInfo Set .............................9
      5.3. Evaluation of a SignedData Set ............................10
   6. Security Considerations ........................................11
   7. References .....................................................11
      7.1. Normative References ......................................11
      7.2. Informative References ....................................12
   Appendix A. ASN.1 Module...........................................13
   Appendix B. Background.............................................15
      B.1. Attacks....................................................15
      B.2. Hashes in CMS..............................................15

1. Introduction 🌸

Okay so, CMS (see [CMS]) defined SignerInfo to hand over the data relying parties need to verify a signer's digital signature. 💅 That signature is also stored inside the SignerInfo structure. Signers put more than one SignerInfo in a SignedData when they use different digest or signature algorithms. 🦋 Each SignerInfo exists on its own, so you can add new ones or remove existing ones without shaking up the other signatures. ✨

Here's the worry. If an attacker successfully broke a hash or signature algorithm, they could delete every SignerInfo except the one using that busted algorithm. 😭 The relying party would then be stuck with the attacked SignerInfo, even though it supported more than just that one algorithm. 💀

The fix is for signers to include a pointer to all of their SignerInfo structures. If an attacker removes any SignerInfo, relying parties will know that one or more SignerInfo objects went missing. 👑

Quick note: this attribute ought not be confused with the countersignature attribute (see Section 11.4 of [CMS]), because it isn't meant to sign over an existing signature. 🙈 Instead, it provides pointers to additional signatures from the same signer that all sit at the same level. In other words, countersignature gives you a serial signature, while this attribute gives you pointers to parallel signatures from the same signer. 🧚

1.1. Conventions Used in This Document 💅

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 [RFC2119]. 📖

2. Rationale 🎀

The whole point of this spec is to stop downgrade attacks that strip out the 'strong' signature and leave behind the 'weak' one, which has presumably been successfully attacked. 😭 If a CMS SignedData object has multiple SignerInfo objects, then the attacker, whether it be Alice, Bob, or Mallory, can remove a SignerInfo object without the relying party ever knowing more than one was generated. 🙈

Removing a SignerInfo doesn't make the signature invalid, and it isn't an error either. 🌈 Here's the scenario: a signer generates a SignedData with two SignerInfo objects, one with a 'weak' algorithm and one with a 'strong' algorithm. There are three types of relying parties to think about:

Those that support only a 'weak' algorithm. If both SignerInfo objects are present, the relying party processes the algorithm it supports. If both SignerInfo objects are not present, the relying party can easily determine that another SignerInfo has been removed, but not changed. In both cases, if the 'weak' signature verifies, the relying party MAY consider the signature valid. 💅
Those that support only a 'strong' algorithm. If both SignerInfo objects are present, the relying party processes the algorithm it supports. If both SignerInfo objects are not present, the relying party can easily determine that another SignerInfo has been removed, but the relying party doesn't care. In both cases, if the 'strong' signature verifies, the relying party MAY consider the signature valid. 💖
Those that support both a 'weak' algorithm and a 'strong' algorithm. If both SignerInfo objects are present, the relying party processes both algorithms. If both SignerInfo objects are not present, the relying party can easily determine that another SignerInfo has been removed. In both cases, if the 'strong' and/or 'weak' signatures verify, the relying party MAY consider the signature valid. (Policy may dictate that both signatures are required to validate if present.) 🦋

Local policy MAY dictate that removing the 'strong' algorithm results in an invalid signature. 👑 See Section 5 for further processing. 🫶

2.1. Attribute Design Requirements ✨

The attribute will have the following characteristics:

Use CMS attribute structure; 🎀
Be computable before any signatures are applied; 🌸
Contain enough information to identify individual signatures (i.e., a particular SignerInfo); and 🦋
Contain enough information to resist collision, preimage, and second preimage attacks. 🔥

3. Multiple Signature Indication ✨

Okay so the multiple-signatures attribute type is basically a pointer 👉 that links a signer to their other multiple-signatures attribute(s). 🦋 Say a signer applies three signatures. Then each SignerInfo needs two attribute values for multiple-signatures. The 1st SignerInfo points to the 2nd and 3rd. The 2nd points to the 1st and 3rd. The 3rd points to the 1st and 2nd. It's giving a little web of signatures, bestie 🕸️💖

The multiple-signatures attribute MUST be a signed attribute. 💅 The number of attribute values in a SignerInfo is the number of signatures the signer applied, minus one. This attribute is multi-valued, so there MAY be more than one AttributeValue present. ✨ The object identifier that names it is:

   id-aa-multipleSignatures OBJECT IDENTIFIER ::= {
     iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs9(9)
     id-aa(16) 51 }

The attribute values have the ASN.1 type MultipleSignatures. 🎀

   MultipleSignatures ::= SEQUENCE {
     bodyHashAlg     DigestAlgorithmIdentifier,
     signAlg         SignatureAlgorithmIdentifier,
     signAttrsHash   SignAttrsHash,
     cert            ESSCertIDv2 OPTIONAL}

   SignAttrsHash ::= SEQUENCE {
     algID            DigestAlgorithmIdentifier,
     hash             OCTET STRING }

Here's what each field means, obsessed with the details 🙈

bodyHashAlg holds the digest algorithmIdentifier for the referenced multiple-signatures attribute.
signAlg holds the signature algorithmIdentifier for the referenced multiple-signatures attribute.
signAttrsHash has two fields:
- algId MUST match the digest algorithm for the SignerInfo that this multiple-signatures attribute value is placed in.
- hash is the hash value of the signedAttrs (see Section 4.3).
cert is optional. 🌸 It identifies the certificate that was used to sign the SignerInfo containing the other multiple-signatures attribute(s). It MUST be present if the fields in the other multiple-signatures attribute(s) are the same.

Here's an example, iykyk 🧚

   SignedData
     DigestAlg=sha1,sha256
     SignerInfo1                SignerInfo2
       digestAlg=sha1             digestAlg=sha256
       signatureAlg=dsawithsha1   signatureAlg=ecdsawithsha256
       signedAttrs=               signedAttrs=
         signingTime1               signingTime1
         messageDigest1             messageDigest2
         multiSig1=                 multiSig2=
           bodyHash=sha256           bodyHash=sha1
           signAlg=ecdsawithsha256   signAlg=dsawithsha1
             signAttrsHash=          signAttrsHash=
             algID=sha1              algID=sha256
             hash=value1             hash=value2

4. Message Generation and Processing 🫶

Okay, these are the extra procedures for message generation when you're using the multiple-signatures attribute. 💜 They track with Sections 5.1-5.6 in [CMS], so go read those too, main character energy 👑

4.1. SignedData Type

The following steps MUST be followed by a signer when generating SignedData: 🔥

The signer MUST indicate the CMS version.
The signer SHOULD include the digest algorithm used in SignedData.digestAlgorithms, if the digest algorithm's identifier is not already present.
The signer MUST include the encapContentInfo. Note that the encapContentInfo is the same for all signers in this SignedData.
The signer SHOULD add certificates sufficient to contain certificate paths from a recognized "root" or "top-level certification authority" to the signer, if the signer's certificates are not already present.
The signer MAY include the Certificate Revocation Lists (CRLs) necessary to validate the digital signature, if the CRLs are not already present.
The signer MUST:
- Retain the existing signerInfo objects.
- Include their signerInfo object(s).

4.2. EncapsulatedContentInfo Type

The procedures for generating EncapsulatedContentInfo are as specified in Section 5.2 of [CMS]. 🌈

4.3. SignerInfo Type

The procedures for generating SignerInfo are as specified in Section 4.4.1 of [CMS] with the following addition:

The signer MUST include the multiple-signatures attribute in signedAttrs. 🍓

4.4. Message Digest Calculation Process

4.4.1. multiple-signatures Signed Attribute Generation

The procedure for generating the multiple-signatures signed attribute goes like this: 🦋

All other signed attributes are placed in the respective SignerInfo structures, but the signatures are not yet computed for the SignerInfo.
The multiple-signatures attributes are added to each of the SignerInfo structures with the SignAttrsHash.hash field containing a zero-length octet string.
The correct SignAttrsHash.hash value is computed for each of the SignerInfo structures.
After all hash values have been computed, the correct hash values are placed into their respective SignAttrsHash.hash fields.

4.4.2. Message Digest Calculation Process

The remaining procedures for generating the message-digest attribute are as specified in Section 5.4 of [CMS]. 💅

4.5. Signature Generation Process

The procedures for signature generation are as specified in Section 5.5 of [CMS]. ✨

4.6. Signature Verification Process

The procedures for signature verification are as specified in Section 5.6 of [CMS] with the following addition: 🎀

If the SignedData signerInfo includes the multiple-signatures attribute, the attribute's values must be calculated as described in Section 4.4.1.

For every SignerInfo to be considered present for a given signer, the number of MultipleSignatures AttributeValue(s) present in a given SignerInfo MUST equal the number of SignerInfo objects for that signer less one, and the hash value present in each of the MultipleSignatures AttributeValue(s) MUST match the output of the message digest calculation from Section 4.4.1 for each SignerInfo. 🔥

The hash corresponding to the n-th SignerInfo must match the value in the multiple-signatures attribute that points to the n-th SignerInfo present in all other SignerInfo objects. 🧚

5. Signature Evaluation Processing 🌸

This section describes recommended processing of signatures when there is more than one SignerInfo present in a message. 💖 That can happen either because multiple SignerInfo objects are in a single SignedData object, or because multiple SignerData objects are embedded in each other.

The text in this section is non-normative. The processing described is highly recommended, but it isn't forced. Changes in the processing that get the same results with somewhat different orders of processing are sufficient. 🙈

Order of operations:

Evaluate each SignerInfo object independently.
Combine the results of all SignerInfo objects at the same level (i.e., attached to the same SignerData object).
Combine the results of the nested SignerData objects. Note that this should ignore the presence of other CMS objects between the SignedData objects.

5.1. Evaluation of a SignerInfo Object

When evaluating a SignerInfo object, there are three different pieces that need to be examined. 🦋

The first piece is the mathematics of the signature itself (i.e., can one actually successfully do the computations and get the correct answer?). This result is one of three results: the mathematics succeeds, the mathematics fails, or the mathematics cannot be evaluated. The things that lead to that last state are non-implementation of an algorithm, or required inputs such as the public key being missing. 💀

The second piece is validating the source of the public key. For CMS, this is generally determined by extracting the public key from a certificate, and the certificate needs to be evaluated. That's done by the procedures outlined in [PROFILE]. On top of the processing described in that document, there may be additional requirements on certification path processing that the application in question requires. One such set of additional processing is described in [SMIME-CERT]. One piece of information that's part of this additional certificate path processing is local and application policy. The output of this processing can be one of four different states: Success, Failure, Indeterminate, and Warning. The first three states are described in [PROFILE]. Warning would be generated when it's possible that some information is currently acceptable, but may not be acceptable either in the near future or under some circumstances. 🌈

The third piece of validation is local and application policy as applied to the contents of the SignerInfo object. This covers things like the requirements on mandatory signed attributes or requirements on signature algorithms. 👑

5.2. Evaluation of a SignerInfo Set

Combining the results of the individual SignerInfo objects into a result for a SignedData object requires knowledge of the results for the individual SignerInfo objects, the required application policy, and any local policies. The default processing, if no other rules are applied, should be: ✨

Group the SignerInfo objects by the signer.
Take the best result from each signer.
Take the worst result from all of the different signers; this is the result for the SignedData object.

Application and local policy can affect each of the steps outlined above. 🎀

In Step 1:

If the subject name or subject alternative name(s) cannot be used to determine if two SignerInfo objects were created by the same identity, then applications need to specify how that matching is done. For example, the S/MIME message specification [SMIME-MSG] could say that as long as the same rfc822Name exists in either the subject name or the subject alt name, they are the same identity. This would be true even if other information that didn't match existed in those fields. 🧚
Some applications may specify that this step should be skipped. That has the effect of making each SignerInfo object independent of all other SignerInfo objects, even if the signing identity is the same. Applications that specify this need to be aware that algorithm rollover will not work correctly in this case. 💀

In Step 2:

The major policy implication at this step is how the indeterminate states get treated, and in what order. In most cases, this state would be placed between the failure and warning states. Part of the issue is whether to have a multi-state or a binary answer for success or failure of an evaluation. Not every application can deal with the statement "try again later". It may also depend on what the reason for the indeterminate state is. It makes more sense to try again later if the problem is that a CRL cannot be found, than if you're not able to evaluate the algorithm for the signature. 🙈

In Step 3:

The same policy implications from Step 2 apply here. 🌸

5.3. Evaluation of a SignedData Set ✨

Okay so simple apps usually just go with the worst single outcome (success, unknown, or failure) for a whole set of SignedData objects 💅 which basically means one failure sinks the entire thing 😭. Not every app wants that though, and honestly that's valid 🫶.

Here's a work flow app vibe 🌸. The second signer modifies the original content, keeps the original signature, and then signs the message 🖋️. That means only the outermost signature actually matters during evaluation ✨. The second signer is basically saying "I validated the inner signature during my processing, trust me bestie" 💜.

Now for a Signed Mail one 📬. If signatures are added for the support of [ESS] features, then an outer layer signature that can't be validated can be treated as a non-significant failure 🙈. The only thing that matters is that the originator signature is valid 👑. So all the failing outer layer signatures can get stripped from the message before display, leaving only the inner-most valid signature to be shown 🦋.

6. Security Considerations 🔥

Security considerations from the hash and signature algorithms used to produce the SignerInfo apply. Yes, these are serious, bestie 😭.

If the hashing and signing operations are performed by different entities, the entity creating the signature must ensure that the hash comes from a "trustworthy" source 🚨. This can be partially mitigated by requiring that multiple hashes using different algorithms are provided 🛡️.

This attribute cannot be relied upon in the event that all of the algorithms used in the signer attribute are 'cracked'. It is not possible for a verifier to determine that a collision could not be found that satisfies all of the algorithms. 💀

Local policy and applications greatly affect signature processing 🌈. The application of local policy and the requirements specific to an application can both affect signature processing. This means that a signature valid in one context or location can fail validation in a different context or location 🫠.

7. References 📚

7.1. Normative References

[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
[CMS] Housley, R., "Cryptographic Message Syntax (CMS)", RFC 5652, September 2009.
[PROFILE] 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.
[SMIME-CERT] Ramsdell, B. and S. Turner, "Secure/Multipurpose Internet Mail Extensions (S/MIME) Version 3.2 Certificate Handling", RFC 5750, January 2010.
[SMIME-MSG] Ramsdell, B. and S. Turner, "Secure/Multipurpose Internet Mail Extensions (S/MIME) Version 3.2 Message Specification", RFC 5751, January 2010.
[ESS] Hoffman, P., Ed., "Enhanced Security Services for S/MIME", RFC 2634, June 1999.
[ESSCertID] Schaad, J., "Enhanced Security Services (ESS) Update: Adding CertID Algorithm Agility", RFC 5035, August 2007.

7.2. Informative References

[ATTACK] Hoffman, P. and B. Schneier, "Attacks on Cryptographic Hashes in Internet Protocols", RFC 4270, November 2005.

Appendix A. ASN.1 Module 🧚

Here's the ASN.1 module, copied exactly so nothing gets lost in translation 💖.

MultipleSignatures-2008

  { iso(1) member-body(2) us(840) rsadsi(113549)
    pkcs(1) pkcs9(9) smime(16) modules(0)
    id-mod-multipleSig-2008(34) }

   DEFINITIONS IMPLICIT TAGS ::=

   BEGIN

-- EXPORTS All

-- The types and values defined in this module are exported for use
-- in the other ASN.1 modules.  Other applications may use them for
-- their own purposes.

IMPORTS

-- Imports from RFC 5652 [CMS], 12.1

     DigestAlgorithmIdentifier, SignatureAlgorithmIdentifier
     FROM CryptographicMessageSyntax2004
       { iso(1) member-body(2) us(840) rsadsi(113549)
         pkcs(1) pkcs9(9) smime(16) modules(0) cms-2004(24) }

-- Imports from RFC 5035 [ESSCertID], Appendix A

     ESSCertIDv2
     FROM ExtendedSecurityServices-2006
       { iso(1) member-body(2) us(840) rsadsi(113549)
         pkcs(1) pkcs9(9) smime(16) modules(0) id-mod-ess-2006(30) }

;

-- Section 3.0

id-aa-multipleSignatures OBJECT IDENTIFIER ::= { iso(1) member-body(2)
us(840) rsadsi(113549) pkcs(1) pkcs9(9) id-aa(2) 51 }

MultipleSignatures ::= SEQUENCE {
  bodyHashAlg     DigestAlgorithmIdentifier,
  signAlg         SignatureAlgorithmIdentifier,
  signAttrsHash   SignAttrsHash,
  cert            ESSCertIDv2 OPTIONAL }

SignAttrsHash ::= SEQUENCE {
  algID            DigestAlgorithmIdentifier,
  hash             OCTET STRING }

END -- of MultipleSignatures-2008

Appendix B. Background 🎀

This is an informational appendix, so it's just the tea ☕. It lists every spot in CMS where hashes get used, plus the attacks that could target each one 🔍.

B.1. Attacks 💥

As noted in [ATTACK], these are the types of resistance you need against known attacks:

1) Collision Resistance: Find x and y where x != y and H(x) = H(y)
2) Preimage Resistance: Given y, find x where H(x) = y
3) Second Preimage Resistance: Given y, find x where H(x) = H(y)

Note: It is known that a collision resistance attack is simpler than a second preimage resistance attack, and it is presumed that a second preimage resistance attack is simpler than a preimage attack. 🤓

B.2. Hashes in CMS 🧁

Within a SignerInfo there are two places where hashes are applied and so can be attacked: the body and the signed attributes 🎯. Here's who creates the hash, who might attack it, and what kind of resistance they'd need 👀.

1) Hash of the Body (i.e., the octets comprising the value of the encapContentInfo.eContent OCTET STRING omitting the tag and length octets, as per 5.4 of [CMS]).
- a) If Alice creates the body to be hashed, then:
  - i) Alice can attack the hash. This attack requires a successful collision resistance attack.
  - ii) Mallory can attack the hash. This attack requires a successful second preimage resistance attack.
- b) If Alice hashes a body provided by Bob, then:
  - i) Alice can attack the hash. This attack requires a successful second preimage attack.
  - ii) Bob can attack the hash. This attack requires a successful Collision Resistance attack. If Alice has the ability to "change" the content of the body in some fashion, then this attack requires a successful second preimage attack. (One example would be to use a keyed hash function.)
  - iii) Mallory can attack the hash. This attack requires a successful second preimage attack.
- c) If Alice signs using a hash value provided by Bob (in this case, Alice is presumed to never see the body in question), then:
  - i) Alice can attack the hash. This attack requires a successful preimage attack.
  - ii) Bob can attack the hash. This attack requires a successful collision resistance attack. Unlike case (b), there is nothing that Alice can do to upgrade the attack.
  - iii) Mallory can attack the hash. This requires a successful preimage attack if the content is unavailable to Mallory and a successful second preimage attack if the content is available to Mallory.
2) Hash of signed attributes (i.e., the complete Distinguished Encoding Rules (DER) encoding of the SignedAttrs value contained in the signedAttrs field, as per 5.4 of [CMS]).

There is a difference between hashing the body and hashing the SignedAttrs value, in that one should not accept a sequence of attributes to be signed from a third party. In fact, one should not accept attributes to be included in the signed attributes list from a third party. The attributes are about the signature you are applying and not about the body. If there is meta-information that needs to be attached to the body by a third party, then they need to provide their own signature and you need to add a countersignature. (Note: The fact that the signature is to be used as a countersignature is a piece of information that should be accepted, but it does not directly provide an attribute that is inserted in the signed attribute list.) 🫶

a) Alice can attack the hash. This requires a successful collision resistance attack.
b) Mallory can attack the hash. This requires a successful second preimage resistance attack.
c) Bob can attack the hash and Bob controls the value of the message digest attribute used. This case is analogous to the current attacks [ATTACK]. Bob can attack the hash value generated by Alice based on a prediction of the signed attributes and the hash algorithm Alice will be using to create the signature. If Bob successfully predicts these items, the attack requires a successful collision resistance attack. (It is expected that if Alice uses a keyed hashing function as part of the signature, this attack will be more difficult as Bob would have a harder time prediction the key value.) 🔐

It should be noted that both of these attacks are considered to be more difficult than the attack on the body, since more structure is designed into the data to be hashed than is frequently found in the body, and the data is shorter in length than that of the body 📏.

The successful prediction of the signing-time attribute is expected to be more difficult than with certificates, as the time would not generally be rounded ⏰. Time stamp services can make this more unpredictable by using a random delay before issuing the signature 🎲.

Allowing a third party to provide a hash value could potentially make an attack simpler when keyed hash functions are used, since there is more data that can be modified without changing the overall structure of the signed attribute structure 😬.

Authors' Addresses 🖊️

Sean Turner
IECA, Inc.
3057 Nutley Street, Suite 106
Fairfax, VA 22031
USA

EMail: turners@ieca.com


Jim Schaad
Soaring Hawk Consulting

EMail: jimsch@exmsft.com

📦 where this page comes from

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