Internet-Draft Identifying SCITT Signed Statements November 2026
Gruszka Expires 19 May 2027 [Page]
Workgroup:
Network Working Group
Internet-Draft:
draft-gruszka-scitt-statement-identification-04
Published:
Intended Status:
Informational
Expires:
Author:
K. Gruszka
b7n0de

Requirements and Test Cases for Identifying SCITT Signed Statements

Abstract

This document describes proposed requirements and test cases for identifying SCITT Signed Statements. It distinguishes reference matching from statement retrieval, signature verification, issuer authorization, and evidence of registration. It examines how alternative identification schemes treat changes to statement encodings and registration context. The requirements are input to technical discussion and do not represent working group consensus. This document does not define a common reference format, allocate a COSE header parameter, or establish a relationship vocabulary. Its examples illustrate selected properties rather than demonstrate interoperability between deployed transparency services.

Status of This Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on 19 May 2027.

▲

Table of Contents

1. Introduction

A Transparency Service in the Supply Chain Integrity, Transparency, and Trust (SCITT) architecture [RFC9943] registers Signed Statements and returns Receipts. Applications increasingly need to refer to a specific Signed Statement: an audit statement that refers to the statement it audited, a correction that refers to the statement it corrects, an evidence bundle that lists the statements it was built from. For such a reference to be usable, two implementations given the reference and a candidate statement must reach the same conclusion about whether they match.

This is harder than hashing some bytes. The same logical Signed Statement can be re-encoded, can gain or lose an unprotected header, and can be registered in more than one Transparency Service, each producing its own entry handle and Receipt. A reference that is meant to survive those changes must say exactly which differences preserve identity and which do not, and must be interpretable without first understanding the application payload of the statement that carries it.

The need is not specific to any one product. On 22 September 2026 one of the SCITT working group chairs asked on the scitt@ietf.org list, "On statement IDs please bring all requirements you may have for statement identification", and raised as an open question "whether or not the statement ID should be cryptographically derived from its log insertion or not" [SCITT-CHAIRS-20260922]. The chair added that it has "pros and cons" and "will need real engagement to get right". This document is input to that discussion.

This document states proposed requirements (Section 4), compares candidate identification objects (Section 5), and works through a small set of fully explained test cases (Section 6). It takes a position, independence of the reference-matching result from any particular registration, and argues it with use and trade-offs rather than asserting it as settled. It does not propose a wire format, a COSE header parameter, or a relationship vocabulary for standardization.

2. Conventions, Terminology and Scope

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

This document uses the SCITT terms Signed Statement, Transparency Service and Receipt as defined in [RFC9943]. It adds the following working terms and keeps them apart deliberately:

Statement reference:

Data that designates a target Signed Statement together with the rule by which a candidate is judged to be that target.

Identification scheme:

The rule a reference is read under: which bytes are covered, which differences preserve identity, and, for a digest-based scheme, the hash algorithm and the exact input bytes.

Reference matching:

The operation of deciding, given a reference and a candidate statement, whether the candidate is the reference's target under the named scheme.

Entry handle (Locator):

A Transparency-Service-local identifier of a registration, such as an entry identifier returned by an API [I-D.ietf-scitt-scrapi]. It locates an entry in one service; it is not a portable statement identity.

Registration evidence:

A Receipt [RFC9942] that a statement was registered. It is distinct from a reference match.

Matching a reference is not the same as retrieving a statement, verifying its signature, authorizing its Issuer, or proving it was registered. Keeping these apart is the central discipline of this document.

2.1. Relationship to existing SCITT work

This document is a requirements and test-case text, not a new mechanism. The following work is adjacent; the References identify the revisions used.

The architecture [RFC9943] defines the Signed Statement envelope: Section 6.1 requires CBOR tag 18, and Section 6.3 requires the unprotected header to be an empty map before a statement is included in a Statement Sequence. It defines the statement, not a portable identifier for one statement or the bytes a statement digest covers.

The Receipts document [RFC9942] defines Verifiable Data Structures and their proofs; its Section 4.4.1 gives the registration requirements for a VDS, and its Section 5.2.1 is the RFC9162_SHA256 Receipt of Inclusion. Identity through a Receipt is scoped to a log and a VDS construction, and Section 4.4.1 leaves each VDS to define its own encoding and proofs.

The payload-binding draft [I-D.mih-sokolov-scitt-payload-binding] gives, in its Section 9, a general typed-digest-reference information model (type, purpose, digest_alg, digest) in which a carried digest and a recomputed digest are comparable only under one established referenced-artifact digest context, and in Sections 6 and 8 a derived identifier and a statement-to-Receipt binding. This document asks the narrower question of the concrete context a SCITT Signed Statement reference needs.

The framing-space measurement [I-D.templeman-scitt-framing-space] re-emits one COSE_Sign1 object under six CBOR encoding freedoms: with or without tag 18, definite or indefinite length for the outer array and for the unprotected header map, and whole or chunked byte strings for the protected header, the payload and the signature. It reports 64 distinct octet sequences, 64 distinct digests over the transmitted octets and one Sig_structure for all of them; a stock decoder rejected none of them, and decoding and re-encoding changed 62 of them. Its Section 5 regards a digest over the transmitted octets as the appropriate choice and notes that a service can reproduce such a digest only if it keeps the octets it received rather than a re-serialization of them. The ToBeSigned rule of Section 5.1 gives one value for all 64 encodings, because they share one Sig_structure. The two rules identify different objects: a digest over the transmitted octets names one serialization, and SHA-256 over ToBeSigned names the signing input that the serializations share. This document selects neither (Section 10).

The protected-object-binding draft [I-D.nobuo-scitt-protected-object-binding] defines Statement References, Receipt References and Relationship Edges with an initial relationship vocabulary (for example describes, measures, authorizes, supersedes and revokes); it couples identification with that vocabulary, whereas this document keeps matching separate from the relationship it carries.

In SCRAPI [I-D.ietf-scitt-scrapi] Section 2.4, a GET on /entries/ followed by an EntryID answers with the Receipt (200), with 204 while registration is still running, or with 404; that EntryID is an API locator for one service, not a portable, registration-independent statement identity.

The SCITT charter (charter-ietf-scitt-01, last updated 2026-03-18, retrieved 2026-10-10) lists among its non-goals to "define data formats for payload content" and asks the group to "reuse existing work from IETF WGs such as COSE and RATS, as appropriate". Where a statement-identification requirement or a small profile belongs is itself an open question (Section 10).

3. Use Cases

The following cases need different identification properties; they motivate the requirements without selecting a scheme.

  1. Audit reference. An auditor registers a statement that refers to the statement it audited. A reader must match the reference to the audited statement even if the audited statement has since been re-registered elsewhere.

  2. Correction reference. An Issuer registers a later statement that corrects an earlier one, keeping the same subject. The subject groups the two; the reference must still select the specific earlier statement, not merely the subject.

  3. Offline evidence bundle. A bundle lists the statements it was built from and is checked by a relying party that holds the bytes but queries no service. Matching must not require a service round-trip.

  4. Cross-service presence. The same statement is registered in two Transparency Services. A reference that is meant to be portable must designate the same statement across both, distinguishing identity-bearing changes from encoding changes the scheme excludes.

4. Proposed Requirements

These requirements are proposed input, not working group consensus. They are taken from an existing requirements note (see Section 11) and are stated here with their differing roles made explicit: A1 and A2 are properties of a reference, A3 is a design position, A4 is its acceptance test, and A5 is a conditional dependency of schemes that rely on a Receipt, not a fifth independent rule on every reference.

The BCP 14 keywords in A1 to A5 address a future identification scheme or profile; they are not obligations this document places on an existing protocol. Where a requirement restates an existing obligation it says so and cites it: the CBOR tag 18 of [RFC9943] Section 6.1, the empty unprotected header of [RFC9943] Section 6.3, and the VDS registration requirements of [RFC9942] Section 4.4.1 are existing obligations this document relies on, not new ones.

4.1. A1. A reference has an unambiguous target and matching rule

Given a reference and a candidate Signed Statement, a verifier can decide whether they match under a named identification scheme. The scheme states which differences preserve identity, including differences in signatures, headers and encodings. For a digest-based scheme it also defines the hash algorithm, the input bytes, and their encoding. These definitions MAY be supplied by a profile rather than repeated in each reference.

The Issuer and Subject pair groups related statements but does not select an individual statement from that group ([RFC9943] Section 6 uses iss and sub to identify the Artifact; the architecture defines no statement identifier). Acceptance: two implementations using the same scheme agree on matching and non-matching candidate vectors; missing inputs or unsupported rules cannot produce a successful match; a ToBeSigned scheme must specify external_aad and the source of any detached payload.

4.2. A2. A reference can be read without interpreting the carrier's payload

A verifier can locate and interpret a reference without interpreting the application payload of the Signed Statement that carries it. Recomputing a target digest may still require the target's payload bytes; that is a property of the target, not of reading the reference from the carrier. This is a proposed scope choice: without it, extracting a reference could require payload-specific parsing or decryption of the carrier.

4.3. A3. Matching a statement reference is independent of registration

Proposed requirement: matching a reference to a candidate does not depend on registration with a particular Transparency Service or on a particular insertion event. Service-local entry handles and Receipts may coexist with the reference and may differ.

This is one proposed answer to that open question. It is a design position, argued from the offline-bundle and cross-service use cases, not a claim that a log-derived identifier cannot work. A log-dependent identifier does not by itself prevent offline verification when the needed bytes, keys and trust anchors are already held; the property asked for here is independence from the registration context, not offline capability in general (Section 5.2).

4.4. A4. Acceptance test for A3

Under the same identification scheme, registration in either of two Transparency Services preserves the identity A1 defines. The test must distinguish identity-bearing changes from changes the scheme explicitly excludes. Section 11 reports one local measurement with two implementations; one of them is an archived emulator whose receipts are not COSE Receipts, so it is not a test of two Transparency Services in the sense of A4. The illustrative cases of Section 6 apply local transformations that a registration may cause (an added unprotected parameter, C5; a changed outer encoding, C12) and show which leave the chosen identity unchanged. The tag-removal case (C9) is a negative format control, not evidence of successful registration in two services.

4.5. A5. Receipt-verification dependency

Where identification depends on a leaf hash or a Receipt, the selected Verifiable Data Structure specification MUST define the entry-to-leaf transformation, serialization and tree hashing sufficiently for independent implementations to reproduce the result. This is a dependency of such schemes and of interoperable Receipt verification, not a fifth independent requirement on every reference. [RFC9942] Section 4.4.1 states that "Each VDS specification applying for inclusion in this registry MUST define how to encode the VDS identifier and its Proof Types in CBOR" and that "Each specification MUST define how to produce and consume the supported Proof Types"; its Section 5.2.1 is the Receipt of Inclusion of the specific RFC9162_SHA256 construction, which begins "In a signed proof, the payload is the Merkle Tree root that corresponds to the log at size tree-size". Different VDS constructions differ in their leaf and node hashing (for example the 0x00/0x01 prefixes of [RFC9162] Section 2.1.1); that difference does not make either construction ambiguous. The illustrative cases in Section 6 do not test leaf hashing or Receipts.

5. Design Alternatives and Trade-offs

The central design decision is not the hash algorithm but the identification object: which differences count as identity-changing. The following is the authors' analysis of candidate objects; it is not a selection.

