| Internet-Draft | Identifying SCITT Signed Statements | November 2026 |
| Gruszka | Expires 19 May 2027 | [Page] |
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.¶
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.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
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.¶
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:¶
Data that designates a target Signed Statement together with the rule by which a candidate is judged to be that target.¶
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.¶
The operation of deciding, given a reference and a candidate statement, whether the candidate is the reference's target under the named scheme.¶
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.¶
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.¶
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).¶
The following cases need different identification properties; they motivate the requirements without selecting a scheme.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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).¶
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.¶
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.¶
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.¶
| 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.¶
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.¶
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.¶
Four identities are kept apart in this document.¶
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.¶
A particular signature instance, the signing input together with one signature value. No scheme of this document identifies it.¶
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.¶
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.¶
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.¶
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:¶
A and R are canonical encodings: decoding each as in [RFC8032] Section 5.1.3 succeeds.¶
A and R have order L: L*A and L*R are the neutral element, and A and R
are not the neutral element.¶
S is below L.¶
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.¶
| 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.¶
| 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.¶
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.¶
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.¶
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.¶
Concrete feedback is sought on the following.¶
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?¶
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)?¶
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.¶
Relationship vocabulary. This document deliberately excludes one; whether the identification work needs any relationship terms at all is open.¶
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).¶
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.¶
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.¶
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¶
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:¶
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.¶
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).¶
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.¶
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¶
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¶
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.¶
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¶
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¶
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.¶
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.¶
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.¶
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¶
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.¶
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¶
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¶
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.¶
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¶
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.¶
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¶
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¶
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¶
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.¶
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.¶
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).¶
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¶
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¶
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¶
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¶
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¶
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¶
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.¶
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.¶
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.¶
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¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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¶
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¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