Table 1
Identification object Possible benefit Price to be settled
Whole transmitted object bytes Simple exact byte identity Transport or envelope changes produce different values even when other checks still pass
An explicitly defined canonical object encoding Equal treatment of selected encoding variants Extra rules, cost, and the risk of diverging normalization
The COSE signing input ToBeSigned Binds to the actually signed content and its signature context Does not itself identify the signature value or the unprotected envelope; external inputs must be available and fixed
The payload only Fits when the content, not the signed assertion, is meant Issuer, header and signature differences are not necessarily distinguished
A VDS leaf or service entry Close tie to a concrete registration Depends on the VDS construction or the service context

For COSE, [RFC9052] Section 4.3 (externally supplied data) and Section 4.4 (the Sig_structure) are the relevant definitions, and Section 9 constrains the CBOR encoding. A successful signature verification does not by itself fix which universal statement identity an application should use.

5.1. The ToBeSigned object, as used in the examples

The examples in Section 6 use SHA-256 over ToBeSigned, SHA-512 in C50, the Sig_structure ["Signature1", body_protected, external_aad, payload] of [RFC9052] Sections 4.4 and 9, with the payload embedded. As Section 9 of [RFC9052] requires, the Sig_structure is encoded with definite lengths and with each argument in its shortest form, whatever the encoding of the candidate. When the payload field of a candidate is nil, the detached payload supplied with the case takes its place, an empty one included, as for detached content in [RFC9052] Sections 4.1 and 4.2; a detached payload supplied for a candidate that carries a payload is not used (C1). The scheme names external_aad as an explicit input: it is the empty byte string unless a specific case states otherwise, and a case that signs over a non-empty external_aad lists those exact bytes (Appendix A) and applies them to both matching and signature verification. The body_protected value is the original protected-header byte string, not a decoded and re-encoded map. This object names a class of signed inputs: it excludes the signature value, the unprotected header and the outer wrapper, so changes confined to those parts preserve it, and it does not normalize the bytes inside the protected header or payload. It is used here as one illustrative rule. This document does not propose it as the statement identity defined by the architecture; [RFC9943] defines no such identity, and a later profile is free to choose a different object.

5.2. Offline is not the same as registration-independent (A3)

A scheme can be checked offline when the needed bytes, keys and trust assumptions are already held; a service-dependent identifier is not online merely because it is service-dependent. A3 therefore argues for independence from the registration context, not for a blanket impossibility of offline checking of other models.

5.3. Four identities

Four identities are kept apart in this document.

  1. The signing input, the ToBeSigned object of Section 5.1. The ToBeSigned scheme binds the protected header, the external_aad and the payload, embedded or supplied as a detached payload. Each enters ToBeSigned as a byte string with its length in the head of its encoding, so two different combinations of these inputs do not give the same ToBeSigned. It does not identify the signature value or the unprotected header.

  2. A particular signature instance, the signing input together with one signature value. No scheme of this document identifies it.

  3. The complete serialized COSE object, the exact octets of one COSE_Sign1. A digest over them identifies those octets only. It does not cover a detached payload or an external_aad supplied outside them, and it is not to be presented as identifying them.

  4. The signed statement together with the external content and context that a reference is meant to identify. This document defines no record that binds the whole object to its external inputs and leaves such a record out of scope. A separate document is planned to define such a record, with cases of its own. A scheme that defines one states which inputs it includes and which it excludes, and gives an encoding whose field boundaries keep different combinations of inputs from giving the same record.

5.4. Two digests over two named objects

The ledger measurement of Section 11 involves three objects of the same statement: the signing input of Section 5.1, the submitted bytes, and the representation included in the Statement Sequence. There the included representation had the unprotected header emptied, as [RFC9943] Section 6.3 requires, and the outer encoding rewritten, and its data-hash differed from SHA-256 over the submitted bytes in 39 of 62 rows. Two different digests over two named objects of the same statement describe a relation between those objects and are not by themselves an error. A scheme can state its identity-preserving differences as named transformations, such as a changed unprotected header or a rewritten outer encoding, as cases C5 and C12 show for the ToBeSigned rule. A difference that no named transformation explains is not read as a match. Whether and where a party that changes the representation, in particular a Transparency Service before inclusion, records what it changed and why is an open question (Section 10). This subsection adds no requirement.

6. Conformance and Illustrative Test Cases

Each check is reported on separate axes: ref_usable indicates whether the reference is well-formed and compatible with the named scheme; match is MATCH or NO_MATCH when the comparison can be completed, and INDETERMINATE when the reference is unusable or a required input is absent; sig_valid indicates whether the candidate's signature verifies under the stated key; and is_scitt indicates whether the candidate is a tagged COSE_Sign1 ([RFC9943] Section 6.1 requires CBOR tag 18). A match establishes none of signature validity, issuer trust, payload truth, or registration.

Three kinds of result are kept apart. A named scheme that a verifier does not implement is UNSUPPORTED, whatever the reference and the candidate: the verifier reports that and gives no axes, and it reports neither NO_MATCH nor an invalid signature for it; Table 2 and Appendix A.3 write UNSUPPORTED in place of the four axes (C15). A result is negative, NO_MATCH or sig_valid False, only where the check was performed and failed. A check that cannot be performed is not negative. The read check of the candidate is a check that is performed: a candidate that fails it is not the designated statement, so its match is NO_MATCH under a usable reference. An unusable reference prevents only the comparison: match is INDETERMINATE and sig_valid is still computed, as in C10, C13, C14 and C16. A missing input gives INDETERMINATE or None on the axes that need it, as stated below. The four axes stay separate in processing and in reporting: NO_MATCH says nothing about the signature, and MATCH says nothing about the signature or the Issuer.

For the cases of this document, a reference is the array [alg, scheme, digest] of Appendix A, with exactly these three elements. It is well-formed when alg is an integer (CBOR major type 0 or 1) that names a hash function in the COSE Algorithms registry, scheme is a text string, and digest is a byte string of that hash function's output length. For the cases of this document the hash functions are the eight with a fixed output length that [RFC9054] registers: -14 (SHA-1, 20 bytes), -15 (SHA-256/64, 8 bytes), -16 (SHA-256, 32 bytes), -17 (SHA-512/256, 32 bytes), -18 (SHAKE128, 32 bytes), -43 (SHA-384, 48 bytes), -44 (SHA-512, 64 bytes) and -45 (SHAKE256, 64 bytes). A reference whose alg names any other hash function is not well-formed for these cases. In this document SHA-256/64 is the first 8 bytes of the SHA-256 output, which [RFC9054] Section 3.2 calls a simple truncation, and SHA-512/256 is the function that Section 3.2 takes from FIPS 180-4, not a truncation of the SHA-512 output. A verifier of these cases implements the ToBeSigned scheme with alg -16 and with alg -44; of the other six hash functions the cases use only the output length, to decide whether a reference is well-formed. It is compatible with the named scheme when its alg and scheme equal those of the scheme. Any other reference has ref_usable False. In these cases the named scheme is the ToBeSigned scheme of Section 5.1, with alg -16 (SHA-256) and scheme "ToBeSigned", except in C10 and C50, where its alg is -44 (SHA-512), and in C15, where it is the scheme "WholeBytes" with alg -16, which this document does not define. The references of C10, C13 and C14 are therefore not usable. A reference is read as one CBOR data item with nothing after it (C16). It has to be well-formed and valid under [RFC8949] Section 5.3.1 by the same rules as the candidate below; a reference that is not has ref_usable False. Its deterministic encoding is not required.

A candidate is read as a COSE_Sign1 ([RFC9052] Section 4.2), bare or with tag 18: an array of exactly four elements: the protected header, a byte string that is empty or encodes one map; the unprotected header, a map; the payload, a byte string or nil; and the signature, a byte string. For these illustrative axes, this read check covers only the outer tag, the array shape, the stated element types and the basic CBOR validity rules below. It does not validate header labels or header parameter semantics. The is_scitt axis reports this structural check with tag 18, not complete conformance to the SCITT envelope profile. A bare COSE_Sign1 passes the read check, so its match is computed although it is not a SCITT Signed Statement (C9). The candidate and, when it is not empty, its protected header are each one CBOR data item that is well-formed and valid under [RFC8949] Section 5.3.1: every text string is valid UTF-8, and no map holds two keys that are equal under the key equivalence of [RFC8949] Section 5.6.1. Under it the integer 1 and true are two keys, the integer 1 and the floating-point value 1.0 are two keys, and 0.0 and -0.0 are one; two NaN values are one key if their significands are equal after both are zero-extended at the right to 64 bits; and arrays, maps and tagged values used as keys are equal if their elements, their pairs regardless of order, or their tag numbers and contents are equal. Whether the content of a tag inside the COSE_Sign1 is valid for that tag ([RFC8949] Section 5.3.2) is not checked; the data items inside a tag are checked like any other data item. The deterministic encoding is not required. CBOR::Core [I-D.rundgren-cbor-core] Section 2.2 decides both points the other way: it requires the deterministic encoding, rejects duplicate map keys, and compares keys by their deterministic encoding, so that 0.0 and -0.0 are two keys there. The cases of this document keep the key equivalence of [RFC8949] Section 5.6.1 and accept any encoding that is well-formed and valid. The CBOR working group's Common Deterministic Encoding [I-D.ietf-cbor-cde] also defines a deterministic encoding. Both documents are cited for information; the cases of this document depend on neither. A candidate that breaks any of this, for example with a text string that is not valid UTF-8 in either header, is not a statement: its is_scitt is False and its sig_valid is None, not evaluated; its match is NO_MATCH under a usable reference and INDETERMINATE under an unusable one (C17).

The sig_valid axis is computed with one rule for every case. n*P is the point P multiplied by the integer n. A is the 32-byte public key of the stated key, derived from its seed in Appendix A.2 as in [RFC8032] Section 5.1.5; R is the first and S the second 32 bytes of the 64-byte signature, S read as a little-endian integer; B' is the base point and L the order of B' ([RFC8032] Section 5.1); and ToBeSigned is the object of Section 5.1 of this document with the case's external_aad and payload. sig_valid is True if and only if all four rules hold:

  1. A and R are canonical encodings: decoding each as in [RFC8032] Section 5.1.3 succeeds.

  2. A and R have order L: L*A and L*R are the neutral element, and A and R are not the neutral element.

  3. S is below L.

  4. With k = SHA-512(R || A || ToBeSigned) read as a little-endian integer and reduced modulo L, the cofactorless equation S*B' = R + k*A holds. R enters the hash exactly as received, A as its 32-byte encoding.

After the candidate passes the read checks above, a signature that is not 64 bytes gives sig_valid False (C21). Otherwise, if the payload is absent and not supplied, or a case names an external_aad that is not supplied, there is no ToBeSigned and sig_valid is None, not evaluated (C8, C22). Otherwise, evaluate the four rules above.

The same missing input decides the match axis for a candidate that passes the read checks above. Under a usable reference, a detached payload that is not supplied for a candidate whose payload is nil, or an external_aad that a case names and that is not supplied, gives match INDETERMINATE (C8, C22). Neither is replaced by an empty byte string, and neither absence is reported as NO_MATCH.

Because A and R have order L, the cofactorless equation of rule 4 and the cofactored equation 8*S*B' = 8*R + 8*k*A of [RFC8032] Section 5.1.7 accept exactly the same signatures. This document defines individual verification only. A randomized batch result MUST NOT substitute for checking all four rules for each signature. Case C11 has an R of mixed order, for which the two equations differ; rule 2 refuses it before either is checked. The rule fixes the sig_valid axis of these cases only; the match axis does not depend on it.

Cases C18, C19 and C20 each have a signature that one of rules 1, 2 and 3 refuses. In C19 and C20 the equation of rule 4 holds, so a verifier that leaves out rule 2 or rule 3 gives sig_valid True where the profile gives False. In C18 the equation holds when R is read with y reduced modulo p; R is then the neutral element, which rule 2 refuses, so only a verifier that leaves out both rules 1 and 2 gives True. Appendix A.3 gives the measured results.

In every case A is the issuer key of Appendix A.2, derived from its seed; it is a canonical encoding of a point of order L, so no case exercises rules 1 and 2 for A. No case exercises a batch verification either; each case checks one signature.

The four rules are a verification profile of this document, named sid-ed25519-strict; a result states the profile under which its sig_valid was computed. Rules 1 and 3 follow the decoding of [RFC8032] Sections 5.1.3 and 5.1.7, and rule 4 uses the cofactorless equation that Section 5.1.7 allows in place of the cofactored one. Rule 2 is a restriction that [RFC8032] does not make. For C11 a verifier that follows Section 5.1.7 with the cofactored equation and without rule 2 gives sig_valid True, one that uses the cofactorless equation without rule 2 gives False, and the profile gives False because rule 2 refuses R before either equation is evaluated. The profile is a choice for these cases, so that every verifier that claims it gives one result; it does not bind an Ed25519 verifier that does not claim it. The match axis of C11 is MATCH in all three. The results that Appendix A.3 gives with a rule left out, for C11, C18, C19 and C20, describe verifiers that do not claim the profile; they are not results under it.

The cases use three synthetic signed statements about one subject and the reference between them, under the ToBeSigned scheme of Section 5.1. Each case is checked against the reference given in Appendix A.1, except C13, C14, C16, C24 to C29 and C49 to C51, which change the reference as Appendix A.3 states. The external_aad is the empty byte string in every case except C7, which states its bytes, and C22, which names the external_aad of C7 and does not supply it. A detached payload is supplied in C23 and in the variants of C1, C8 and C23 only. The bytes, or the changes that give them, the keys and the per-case results are in Appendix A; the keys are pure test keys. The fixtures use the fully specified Ed25519 algorithm (COSE algorithm -19); the source package uses EdDSA (-8). The identification rule is the same whatever the signature algorithm, but the alg of the protected header is part of ToBeSigned: the same statement signed again under -8 has another ToBeSigned and does not match a reference to its form under -19.

Table 2
ID Req ref_usable match is_scitt sig_valid What it shows
C1 A1 True MATCH True True positive control
C2 A1 True NO_MATCH True True subject grouping is not single identity
C3 A1 True NO_MATCH True True changed target payload
C4 A1 True NO_MATCH True True changed protected header
C5 A4 True MATCH True True added unprotected parameter (envelope)
C6 A1 True MATCH True False signature replaced, same signed input
C7 A1 True NO_MATCH True True non-empty external_aad
C8 A1 True INDETERMINATE True None detached payload not supplied
C9 A1 True MATCH False True tag 18 removed
C10 A1 False INDETERMINATE True True scheme/algorithm mismatch
C11 A1 True MATCH True False R of mixed order
C12 A4 True MATCH True True outer encoding changed, tag 18 kept
C13 A1 False INDETERMINATE True True 31-byte digest: not well-formed
C14 A1 False INDETERMINATE True True other scheme name: not compatible
C15 A1 UNSUPPORTED, no axes scheme not implemented
C16 A1 False INDETERMINATE True True byte after the reference
C17 A1 True NO_MATCH False None not a COSE_Sign1
C18 A1 True MATCH True False R not canonical (rule 1)
C19 A1 True MATCH True False R the neutral element (rule 2)
C20 A1 True MATCH True False S + L (rule 3)
C21 A1 True MATCH True False 63-byte signature
C22 A1 True INDETERMINATE True None named external_aad not supplied
C23 A1 True MATCH True True detached payload supplied
C24 A1 False INDETERMINATE True True reference not well-formed
C25 A1 False INDETERMINATE True True invalid UTF-8 in the reference
C26 A1 False INDETERMINATE True True reference of four elements
C27 A1 False INDETERMINATE True True alg as a float
C28 A1 False INDETERMINATE True True scheme as a byte string
C29 A1 False INDETERMINATE True True digest inside a tag
C30 A1 True NO_MATCH False None byte after the candidate
C31 A1 True NO_MATCH False None tag 17 in place of 18
C32 A1 True NO_MATCH False None protected header not a byte string
C33 A1 True NO_MATCH True True empty protected header
C34 A1 True NO_MATCH False None protected header not a map
C35 A1 True NO_MATCH False None two items in the protected header
C36 A1 True NO_MATCH False None unprotected header not a map
C37 A1 True NO_MATCH False None payload as a text string
C38 A1 True NO_MATCH False None signature inside a tag
C39 A1 True NO_MATCH False None invalid UTF-8, unprotected header
C40 A1 True NO_MATCH False None invalid UTF-8, protected header
C41 A1 True NO_MATCH False None two equal integer keys
C42 A1 True MATCH True True keys 1 and 1.0
C43 A1 True MATCH True True keys 1 and true
C44 A1 True NO_MATCH False None keys 0.0 and -0.0
C45 A1 True MATCH True True two NaN keys, other significands
C46 A1 True NO_MATCH False None two NaN keys, one significand
C47 A1 True NO_MATCH False None two equal array keys
C48 A1 True MATCH True True tag content not checked
C49 A1 False INDETERMINATE False None not a statement, unusable reference
C50 A1 True MATCH True True SHA-512 reference
C51 A1 True MATCH True True reference not deterministic
C52 A1 True NO_MATCH False None candidate not well-formed
C53 A1 True NO_MATCH False None two equal map keys
C54 A1 True NO_MATCH False None two equal tagged keys

The following cases illustrate the scope and limits of the chosen identity rule. Case C5 adds one unprotected parameter after signing: the ToBeSigned digest and the signature are unchanged while the whole-object digest changes, so a whole-bytes identifier and a ToBeSigned identifier disagree exactly where a registration may rewrite the envelope. Case C12 keeps tag 18 and every element of statement 01 and writes the head of the four-element array with a one-byte length argument (98 04 in place of 84), which is well-formed but not the preferred encoding: as in C5, the ToBeSigned reference matches and the signature verifies while the whole-object digest changes. C9 reports MATCH under the illustrative ToBeSigned rule and is_scitt = False because tag 18 is absent; it is a negative format control, not evidence of successful registration in two services. Case C8 withholds a detached payload: a missing input yields INDETERMINATE, never a match. Case C6 replaces the signature with one from another key over the same signing input: the ToBeSigned reference still matches, but the signature does not verify under the stated key, which is why the two axes are reported separately.

Cases C15 to C54 add cases for checks of this section. Table 3 lists every check of this section together with the cases that exercise it, and says why six checks have no case. The obligations that Sections 4.5, 7 and 8 and Appendix A place on other specifications, on relying parties and on producers of statements are not results of a verifier, and no case exercises them.

Table 3: Checks of this section and the cases that exercise them
Check Cases
Reference (ref_usable)
one well-formed CBOR data item C24
valid under RFC 8949 Section 5.3.1 C25 (UTF-8); two equal map keys could only stand in an element whose type already makes the reference not well-formed
nothing after the data item C16
an array of exactly three elements C26
alg is an integer C27
alg names one of the eight hash functions none: an alg outside this set cannot equal -16 or -44, the algorithms of the implemented named schemes used by these cases; C10 already exercises algorithm mismatch
scheme is a text string C28
digest is a byte string C29
digest has the output length of the hash function C13
alg equals that of the named scheme C10
scheme equals that of the named scheme C14
the deterministic encoding is not required C51
Candidate (is_scitt)
one well-formed CBOR data item C52
nothing after the data item C30
bare or with tag 18 C9 (bare), C31 (tag 17)
an array of exactly four elements C17
protected header is a byte string C32
protected header is empty or encodes one map C33 (empty), C34 (an array), C35 (two data items)
unprotected header is a map C36
payload is a byte string or nil C8 and C23 (nil), C37 (a text string)
signature is a byte string C38
text strings are valid UTF-8, in either header C39 (unprotected), C40 (protected)
no two map keys are equal under RFC 8949 Section 5.6.1 C41 (1 and 1), C42 (1 and 1.0), C43 (1 and true), C44 (0.0 and -0.0), C45 and C46 (NaN), C47 (arrays), C53 (maps), C54 (tags)
the content of a tag is not checked for that tag C48
header labels and header parameter semantics are not validated C42 (a label 1.0), C43 (a label true), C45 (two NaN labels)
the deterministic encoding is not required C12
Signature (sig_valid)
a signature that is not 64 bytes gives False C21
no ToBeSigned gives None C8, C22
rule 1 for R C18, whose R rule 2 refuses as well; no case can separate the two rules for R, because an R that only rule 1 refuses would encode a point r*B' with y below 19, and finding such an r is infeasible
rule 1 for A none: A is the issuer key of Appendix A.2 in every case
rule 2 for R C11 (mixed order), C19 (neutral element)
rule 2 for A none: A is the issuer key of Appendix A.2 in every case
rule 3 C20
rule 4, the cofactorless equation C6; C7 and C8 in their variants
a batch result does not replace the four rules none: each case checks one signature
Match (match)
the digest of ToBeSigned is compared with the reference C1 to C4, C7; C50 (SHA-512)
a missing input gives INDETERMINATE C8, C22
an unusable reference gives INDETERMINATE C10, C13, C14, C16, C24 to C29
a candidate that is not a statement C17 (usable reference), C49 (unusable reference)
a supplied detached payload takes the place of nil C23 and its variant
a supplied detached payload is not used when the payload is embedded the variant of C1
Result
a named scheme the verifier does not implement gives UNSUPPORTED C15
an empty check set is INDETERMINATE, not a match none: ref_usable and is_scitt are computed for every input under a scheme the verifier implements, so no case has an empty check set
a result states the profile under which its sig_valid was computed none: a case gives the expected axes, not the form of a report

An empty check set is not a PASS: a case under a scheme the verifier implements for which no axis could be evaluated is reported as INDETERMINATE, not as a match. A named scheme the verifier does not implement is UNSUPPORTED, as stated above.

No input of these cases is longer than 450 bytes. Counting the outermost data item as level 1, a data item inside a tag, array or map as one level deeper than it, and the contents of the protected header as one level deeper than its byte string, none nests deeper than seven levels. A verifier whose bounds on size and nesting (Section 7) admit inputs of that size and depth reads every case; its bounds then decide none of them.

7. Security Considerations

This section considers the attacker and the risks this work raises, in the spirit of [RFC3552]. A successful reference match is not a trust decision. It does not establish that the candidate's signature is valid, that its Issuer is authorized, that its payload is true, or that it was registered. Relying parties MUST keep these results separate and MUST NOT treat a match as any of them. Collapsing them into a single boolean is the main foreseeable misuse.

The identification object determines the attack surface. A whole-bytes identifier changes when the unprotected header or outer encoding is rewritten, so a party expecting stability may fail to match a legitimately re-registered statement. A ToBeSigned identifier is stable across such rewrites but, by construction, does not distinguish two objects that share a signing input and differ only in the signature value or unprotected header; a party that needs to pin the exact serialized object needs a whole-object identifier instead, which does not cover a detached payload or an external_aad (Section 5.3). A scheme MUST state external_aad and the source of any detached payload; a missing input MUST NOT silently become an empty input or a successful match, and a mismatch between a scheme's declared algorithm and a reference's algorithm MUST NOT fall back silently.

Tag discipline matters: a generic COSE_Sign1 without CBOR tag 18 is not a SCITT Signed Statement ([RFC9943] Section 6.1), and a test that drops the tag MUST NOT be presented as a valid SCITT case. A reference match under the ToBeSigned scheme shows only that the signing input of the candidate is that of the designated statement; it does not show that no newer relevant statement has appeared, so a reference match MUST NOT be read as current validity or as completeness of a history.

A verifier that recomputes a target digest reads externally supplied bytes; large, deeply nested, or cyclically referenced inputs can exhaust resources. An implementation should bound the input size and nesting it will process rather than hashing unbounded input, and should treat a set of references as a list to check, not a graph to traverse.

Digest-based identification depends on the collision and second-preimage resistance of the selected hash algorithm.

8. Privacy Considerations

A stable, portable reference is a correlator. The same identifier appearing in two contexts links them. Schemes and deployments SHOULD consider whether a reference needs to be stable across services at all, and whether salted or context-scoped references are more appropriate where linkage is a concern. The subject identifier in a statement groups statements about one Artifact and is itself a correlator independent of the reference scheme.

A digest is not by itself a confidentiality mechanism. When the covered content is drawn from a small or well-known set of possibilities, a party that holds the reference can confirm a guess by hashing each candidate and comparing, even if the target statement is never disclosed. A scheme that intends a reference to hide its target needs enough entropy in the covered content (for example a salt) that this guessing attack is infeasible.

9. IANA Considerations

This document has no IANA actions. It allocates no COSE header parameter and defines no registry. The COSE header label -70001 used by the examples in Appendix A is in the Private Use range of the COSE Header Parameters registry (integer values less than -65536); it is a local convention of the example package, not a requested or assigned value.

10. Open Questions

Concrete feedback is sought on the following.

  1. The identification object. Should a SCITT statement reference bind to ToBeSigned, to a canonical object encoding, to the whole object bytes, or to a VDS leaf; and should the choice be fixed by the architecture or left to profiles?

  2. Registration derivation. That open question stands: should a statement identifier be cryptographically derived from its log insertion, and what are the trade-offs against a registration-independent identifier (A3)?

  3. Venue. Whether statement-identification requirements, or a small profile, belong in the SCITT architecture, in a Receipts or payload-binding document, or in a separate document; the charter's payload-format non-goal (Section 2.1) bears on this.

  4. Relationship vocabulary. This document deliberately excludes one; whether the identification work needs any relationship terms at all is open.

  5. Recording a transformation. Whether and where a party that changes the representation of a statement, in particular a Transparency Service before inclusion, records what it changed and why (Section 5.4).

11. Implementation Status

This section is given per [RFC7942] and is to be removed by the RFC Editor before publication.

An open-source project, proofbundle, carries the requirements note this document is drawn from and a small synthetic example package, at commit eb1b7eeb28a4f77a4fe9fb1eadc21be0fb03746d (files docs/scitt/statement_identification/requirements.md and the package under docs/scitt/statement_identification/package/). That package signs three synthetic statements and checks the ToBeSigned references between them offline with a CBOR library and a general cryptography library. The illustrative examples here sign with the fully-specified Ed25519 algorithm -19 of [RFC9864]; the package at that commit uses EdDSA -8, which [RFC9864] lists as deprecated, and the ToBeSigned identification rule is the same for either algorithm, although the alg in the protected header is part of ToBeSigned (Section 6). The three example signatures were decoded and verified independently in this work by decoding the COSE_Sign1 with a CBOR library and verifying the Ed25519 signature over the Sig_structure with a general cryptography library. pycose 1.1.0, the COSE library present in the run environment, cannot decode algorithm -19; no other independent COSE library was available, so whether a second COSE library decodes and verifies -19 was not tested. The examples were generated and checked with cbor2 5.4.6 and cryptography 41.0.7. The illustrative cases of Section 6 and Appendix A were generated and checked in this work; the fixtures are synthetic and the keys are test keys.

On 2026-10-12, the checker of that package as merged into the main branch of proofbundle, at commit 3611eb73fca16cf68ef47af00fd5193f733bc552, was applied to cases C1 to C12 of Section 6 with the bytes of Appendix A: its own reading, ToBeSigned, signature and digest functions gave all four axes of the table for nine cases directly and for C10 with the scheme and the reference algorithm exchanged, because the package takes no scheme as input; it has no external_aad input and gives for C7 the result under the fixed empty external_aad rule that the case also records, and it refuses C8, whose payload is nil, as malformed. A further checker, written from the published text of this document alone, reproduced the four axes of 11 of the 12 cases directly and those of C10 in that mirrored form, as it also takes no scheme as input, and showed no deviation over 30237 generated inputs (measured on 2026-10-12).

A second reader of cases C1 to C14 was written by Toshikatsu Oga (The HORIZONs Co., Ltd.) from the text of draft-gruszka-scitt-statement-identification-03 alone, with the README of the case folder for its file format, and without reading or running the checker of that folder. It uses the Python standard library only, with its own CBOR reader and its own Ed25519 arithmetic after [RFC8032]. Its six files are kept unchanged, under the MIT licence, in the proofbundle repository at commit 19a4fffdda96c07a6c759b617edb195783baa89b, https://github.com/b7n0de/proofbundle/tree/19a4fffdda96c07a6c759b617edb195783baa89b/interop/scitt-statement-identification-03/independent/oga, next to the 14 case files and their checker. It agrees with the case files on 19 of 19 checks, cases C1 to C14 and their 5 variants, on every axis each one states. Two limits apply. This is a result on the published cases and says nothing beyond them. The reader was blind to the code of the repository, not to the expected axes, which are in Section 6 and Appendix A.3.

On 2026-11-12, the 988 single-byte mutants of statement 01 for which that reader gives its axes were run through the checker of the case folder at commit 82411560bb0c240c4cb9af8a6c08061789faeb64, with the reference, key and other inputs of C1. The two readers gave the same four axes for all 988. This compares two readers on single-byte changes of one statement and says nothing about other inputs.

This section keeps six levels of assurance apart: a defined reference identity rule (Sections 5.1 and 6), its demonstration through supplied cases (Section 6 and Appendix A), the implementation of the rule by a checker, the reproduction of the expected results from an identified source snapshot, interoperability between independent implementations, and the intended deployment and trust properties. Two readers that agree on the published cases are evidence for these cases at the second to fourth level only. A test between two independently developed Transparency Services has not been shown; it is open work (A4).

One own measurement motivates the choice of hash input under A1 and is reported here as a measured fact, not an endorsement. Against a locally run transparency ledger (microsoft/scitt-ccf-ledger at commit 00101f76, CCF 7.0.17), of 62 registered rows, 39 had a SHA-256 of the submitted bytes that differed from the data-hash in the returned Receipt, because the service sets the unprotected header to an empty map and rewrites the outer encoding before inclusion. This measurement shows why a reference scheme must specify whether it covers submitted bytes or the representation included in the Statement Sequence; it does not by itself show that the identifier depends on the service or insertion event. The corpus matrix is in the proofbundle repository at tools/scitt_ccf_external/differential_corpus_round3/README.md (freeze commit c5ff0a72e28aa087eecd3e2b426577be3cf2a80f) and the replay at tools/scitt_ccf_external/replay_earlier_build/results_table.md (commit 3ca368164b68a09a863f7ec12b2f9fa1b21123ec). Only the repository evidence is cited here.

A local check on 2026-10-12 used seven inclusion receipts and their Transparent Statements from three instances of the same ledger. Each receipt signature verified over the recomputed root with its corresponding service key and failed with the other two keys. In these inputs, data-hash was SHA-256 over the tagged COSE_Sign1 bytes with the unprotected header replaced by an empty map and the remaining bytes unchanged. It differed from the digest of the Transparent Statement and from that of the corresponding encoding without tag 18. Pull request 31 for the CCF Receipt profile, at revision d04ddffe [CCF-DATA-HASH], proposes this hash input and a comparison against the data-hash in each inclusion proof. That proposal is work in progress. These observations illustrate A1; they do not establish registration-independent identification or satisfy the two-service acceptance test of A4.

A second local measurement, on 2026-10-11, follows use case 4 with two implementations and no hosted service: the ledger above, and scitt-community/scitt-api-emulator at commit 6e6776070a1adf7298c9427871f15a8f087be73d, an archived emulator run in its CCF tree mode. Its dependency rkvst-archivist is no longer published; only its unused RKVST mode needs it, and the measurement replaced that import by a stub. The test statements were S, a COSE Hash Envelope with an X.509 chain and alg -7; S2, the ToBeSigned of S signed again; and S3, S with another sub. The ledger registered all three, and S a second time under another entry identifier. Each returned Transparent Statement kept the protected header, payload and signature of what was submitted, while its bytes differed. The ToBeSigned reference of Section 6 matched S, S2 and the second registration of S, and did not match S3. The emulator refused S, S2 and S3, because it requires a content type parameter (label 3) and a CWT Claims parameter under label 14. After the two required parameters had been added and the statements signed again, the emulator registered the adapted statements and returned each submitted byte sequence unchanged; its receipts are not COSE Receipts. For one statement registered at both implementations, the ToBeSigned reference was equal and the entry identifiers differed.

This information is given per [RFC7942] and does not constitute endorsement.

12. References

12.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC8032]
Josefsson, S. and I. Liusvaara, "Edwards-Curve Digital Signature Algorithm (EdDSA)", RFC 8032, , <https://www.rfc-editor.org/info/rfc8032>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC8949]
Bormann, C. and P. Hoffman, "Concise Binary Object Representation (CBOR)", STD 94, RFC 8949, , <https://www.rfc-editor.org/info/rfc8949>.
[RFC9052]
Schaad, J., "CBOR Object Signing and Encryption (COSE): Structures and Process", STD 96, RFC 9052, , <https://www.rfc-editor.org/info/rfc9052>.
[RFC9054]
Schaad, J., "CBOR Object Signing and Encryption (COSE): Hash Algorithms", RFC 9054, , <https://www.rfc-editor.org/info/rfc9054>.
[RFC9864]
Jones, M. B. and O. Steele, "Fully-Specified Algorithms for JSON Object Signing and Encryption (JOSE) and CBOR Object Signing and Encryption (COSE)", RFC 9864, , <https://www.rfc-editor.org/info/rfc9864>.
[RFC9943]
Birkholz, H., Delignat-Lavaud, A., Fournet, C., Deshpande, Y., and S. Lasker, "An Architecture for Trustworthy and Transparent Digital Supply Chains", RFC 9943, , <https://www.rfc-editor.org/info/rfc9943>.

12.2. Informative References

[CCF-DATA-HASH]
"Define data-hash preimage and require inclusion proof validation", pull request 31 in ietf-wg-scitt/draft-ietf-scitt-receipts-ccf-profile, revision d04ddffe, Work in Progress, accessed 12 October 2026, <https://github.com/ietf-wg-scitt/draft-ietf-scitt-receipts-ccf-profile/pull/31>, <https://github.com/ietf-wg-scitt/draft-ietf-scitt-receipts-ccf-profile/commit/d04ddffe>.
[I-D.ietf-cbor-cde]
Bormann, C., "CBOR Common Deterministic Encoding (CDE)", Work in Progress, Internet-Draft, draft-ietf-cbor-cde-13, , <https://datatracker.ietf.org/doc/draft-ietf-cbor-cde/13/>.
[I-D.ietf-scitt-scrapi]
Birkholz, H., Geater, J., and A. Delignat-Lavaud, "Supply Chain Integrity, Transparency, and Trust (SCITT) Reference APIs", Work in Progress, Internet-Draft, draft-ietf-scitt-scrapi-11, , <https://datatracker.ietf.org/doc/draft-ietf-scitt-scrapi/11/>.
[I-D.mih-sokolov-scitt-payload-binding]
Mih, S. and A. Sokolov, "Canonicalization Declaration for SCITT Signed Statements", Work in Progress, Internet-Draft, draft-mih-sokolov-scitt-payload-binding-06, , <https://datatracker.ietf.org/doc/draft-mih-sokolov-scitt-payload-binding/06/>.
[I-D.nobuo-scitt-protected-object-binding]
Aoki, N., "SCITT Statement Relationship and Protected Object Binding", Work in Progress, Internet-Draft, draft-nobuo-scitt-protected-object-binding-00, , <https://datatracker.ietf.org/doc/draft-nobuo-scitt-protected-object-binding/00/>.
[I-D.rundgren-cbor-core]
Rundgren, A., Ed., "CBOR::Core - CBOR Cross Platform Profile", Work in Progress, Internet-Draft, draft-rundgren-cbor-core-25, , <https://datatracker.ietf.org/doc/draft-rundgren-cbor-core/25/>.
[I-D.templeman-scitt-framing-space]
Templeman, N., "Measuring the CBOR Framing Space of COSE_Sign1 Data-Hash Pre-images", Work in Progress, Internet-Draft, draft-templeman-scitt-framing-space-01, , <https://datatracker.ietf.org/doc/draft-templeman-scitt-framing-space/01/>.
[RFC3552]
Rescorla, E. and B. Korver, "Guidelines for Writing RFC Text on Security Considerations", BCP 72, RFC 3552, , <https://www.rfc-editor.org/info/rfc3552>.
[RFC7942]
Sheffer, Y. and A. Farrel, "Improving Awareness of Running Code: The Implementation Status Section", BCP 205, RFC 7942, , <https://www.rfc-editor.org/info/rfc7942>.
[RFC9162]
Laurie, B., Messeri, E., and R. Stradling, "Certificate Transparency Version 2.0", RFC 9162, , <https://www.rfc-editor.org/info/rfc9162>.
[RFC9942]
Steele, O., Birkholz, H., Delignat-Lavaud, A., and C. Fournet, "CBOR Object Signing and Encryption (COSE) Receipts", RFC 9942, , <https://www.rfc-editor.org/info/rfc9942>.
[SCITT-CHAIRS-20260922]
Geater, J., "[SCITT] Re: SCITT WG: IETF 127 Agenda Planning", , <https://mailarchive.ietf.org/arch/msg/scitt/BPmxsdV7RDQx3qxgdCjOUwuFNZU/>.

Appendix A. Illustrative Test Cases: Bytes and Keys

All byte strings are hex. Each of the three base statements is a tagged COSE_Sign1 (first byte 0xd2, CBOR tag 18) signed with the fully-specified Ed25519 algorithm (COSE algorithm -19, [RFC9864]). The private-use label carries a list of references; in these examples the list holds exactly one, the array [-16, "ToBeSigned", digest], which references statement 01, and the digest is SHA-256 over the ToBeSigned of statement 01. The test keys are pure test keys given as fixed seeds and MUST NOT be used for any real statement.

A.1. Base statements and the reference

All three statements share the subject pkg:generic/example-widget@1.0.0. COSE header label -70001 (Private Use) carries a list of references; in these examples the list holds exactly one, [-16, "ToBeSigned", digest], which references statement 01, and its digest is SHA-256 over the ToBeSigned of 01.

  • Reference digest (SHA-256 over ToBeSigned of 01): c3f5f13764679b9f77918bb52782480bc222be5ae4bce37f51384a6b1faa9dbc

  • 01 ToBeSigned SHA-256: c3f5f13764679b9f77918bb52782480bc222be5ae4bce37f51384a6b1faa9dbc

Statement 01 (iss https://issuer.example; 330 bytes; SHA-256 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6):

d284587ba4013203706170706c69636174696f6e2f6a736f6e0458200e6e86cd
20c07df4e95cb4a07a286192d29fc74567b41e726f1c7f7bd202eb5b0fa30176
68747470733a2f2f6973737565722e6578616d706c65027820706b673a67656e
657269632f6578616d706c652d77696467657440312e302e30061a68ce7b20a0
58867b226172746966616374223a226578616d706c652d7769646765742d312e
302e302e7461722e677a222c226c6963656e7365223a224d4954222c22736861
323536223a223630376536633165366333356463633962373730646535646139
3262393639373034613336366434363839373261386235356431613063333264
623334613732227d58401fb31a6df345f1c1840d878bd4b4acedb6612956916e
4b4550c5b6479289ed36f41cb604c8ab743dc2eb9fbda7fecfb896b3d444ba30
e591e663093a4eeb8104

Statement 02 (iss https://auditor.example, refers to 01; 365 bytes; SHA-256 c4758ea9ae4d85461a93ee1dbb302fb698c922b1fbcb4139ebc706e3aeccbebd):

d28458aba50132036a746578742f706c61696e045820a2820b29631a0e52ec5d
be41f948a9e5725c6b8d8c0346bd3ef5483cab27de580fa3017768747470733a
2f2f61756469746f722e6578616d706c65027820706b673a67656e657269632f
6578616d706c652d77696467657440312e302e30061a68ce7b203a0001117081
832f6a546f42655369676e65645820c3f5f13764679b9f77918bb52782480bc2
22be5ae4bce37f51384a6b1faa9dbca058795468652061727469666163742064
696765737420696e20746865207265666572656e6365642073746174656d656e
7420776173207265636f6d707574656420616e64206d6174636865732e205468
697320617564697420636f7665727320746865207265666572656e6365642062
79746573206f6e6c792e0a5840702de547d0247fd14444d31f0130c7d9b16c01
68f43988c19320e5a6e37264c617a086d8a117a8c4e44ece4fe17da69ae2527d
b8cbb9a709be4a271047016b03

Statement 03 (iss https://issuer.example, refers to 01; 450 bytes; SHA-256 f5afbb3b0c7d822b00741e5eacd9128b723922bf3cad6ed5a3ab00e884b58e99):

d28458b0a5013203706170706c69636174696f6e2f6a736f6e0458200e6e86cd
20c07df4e95cb4a07a286192d29fc74567b41e726f1c7f7bd202eb5b0fa30176
68747470733a2f2f6973737565722e6578616d706c65027820706b673a67656e
657269632f6578616d706c652d77696467657440312e302e30061a68ce7b203a
0001117081832f6a546f42655369676e65645820c3f5f13764679b9f77918bb5
2782480bc222be5ae4bce37f51384a6b1faa9dbca058c97b2261727469666163
74223a226578616d706c652d7769646765742d312e302e302e7461722e677a22
2c226c6963656e7365223a224170616368652d322e30222c226e6f7465223a22
546865206c6963656e736520696e20746865207265666572656e636564207374
6174656d656e74207761732077726f6e672e222c22736861323536223a223630
3765366331653663333564636339623737306465356461393262393639373034
613336366434363839373261386235356431613063333264623334613732227d
584032cc26dcf624b14ff15e1f307898d9a287559ca388b78227283e4dee5fea
9b04a3fb86cf0b12d553b791a210bff7e7478efe147f99c05f69b0d11e6a0766
ae0b

A.2. Test keys

PURE TEST KEYS given as fixed seeds. They MUST NOT be used for any real statement.

issuer:

  • Ed25519 seed (hex, 32 bytes): 51bdccce75df50a4bcee21a2f730ccdcd4917a0a4d20dd2ab3d2e5ffad3f6fd3

  • kid (hex, SHA-256 of the SubjectPublicKeyInfo): 0e6e86cd20c07df4e95cb4a07a286192d29fc74567b41e726f1c7f7bd202eb5b

auditor:

  • Ed25519 seed (hex, 32 bytes): 2a8b1161e212cc24681c06e6d7486daa0910253e54903d41ae964aaee2bfc681

  • kid (hex, SHA-256 of the SubjectPublicKeyInfo): a2820b29631a0e52ec5dbe41f948a9e5725c6b8d8c0346bd3ef5483cab27de58

A.3. Cases

Each case below gives its candidate as a base statement of Appendix A.1 or as a stated change to one, together with the candidate's length and SHA-256, so that a reader can rebuild the exact bytes the case was run on and confirm them; a change that needs new signature bytes gives them in full. C13, C14, C16, C24 to C29 and C51 keep the candidate of C1 and give their changed reference in full; C15 keeps the candidate and the reference of C1 and names another scheme. C30 to C48 and C52 to C54 state their change to statement 01 as bytes at offsets counted from 0 in statement 01 as Appendix A.1 gives it; where a case names more than one change, every offset refers to statement 01 before any change. In every case the stated key of Section 6 is the issuer key of Appendix A.2, whose kid the protected header of statement 01 carries. The expected axes are in the table of Section 6; the measured axes are given here.

A.3.1. C1 (requirement A1)

Unchanged reference and candidate (the reference target 01).

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1.

Supplied together with a detached payload, for example 32 zero bytes, the candidate gives the same four axes: its payload field is not nil, so the supplied payload is not used (Section 5.1).

A.3.2. C2 (requirement A1)

Same issuer and subject, different statement (03): subject grouping does not select 01.

  • candidate SHA-256 (whole COSE_Sign1): f5afbb3b0c7d822b00741e5eacd9128b723922bf3cad6ed5a3ab00e884b58e99 (450 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = True, sig_valid = True

The candidate is statement 03 of Appendix A.1.

A.3.3. C3 (requirement A1)

Changed target payload (re-signed): ToBeSigned differs.

  • candidate SHA-256 (whole COSE_Sign1): 63723353fdf05662cfcc618e8b47fd4142dce4a71e84b61a6bdbdde988e837ab (339 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 with the license value "MIT" in its payload replaced by "BSD-3-Clause", the payload otherwise unchanged, signed again under the issuer key. Signature (hex):

a7cd3cb04606ed9a99f7105b489cd67f424fcc0993964eefc170600d37214794
ded3d2e84d1309727cb4a9d550ea0729af7a283453794ea2ad0d023d1e824307

A.3.4. C4 (requirement A1)

Changed protected header (content type), re-signed: ToBeSigned differs.

  • candidate SHA-256 (whole COSE_Sign1): 65eb1e45177add009aef819b438c910aae934c3a05b7966ef73614e11ff07bcc (330 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 with the content type, header parameter 3, "application/cbor" in place of "application/json", the protected header in the deterministic encoding, signed again under the issuer key. Signature (hex):

6e32c4cb930f0a80529f3c9494ddcf140e0cefa61d5e26a16f8959cbddd6dc3b
7555affb55bec79d8cef0a4d710cd16057aa364924e3e7867966bb03e5764c04

A.3.5. C5 (requirement A4)

Added one unprotected parameter after signing (tag 18 kept): ToBeSigned and signature unchanged, whole-object digest changes.

  • candidate SHA-256 (whole COSE_Sign1): fbab2b2b1c572ca374458ba2590fa5ca0da056a6ce47666f7220f1bca4250ab8 (355 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 with the unprotected header {-70002: "added after signing"}, encoded deterministically, in place of the empty map; its protected header, payload and signature are those of 01.

A.3.6. C6 (requirement A1)

Same ToBeSigned, signature replaced with one from a different key: matches the ToBeSigned reference, but does not verify under the issuer key.

  • candidate SHA-256 (whole COSE_Sign1): f8bf927260ae6d9c6edadeb79e0295e39dc30341b21b1a61d6cf31b35d778bf8 (330 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = False

The candidate is statement 01 with its signature replaced by this signature over the same Sig_structure under the auditor key (hex):

15d271c055a0f391bcec610607a951fa312ef917892ff6528dc362a074b63a48
67d95424ae1904e7b353bf11fb13e05a276032747c52d7db0ddb953f89e3c60e

A.3.7. C7 (requirement A1)

Target signed over a non-empty external_aad. The scheme applies the supplied AAD bytes (given below) to both reference matching and signature verification, so the empty-external_aad reference does not match while the signature verifies. The same candidate bytes under the fixed empty-external_aad rule are reported separately below. A missing external context is not assumed empty.

  • candidate SHA-256 (whole COSE_Sign1): 0a5390069e431e6dd83764ee276b28f69d34986a9e64d82f05ef3322bc66d61c (330 bytes)

  • external_aad (hex, 17 bytes): 6374783a6465706c6f796d656e742d3432

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = True, sig_valid = True

  • the same candidate bytes under the fixed empty external_aad rule: match = MATCH, sig_valid = False

The candidate is statement 01 signed again under the issuer key over the Sig_structure with the external_aad below; only the signature differs from 01. Signature (hex):

57a8f8450fa4e8449619d980fc34d38ad07f02f2c618029be54102abfe430f90
5522a26a4013dae2ed3e093f199e127dc8e1a558a071192eac406a813ab97f04

A.3.8. C8 (requirement A1)

Detached payload (payload field is nil) and the detached bytes are not supplied: the match is INDETERMINATE, never a success.

  • candidate SHA-256 (whole COSE_Sign1): 7ceb07265f8b803a1ff96924da0b3a48b8355ec9daed0a9a31cd36cddaf34fdb (195 bytes)

  • measured: ref_usable = True, match = INDETERMINATE, is_scitt = True, sig_valid = None

  • note: detached payload not supplied; a missing input is never a match

The candidate is statement 01 with its payload replaced by nil and its signature replaced by (hex):

efdb7c7670bd56d96454ded2a7d92934b75edc092e9e9538aa16dd088ab74c1d
2831555b36abf6f9c13549d25eb07951880731bf2b52acd42c4e98237bdbdb0e

These signature bytes were made under the issuer key over ["Signature1", body_protected, external_aad, payload] with an empty external_aad and nil as the payload. That array is not a Sig_structure of [RFC9052] Section 4.4, where the payload is a byte string; the case does not use the bytes, because with the payload absent and not supplied, sig_valid is not evaluated (Section 6).

Supplied with the payload of statement 01 as its detached payload, the candidate gives ref_usable = True, match = MATCH, is_scitt = True and sig_valid = False: its ToBeSigned is that of 01, which the signature bytes above were not made over, so rule 4 fails.

A.3.9. C9 (requirement A1/RFC9943-6.1)

Tag 18 removed, nothing else changed: the ToBeSigned digest still matches, but the object is not a tagged COSE_Sign1, so it is not a valid SCITT Signed Statement (RFC 9943 Section 6.1 requires tag 18).

  • candidate SHA-256 (whole COSE_Sign1): c205d745619c3087ad1f83f6c1f7883f4fff616f8f90ecbe64c4aa08854b28e6 (329 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = False, sig_valid = True

The candidate is statement 01 without its first byte, d2, the tag 18.

A.3.10. C10 (requirement A1)

The scheme names SHA-512 (-44), while the reference carries SHA-256 (-16), so ref_usable is False and match is INDETERMINATE; no fallback is performed.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = False, match = INDETERMINATE, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1.

A.3.11. C11 (requirement A1)

Statement 01 with its 64 signature bytes replaced: R is a canonical encoding of a point of mixed order, and S is below L. Rule 2 refuses R, so sig_valid is False while the ToBeSigned reference matches. With rule 2 left out, the cofactored equation holds and the cofactorless equation does not.

  • candidate SHA-256 (whole COSE_Sign1): d1e77e708d759c9b393e93708968887df1ef0e56872166877f68d4ff9e43afe1 (330 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = False

  • with rule 2 left out: the cofactorless equation gives sig_valid = False, the cofactored equation gives sig_valid = True

The candidate is statement 01 with its 64 signature bytes replaced by (hex):

9599999999999999999999999999999999999999999999999999999999999999
2d5ac5acb4933c1790098a56557795abf48a9f65f4636552659e0a89d2a3110d

A.3.12. C12 (requirement A4)

Statement 01 with the head of its four-element array written with a one- byte length argument (98 04 in place of 84), tag 18 kept and every element unchanged: the outer encoding changes, ToBeSigned and signature do not, and the whole-object digest changes.

  • candidate SHA-256 (whole COSE_Sign1): f868bef38c6bf945c845b1dd327bc82b0cd71493b68fe4c11761fde6f4f6d988 (331 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 with the head of its array, the byte 84 after the tag, written as the two bytes 98 04.

A.3.13. C13 (requirement A1)

The reference is that of Appendix A.1 with the last byte of its digest removed. Its alg, -16, names SHA-256, whose output is 32 bytes, so a digest of 31 bytes makes the reference not well-formed: ref_usable is False and match is INDETERMINATE. The 31 bytes are not compared with a part of the computed digest.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = False, match = INDETERMINATE, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1. The reference, encoded as in statements 02 and 03, is (46 bytes, hex):

832f6a546f42655369676e6564581fc3f5f13764679b9f77918bb52782480bc2
22be5ae4bce37f51384a6b1faa9d

A.3.14. C14 (requirement A1)

The reference is that of Appendix A.1 with the scheme "WholeBytes" in place of "ToBeSigned". It is well-formed, but its scheme is not that of the named scheme, so it is not compatible: ref_usable is False and match is INDETERMINATE. No fallback to another scheme is performed.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = False, match = INDETERMINATE, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1. The reference, encoded as in statements 02 and 03, is (47 bytes, hex):

832f6a57686f6c6542797465735820c3f5f13764679b9f77918bb52782480bc2
22be5ae4bce37f51384a6b1faa9dbc

A.3.15. C15 (requirement A1)

The named scheme is the scheme "WholeBytes" with alg -16, which this document does not define. A verifier of these cases does not implement it, so the result is UNSUPPORTED: it gives no axes, neither NO_MATCH nor an invalid signature.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: UNSUPPORTED, no axes

The candidate is statement 01 of Appendix A.1, as in C1, and the reference is that of Appendix A.1.

A.3.16. C16 (requirement A1)

The reference is that of Appendix A.1 followed by the one byte 00. A reference is one CBOR data item with nothing after it, so this reference is not usable: ref_usable is False and match is INDETERMINATE, while the signature is still verified.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = False, match = INDETERMINATE, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1. The reference, the 47 bytes of the reference of Appendix A.1 followed by the one byte 00, is (48 bytes, hex):

832f6a546f42655369676e65645820c3f5f13764679b9f77918bb52782480bc2
22be5ae4bce37f51384a6b1faa9dbc00

A.3.17. C17 (requirement A1)

Statement 01 as an array of three elements, its signature removed: the candidate is not a COSE_Sign1, so is_scitt is False and sig_valid is None, and under the usable reference match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): e93f290f6b71e86a570f32f20dcf2c20440f6e090c9e0dc017a971abdc6f8ef7 (264 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the head of its array, the byte 84 after the tag, written as 83, and its last element, the signature, removed.

A.3.18. C18 (requirement A1)

Statement 01 with new signature bytes whose R is the 32-byte little-endian encoding of y = p + 1, with the sign bit 0. Decoding R as in [RFC8032] Section 5.1.3 fails because y is not below p, so rule 1 refuses R: sig_valid is False while the ToBeSigned reference matches. S is chosen with the issuer key so that S*B' = k*A, with k computed as in rule 4 from R as received.

  • candidate SHA-256 (whole COSE_Sign1): 9fa00f051c73affe2ad58f96a335f199a70d4a66ba5e3bb6ad5c4e637dacff59 (330 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = False

  • with rules 1 and 2 left out and y reduced modulo p: R is the neutral element and the cofactorless equation holds

The candidate is statement 01 with its 64 signature bytes replaced by (hex):

eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f
55b023c0909a754a8467372b761ea295fd1f62910a47e266e19753c1ab4af70f

A.3.19. C19 (requirement A1)

Statement 01 with new signature bytes whose R is the canonical encoding of the neutral element, the byte 01 followed by 31 zero bytes, and whose S is chosen with the issuer key so that S*B' = k*A, with k computed as in rule 4. The cofactorless and the cofactored equation both hold, but rule 2 refuses R, so sig_valid is False while the ToBeSigned reference matches.

  • candidate SHA-256 (whole COSE_Sign1): 0e8edfa53b935b47bb0c5b6bf3bf0246ee8c2177f38c06a08fb0f35ba60b2754 (330 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = False

  • with rule 2 left out: the cofactorless equation gives sig_valid = True, the cofactored equation gives sig_valid = True

The candidate is statement 01 with its 64 signature bytes replaced by (hex):

0100000000000000000000000000000000000000000000000000000000000000
53ec0c3dfc2c0675a049a67f326adbe3acf48e7afda5c541b656b670393d8909

A.3.20. C20 (requirement A1)

Statement 01 with S replaced by S + L, R unchanged. Because L*B' is the neutral element, the equation of rule 4 still holds, but rule 3 refuses S, so sig_valid is False while the ToBeSigned reference matches.

  • candidate SHA-256 (whole COSE_Sign1): 12ab3564205c348655ea8386430517cd25d56d5b634748e50056eebb9a1fc733 (330 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = False

  • with rule 3 left out: sig_valid = True

The candidate is statement 01 with the second 32 bytes of its signature, S read as a little-endian integer, replaced by S + L, so that its 64 signature bytes are (hex):

1fb31a6df345f1c1840d878bd4b4acedb6612956916e4b4550c5b6479289ed36
e1f0ab61e20e87959888976086f8aecd96b3d444ba30e591e663093a4eeb8114

A.3.21. C21 (requirement A1)

Statement 01 with a signature of 63 bytes: a signature that is not 64 bytes gives sig_valid False, while the ToBeSigned reference matches.

  • candidate SHA-256 (whole COSE_Sign1): 038bee2747145c0d7abfe7556a49265295686e82ba8cc879aad41c100d44512c (329 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = False

The candidate is statement 01 with its signature replaced by its first 63 bytes.

A.3.22. C22 (requirement A1)

The candidate of C7, signed over the external_aad that C7 states, with that external_aad named and not supplied. There is no ToBeSigned, so match is INDETERMINATE and sig_valid is None; the missing external_aad is not replaced by an empty byte string.

  • candidate SHA-256 (whole COSE_Sign1): 0a5390069e431e6dd83764ee276b28f69d34986a9e64d82f05ef3322bc66d61c (330 bytes)

  • measured: ref_usable = True, match = INDETERMINATE, is_scitt = True, sig_valid = None

The candidate is that of C7. The case names the external_aad of C7 and does not supply it.

A.3.23. C23 (requirement A1)

Statement 01 with its payload replaced by nil and the payload of 01 supplied as the detached payload: ToBeSigned is that of 01, so the reference matches and the signature of 01 verifies.

  • candidate SHA-256 (whole COSE_Sign1): 347983cb1677bfec025892ba5e04b222476ffacd67b66b7abefae62276030efa (195 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = True

  • with an empty detached payload: ref_usable = True, match = NO_MATCH, is_scitt = True, sig_valid = False

The candidate is statement 01 with its payload replaced by nil; its protected header, unprotected header and signature are those of 01. The detached payload supplied with it is the payload of statement 01 (134 bytes).

A.3.24. C24 (requirement A1)

The reference of Appendix A.1 as an array of indefinite length whose break byte is missing. The reference is therefore not well-formed CBOR: ref_usable is False and match is INDETERMINATE. A reader that ends the array at the end of the data would find a usable reference.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = False, match = INDETERMINATE, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1. The reference is the reference of Appendix A.1 with the 1 byte at offset 0, 83, replaced by the 1 byte 9f (47 bytes, hex):

9f2f6a546f42655369676e65645820c3f5f13764679b9f77918bb52782480bc2
22be5ae4bce37f51384a6b1faa9dbc

A.3.25. C25 (requirement A1)

The reference of Appendix A.1 with the byte ff appended to its scheme text. The text string is not valid UTF-8, so the reference is not valid under RFC 8949 Section 5.3.1: ref_usable is False and match is INDETERMINATE. A reader that drops the invalid byte would see "ToBeSigned".

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = False, match = INDETERMINATE, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1. The reference is the reference of Appendix A.1 with the 1 byte at offset 2, 6a, replaced by the 1 byte 6b, and the 1 byte ff inserted at offset 13 (48 bytes, hex):

832f6b546f42655369676e6564ff5820c3f5f13764679b9f77918bb52782480b
c222be5ae4bce37f51384a6b1faa9dbc

A.3.26. C26 (requirement A1)

The reference of Appendix A.1 as an array of four elements, with null after the digest. A reference has exactly three elements, so ref_usable is False and match is INDETERMINATE.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = False, match = INDETERMINATE, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1. The reference is the reference of Appendix A.1 with the 1 byte at offset 0, 83, replaced by the 1 byte 84, and the 1 byte f6 inserted at offset 47 (48 bytes, hex):

842f6a546f42655369676e65645820c3f5f13764679b9f77918bb52782480bc2
22be5ae4bce37f51384a6b1faa9dbcf6

A.3.27. C27 (requirement A1)

The reference of Appendix A.1 with its alg written as the half-precision float -16.0. The alg of a reference is an integer, so ref_usable is False and match is INDETERMINATE, although -16.0 is numerically equal to -16.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = False, match = INDETERMINATE, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1. The reference is the reference of Appendix A.1 with the 1 byte at offset 1, 2f, replaced by the 3 bytes f9cc00 (49 bytes, hex):

83f9cc006a546f42655369676e65645820c3f5f13764679b9f77918bb5278248
0bc222be5ae4bce37f51384a6b1faa9dbc

A.3.28. C28 (requirement A1)

The reference of Appendix A.1 with its scheme written as a byte string of the same ten bytes. The scheme of a reference is a text string, so ref_usable is False and match is INDETERMINATE.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = False, match = INDETERMINATE, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1. The reference is the reference of Appendix A.1 with the 1 byte at offset 2, 6a, replaced by the 1 byte 4a (47 bytes, hex):

832f4a546f42655369676e65645820c3f5f13764679b9f77918bb52782480bc2
22be5ae4bce37f51384a6b1faa9dbc

A.3.29. C29 (requirement A1)

The reference of Appendix A.1 with its digest enclosed in tag 2. The digest of a reference is a byte string, and a tagged byte string is not one, so ref_usable is False and match is INDETERMINATE.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = False, match = INDETERMINATE, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1. The reference is the reference of Appendix A.1 with the 1 byte c2 inserted at offset 13 (48 bytes, hex):

832f6a546f42655369676e6564c25820c3f5f13764679b9f77918bb52782480b
c222be5ae4bce37f51384a6b1faa9dbc

A.3.30. C30 (requirement A1)

Statement 01 followed by one byte 00. A candidate is one CBOR data item with nothing after it, so this candidate is not a statement: is_scitt is False, sig_valid is None, and under the usable reference match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 3e240a4958ab3d2f76d1f1e3459b26c8e1a483eccd5d8c9417cd50dbdf761cea (331 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte 00 inserted at offset 330.

A.3.31. C31 (requirement A1)

Statement 01 with tag 17 in place of tag 18. A candidate is bare or carries tag 18, so this candidate is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 692b39d654f222c856ea7339c87b270bdc65ccedc390a38d4508f5a7c3f8f3cf (330 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 0, d2, replaced by the 1 byte d1.

A.3.32. C32 (requirement A1)

Statement 01 with the head of its protected header removed, so that the header map stands in place of the byte string. The protected header of a candidate is a byte string, so this candidate is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): f6cb7b0bc3e82edaade68a8a784c0229c9bf7f8f8cece1e0ab577971cbd60066 (328 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 2 bytes at offset 2, 587b, removed.

A.3.33. C33 (requirement A1)

Statement 01 with an empty protected header, signed again under the issuer key. An empty protected header is allowed, so the candidate is a statement and its signature verifies, while its ToBeSigned differs from that of 01 and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 2d0fb6e6ccc7375c85f9f476d90cfad7fe308db74d681747a8a9526f692c4914 (206 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 with the 125 bytes at offset 2 replaced by the 1 byte 40. Its 64 signature bytes are then replaced by a signature under the issuer key over its ToBeSigned (hex):

b112d5a29033a656b5a1234df11edbba3f3ab754a5fbb23c1a60528963c6fa9a
2ab8edd4a0e94109ad24906b19e42c13d72540b79c3a89ead7ae3bcf1d5fe50b

A.3.34. C34 (requirement A1)

Statement 01 with a protected header that encodes an empty array. The protected header of a candidate is empty or encodes one map, so this candidate is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): c12a7646b4a7e328072824f77265c986e7af2ec052f38df704ba25b9e655e7c5 (207 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 125 bytes at offset 2 replaced by the 2 bytes 4180.

A.3.35. C35 (requirement A1)

Statement 01 with the byte 00 appended to the contents of its protected header, which then encode two data items. The protected header of a candidate encodes one map and nothing after it, so this candidate is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 507dda35f8d7f07522141a42f9afdc35dedc75c4f4c467e11f212e6b5abb7253 (331 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 2 bytes at offset 2, 587b, replaced by the 2 bytes 587c, and the 1 byte 00 inserted at offset 127.

A.3.36. C36 (requirement A1)

Statement 01 with an empty array in place of its unprotected header. The unprotected header of a candidate is a map, so this candidate is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): e883588345c587c807569f3e8a8e2c4c965e95d6522065d21760254e89df6dd5 (330 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 1 byte 80.

A.3.37. C37 (requirement A1)

Statement 01 with its payload written as a text string of the same bytes. The payload of a candidate is a byte string or nil, so this candidate is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 50334ddd13c606869ae090ac949e0979d0db9d9d251daa820654da3991a520fa (330 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 128, 58, replaced by the 1 byte 78.

A.3.38. C38 (requirement A1)

Statement 01 with its signature enclosed in tag 2. The signature of a candidate is a byte string, and a tagged byte string is not one, so this candidate is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): be9dea61106eb236d02d2bb381f9e5b6f2e097fb61c1f8be38c09755299c48e6 (331 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte c2 inserted at offset 264.

A.3.39. C39 (requirement A1)

Statement 01 with the unprotected header {-70002: text}, where the text is the one byte ff, which is not valid UTF-8. The candidate is therefore not valid, and not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 4939091506e6f12cc2f79f55f59d9521b120d74df66c02d51e49d365f6a87a81 (337 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 8 bytes a13a0001117161ff.

A.3.40. C40 (requirement A1)

Statement 01 with the last byte of the content type "application/json" in its protected header replaced by ff, which makes the text string not valid UTF-8. The protected header is therefore not valid, and the candidate is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 34b0034951bacf7cd8cd1ae4dee0ff0209226033d3f95a3018a5e263eeae2cf6 (330 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 24, 6e, replaced by the 1 byte ff.

A.3.41. C41 (requirement A1)

Statement 01 with the unprotected header {1: 0, 1: 0}. The map holds two equal keys, so the candidate is not valid and not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 1d707343f23ca681436e6a8864decdfed235d3d9c6c0371efbc18c075d0346ba (334 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 5 bytes a201000100.

A.3.42. C42 (requirement A1)

Statement 01 with the unprotected header {1: 0, 1.0: 0}, 1.0 as a half-precision float. An integer and a floating-point value are distinct keys, so the candidate is a statement: the reference matches and the signature verifies.

  • candidate SHA-256 (whole COSE_Sign1): 3c2d77cab18554bc03b7ecd4b5c651a3859afd1fdd4c8ddd626588eccc8e808f (336 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 7 bytes a20100f93c0000.

A.3.43. C43 (requirement A1)

Statement 01 with the unprotected header {1: 0, true: 0}. The integer 1 and true are distinct keys, so the candidate is a statement: the reference matches and the signature verifies.

  • candidate SHA-256 (whole COSE_Sign1): 7a9f8dc2a4fe2dc440dbb9e88e8ef90548069aedeeb41619a95ea2aefb552eab (334 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 5 bytes a20100f500.

A.3.44. C44 (requirement A1)

Statement 01 with the unprotected header {0.0: 0, -0.0: 0}, both half-precision floats. 0.0 and -0.0 are one key, so the map holds two equal keys and the candidate is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 873a50d499d9579ff016c314f4279b9394cc2301a1d70e3fab875fa4d3d16e12 (338 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 9 bytes a2f9000000f9800000.

A.3.45. C45 (requirement A1)

Statement 01 with an unprotected header of two half-precision NaN keys whose significands differ, f9 7e00 and f9 7e01. They are distinct keys, so the candidate is a statement: the reference matches and the signature verifies.

  • candidate SHA-256 (whole COSE_Sign1): ea1104aaebfb99905e414ecfc8f58b8301d4887984960365db5e92a10084b9b7 (338 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 9 bytes a2f97e0000f97e0100.

A.3.46. C46 (requirement A1)

Statement 01 with an unprotected header of two NaN keys, the half-precision f9 7e00 and the single-precision fa 7fc00000, whose significands are equal after both are zero-extended at the right to 64 bits. They are one key, so the map holds two equal keys and the candidate is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 02661d39fbc6d9d2cec8c9e897cac75469fb6a6cfe8e66a270bd439aa35162c5 (340 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 11 bytes a2f97e0000fa7fc0000000.

A.3.47. C47 (requirement A1)

Statement 01 with the unprotected header {[1]: 0, [1]: 0}. Two arrays with equal elements are equal keys, so the candidate is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): c50acc50b04489eaea57e36c00dd6d0b9f858ff264ec691047422192a7e31873 (336 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 7 bytes a2810100810100.

A.3.48. C48 (requirement A1)

Statement 01 with the unprotected header {-70002: 1("x")}, tag 1 around a text string, which is not valid content for tag 1. Whether the content of a tag is valid for that tag is not checked, so the candidate is a statement: the reference matches and the signature verifies.

  • candidate SHA-256 (whole COSE_Sign1): 5e910fd4676c445dee82621a14d8f89811f17336280f63038cc8bccc6c11c791 (338 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 9 bytes a13a00011171c16178.

A.3.49. C49 (requirement A1)

The candidate of C17, which is not a statement, under the reference of C13, which is not well-formed. Under an unusable reference match is INDETERMINATE, not NO_MATCH; is_scitt is False and sig_valid is None.

  • candidate SHA-256 (whole COSE_Sign1): e93f290f6b71e86a570f32f20dcf2c20440f6e090c9e0dc017a971abdc6f8ef7 (264 bytes)

  • measured: ref_usable = False, match = INDETERMINATE, is_scitt = False, sig_valid = None

The candidate is that of C17, and the reference is that of C13.

A.3.50. C50 (requirement A1)

The ToBeSigned scheme with alg -44 (SHA-512) and a reference whose digest is SHA-512 over the ToBeSigned of statement 01. The reference is usable, the digests are equal, and the signature verifies.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1. The named scheme is the ToBeSigned scheme with alg -44. The reference, [-44, "ToBeSigned", digest] with SHA-512 over the ToBeSigned of statement 01 as its digest, is (80 bytes, hex):

83382b6a546f42655369676e6564584006b15f9394faa354ef476ad832429fc7
93b6371261264ef4e3dcd22ac01378a4da24bf58b43706a17ecff8cf9a45c8fd
602e69927b80b8510ad2cd739e2119cd

A.3.51. C51 (requirement A1)

The reference of Appendix A.1 with the head of its array written with a one-byte length argument, 98 03 in place of 83. The deterministic encoding of a reference is not required, so the reference is usable: the reference matches and the signature verifies.

  • candidate SHA-256 (whole COSE_Sign1): 9c7253617b9fe51ba25eb0f957dadea493ca03e98c4a81806237757f13d054c6 (330 bytes)

  • measured: ref_usable = True, match = MATCH, is_scitt = True, sig_valid = True

The candidate is statement 01 of Appendix A.1, as in C1. The reference is the reference of Appendix A.1 with the 1 byte at offset 0, 83, replaced by the 2 bytes 9803 (48 bytes, hex):

98032f6a546f42655369676e65645820c3f5f13764679b9f77918bb52782480b
c222be5ae4bce37f51384a6b1faa9dbc

A.3.52. C52 (requirement A1)

Statement 01 with the head of its array, 84, replaced by 9f, the head of an array of indefinite length, and no break byte at its end. The candidate is not well-formed CBOR, so it is not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH. A reader that ends the array at the end of the data would find statement 01.

  • candidate SHA-256 (whole COSE_Sign1): 432f9cd95bfadbca540e3a86ec01db1eacfab275fbf10b2f2d52d49c63843c5a (330 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 1, 84, replaced by the 1 byte 9f.

A.3.53. C53 (requirement A1)

Statement 01 with an unprotected header whose two keys are the maps {1: 2, 3: 4} and {3: 4, 1: 2}. Two maps with the same pairs are equal keys regardless of order, so the candidate is not valid and not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 91f2f491e7807b5e2af38f522803ea31cf2656254099f05df543dd43e445f9e4 (342 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 13 bytes a2a20102030400a20304010200.

A.3.54. C54 (requirement A1)

Statement 01 with an unprotected header whose two keys are tag 1 around the integer 0, once encoded as c1 00 and once as c1 18 00. Two tagged values with the same tag number and equal contents are equal keys, so the candidate is not valid and not a statement: is_scitt is False, sig_valid is None and match is NO_MATCH.

  • candidate SHA-256 (whole COSE_Sign1): 94b724c635a5c06e263ffb63c3c4409a989e6f2a578643ae3788ced8a07fd6c8 (337 bytes)

  • measured: ref_usable = True, match = NO_MATCH, is_scitt = False, sig_valid = None

The candidate is statement 01 with the 1 byte at offset 127, a0, replaced by the 8 bytes a2c10000c1180000.

Acknowledgments

The author used AI tools to help draft this document and to generate and cross-check its examples. The author reviewed the entire text and is responsible for it.

Citing adjacent work in the References does not imply that its authors endorse this document.

Provenance

The requirements in Section 4 are drawn from the requirements note at the commit cited in Section 11. The illustrative cases in Appendix A were generated for this document; Section 11 separately identifies the sources of the reported measurement.

Changes (to be removed before publication)

Since draft-gruszka-scitt-statement-identification-03

  • Section 5.3 keeps four identities apart: the signing input, a particular signature instance, the complete serialized COSE object, and the statement together with its external content and context. A record that binds the whole object to its external inputs is left out of scope and planned as a separate document.

  • Section 5.4 states that two digests over two named objects of the same statement describe a relation, not an error, and Section 10 adds the question whether and where a party that changes the representation records what it changed.

  • Section 6 keeps UNSUPPORTED, negative and INDETERMINATE results apart.

  • Section 6 names the eight hash functions with a fixed output length of [RFC9054] that a well-formed reference can name.

  • Section 6 states that the validity rules of [RFC8949] Section 5.3.1 apply to the reference as to the candidate.

  • Section 6 states how integer and floating-point keys, NaN keys and compound keys compare under [RFC8949] Section 5.6.1, how SHA-256/64 and SHA-512/256 are read, which hash functions a verifier of the cases implements, the largest size and depth of a case input, and that a result with a rule left out is not a result under the profile. Section 5.1 states the encoding of the Sig_structure.

  • Section 6 states which verifier, leaving out which rule, gives another result for C18 to C20, and that no case exercises rules 1 and 2 for A or a batch verification.

  • Section 6 says that the read check of the candidate is a performed check, so that a candidate that fails it gives NO_MATCH under a usable reference, and that a reference whose alg names a hash function outside the eight is not well-formed for these cases.

  • Section 6 says that the alg of the protected header is part of ToBeSigned, so that the identification rule does not depend on the signature algorithm while a statement signed under another alg has another reference.

  • Cases C24 to C54 are added for checks of Section 6: the form, validity and encoding of a reference, the form and validity of a candidate and its headers, the equivalence of map keys, a tag whose content is not checked, a candidate that is not a statement under an unusable reference, and a reference under SHA-512. Table 3 lists every check of Section 6 with the cases that exercise it or, for a check that no case exercises, the reason.

  • Section 6 cites CBOR::Core [I-D.rundgren-cbor-core] on duplicate map keys and the deterministic encoding, cites [I-D.ietf-cbor-cde] for information as well, and keeps the key equivalence of [RFC8949] Section 5.6.1.

  • Section 6 states that an external_aad or a detached payload that is not supplied gives match INDETERMINATE and sig_valid None.

  • Section 6 names the four rules for sig_valid as the profile sid-ed25519-strict, names rule 2 as a restriction that [RFC8032] does not make, and gives the result of C11 under each equation.

  • Section 7 says that a whole-bytes identifier changes when the unprotected header or outer encoding is rewritten, that a reference match under the ToBeSigned scheme shows only that the signing input of the candidate is that of the designated statement, and that a whole-object identifier does not cover a detached payload or an external_aad.

  • Section 11 reports the second reader by Toshikatsu Oga (The HORIZONs Co., Ltd.) with its two limits, the comparison of 988 single-byte mutants, and the six levels of assurance, and keeps the test between two independent Transparency Services open.

  • Section 11 no longer states that the ToBeSigned matches at the archived emulator were the same; it states that the emulator registered the adapted statements and returned each submitted byte sequence unchanged.

  • Cases C1 to C14, their candidates and their expected results are unchanged.

  • Cases C15 to C23 are added, each for one check of Section 6 that C1 to C14 do not exercise: a named scheme the verifier does not implement, a reference with a byte after it, a candidate that is not a COSE_Sign1, each of rules 1 to 3, a signature of 63 bytes, a named external_aad that is not supplied, and a detached payload under which the signature verifies. Section 6 states for every case which external_aad and which detached payload it is supplied with.

Since draft-gruszka-scitt-statement-identification-02

  • Section 2.1 cites the framing-space measurement [I-D.templeman-scitt-framing-space] and states that a digest over the transmitted octets and the ToBeSigned rule of Section 5.1 identify different objects.

  • Appendix A gives each case as a base statement or as a stated change to one, with the length and SHA-256 of the candidate; apart from the bytes that a stated change names, a case gives bytes in full only for new signature bytes and for inputs that Appendices A.1 and A.2 do not contain, such as the external_aad of C7 and the references of C13 and C14. C8 says what its signature bytes were made over, and the opening of Appendix A.3 names the stated key of Section 6 for every case. Section 5.1 states which payload enters ToBeSigned when a detached payload is supplied, and C1 and C8 show it. Cases C1 to C12, their candidates and their expected results are unchanged.

  • Section 6 defines, for the cases of this document only, when a reference is well-formed and when it is compatible with the named scheme. Cases C13, a digest of 31 bytes, and C14, the scheme "WholeBytes", are added, each with ref_usable False and match INDETERMINATE. Section 11 and the earlier Changes item on its measurement now name cases C1 to C12, the cases that measurement covered.

  • [I-D.mih-sokolov-scitt-payload-binding] is cited as revision -06; Section 2.1 follows its section numbers.

Since draft-gruszka-scitt-statement-identification-01

  • In requirement A2, "may" is no longer written in capitals; recomputing a target digest is not a permission in the sense of BCP 14.

  • Requirement A5 says that the illustrative cases in Section 6 do not test leaf hashing or Receipts.

  • Section 11 adds the measurement of the package on the main branch of its repository against cases C1 to C12 of Section 6, and the result of a further checker written from the text.

  • Section 11 adds a local check of inclusion receipts from three instances of the ledger and cites pull request 31 of the CCF Receipt profile [CCF-DATA-HASH].

  • The Open Items section is removed. The references were checked against the published documents on 2026-10-12; Open Question 2 stays in Section 10.

  • This appendix is added.

Since draft-gruszka-scitt-statement-identification-00

  • Case C12 (requirement A4) is added: statement 01 with the head of its array written with a one-byte length argument, so that the ToBeSigned reference matches and the signature verifies while the whole-object digest changes. Its bytes are in Appendix A.

  • Section 11 adds a second local measurement, on 2026-10-11, with two implementations, the ledger and an archived emulator. Section 4.4 refers to it and to cases C5 and C12, and states that the emulator's receipts are not COSE Receipts, so the measurement is not a test of two Transparency Services.

Author's Address

Konrad Gruszka
b7n0de
Germany