This specification describes several Data Integrity Cryptosuites for use when generating a digital signature using Post-Quantum digital signature algorithms.
This specification is experimental, do not use it in any production setting.
This specification defines several cryptographic suites for the purposes of creating and verifying proofs for Post-Quantum signatures, in conformance with the Data Integrity [[VC-DATA-INTEGRITY]] specification.
This specification uses either the RDF Dataset Canonicalization Algorithm [[RDF-CANON]] or the JSON Canonicalization Scheme [[RFC8785]] to transform the input document into its canonical form. It uses a hash based on SHA-2 [[RFC6234]] and appropriate to the security category as the message digest, and supports a number of different Post-Quantum signature algorithms with varying properties such as public key size, signature size, and computational and implementational complexity.
Terminology used throughout this document is defined in the Terminology section of the [[[VC-DATA-INTEGRITY]]] specification.
A conforming proof is any concrete expression of the data model that complies with the normative statements in this specification. Specifically, all relevant normative statements in Sections [[[#data-model]]] and [[[#Algorithms]]] of this document MUST be enforced.
A conforming processor is any algorithm realized as software and/or hardware that generates or consumes a [=conforming proof=]. Conforming processors MUST produce errors when non-conforming documents are consumed.
This document contains examples of JSON and JSON-LD data. Some of these examples are invalid JSON, as they include features such as inline comments (`//`) explaining certain portions and ellipses (`...`) indicating the omission of information that is irrelevant to the example. Such parts need to be removed if implementers want to treat the examples as valid JSON or JSON-LD.
The following sections outline the data model that is used by this specification to express verification methods, such as cryptographic public keys, and data integrity proofs, such as digital signatures.
These verification methods are used to verify Data Integrity Proofs [[VC-DATA-INTEGRITY]] produced using the cryptographic key material for the various algorithms and parameter sets supported by this specification. The encoding formats for these key types are provided in this section. Lossless cryptographic key transformation processes that result in equivalent cryptographic key material MAY be used during the processing of digital signatures.
The Multikey format, defined in [[[CID]]], is used to express public keys for the cryptographic suites defined in this specification.
The `publicKeyMultibase` property represents a Multibase-encoded Multikey expression of a public key.
| Signature Name | Varint Code | Multi-Byte Prefix | Raw Public Key Size |
|---|---|---|---|
| ML-DSA-44 | 0x1210 | 0x9024 | 1312 |
| SLH-DSA-SHA2-128s | 0x1220 | 0xa024 | 32 |
| FALCON-512* | 0x122c | 0xac24 | 897 |
| SQIsign-I* | 0x122e | 0xae24 | 65 |
The Multikey encoding of a public key for a signature supported by this specification MUST start with the corresponding multi-byte prefix for the signature named in [[[#MultiKeyTable]]] followed by the raw public key bytes. This multi-byte prefix is the varint expression of the varint code given in the previous table. The resulting value will have a byte length given by the raw public key size in the table plus the length of the multi-byte prefix. This value MUST then be encoded using the base-64-url alphabet, according to the Multibase section of [[[CID]]] and then prepended with the base-64-url Multibase header (`u`).
Examples of all the `publicKeyMultibase` encodings defined in this specification can be found in appendix [[[#TestVectors]]].
Note*: The codes given in [[[#MultiKeyTable]]] for FALCON-512 and SQIsign-I are preliminary and not currently registered with multicodecs. When these signature schemes are formalized by NIST or other SDOs these values should be updated/registered.
The `secretKeyMultibase` property represents a Multibase-encoded Multikey expression of a secret key (also sometimes referred to as a private key).
| Signature Name | Varint Code | Multi-Byte Prefix | Raw Secret Size |
|---|---|---|---|
| ML-DSA-44 key1 | 0x1317 | 0x9726 | 2560 |
| ML-DSA-44 seed1 | 0x131a | 0x9a26 | 32 |
| SLH-DSA-SHA2-128s | 0x131d | 0x9d26 | 64 |
| FALCON-512** | 0x1321 | 0xa126 | 1281 |
| SQIsign-I** | 0x1322 | 0xa226 | 353 |
Note1: For ML-DSA signatures, the private key is generated from a private seed. Whether one retains the full private key or regenerates it from the corresponding seed is an implementation decision.
The Multikey encoding of a secret key for a signature supported by this specification MUST start with the corresponding multi-byte prefix for the signature named in [[[#SecretMultiKeyTable]]] followed by the raw public key bytes. This multi-byte prefix is the varint expression of the varint code given in the previous table. The resulting value will have a byte length given by the raw public key size in the table plus the length of the multi-byte prefix. This value MUST then be encoded using the base-64-url alphabet, according to the Multibase section of [[[CID]]] and then prepended with the base-64-url Multibase header (`u`).
Note**: The codes given in [[[#SecretMultiKeyTable]]] for FALCON-512, and SQIsign-I are preliminary and not currently registered with multicodecs. When these signature schemes are formalized by NIST or other SDOs, these values should be updated/registered.
Developers are advised to prevent accidental publication of a representation of a secret key, and to not export the `secretKeyMultibase` property by default, when serializing key pairs as Multikey.
This section details the proof representation formats that are defined by this specification.
A proof contains the attributes specified in the Proofs section of [[VC-DATA-INTEGRITY]] with the following restrictions.
The `type` property of the proof MUST be `DataIntegrityProof`.
The `cryptosuite` property of the proof MUST be one of the values from [[[#CryptosuiteTable]]], below, or [[[#SDCryptosuiteTable]]] for selective disclosure cryptosuites.
| Name | Signature Algorithm | Signature Length | Details |
|---|---|---|---|
| `mldsa44-rdfc-2024` | ML-DSA-44 | 2420 | ML-DSA |
| `mldsa44-jcs-2024` | ML-DSA-44 | 2420 | ML-DSA |
| `slhdsa128-rdfc-2024` | SLH-DSA-SHA2-128s | 7856 | SLH-DSA |
| `slhdsa128-jcs-2024` | SLH-DSA-SHA2-128s | 7856 | SLH-DSA |
| `falcon512-rdfc-2024` | FALCON-512 | 666 | FALCON |
| `falcon512-jcs-2024` | FALCON-512 | 666 | FALCON |
| `sqisign1-rdfc-2024` | SQIsign-I | 148 | SQIsign |
| `sqisign1-jcs-2024` | SQIsign-I | 148 | SQIsign |
The value of the `proofValue` property of the proof MUST be a signature produced by the signature algorithm corresponding to the `cryptosuite` given in [[[#CryptosuiteTable]]]. This signature is produced according to using the algorithms specified in section [[[#Algorithms]]], then encoded using the base-64-url-nopad header and alphabet as described in the Multibase section of [[CID]].
Examples of the `proofValue` for all the cryptosuites defined in this specification can be found in appendix [[[#TestVectors]]].
The following sections describe multiple Data Integrity cryptographic suites that utilize quantum safe signature algorithms at different claimed security categories. For a given claimed security category, an appropriate hash function is specified.
From [[[NIST-SP-800-57-Part-1R6]]], Section 4.6.1.4 on the "Security Strengths of Hash Functions, XOFs, and Their Applications," the following hash functions are chosen for use with digital signatures in [[[#HashSigTable]]].
| Security Strength | Hash Function |
|---|---|
| Category 1 or 2 | SHA-256 |
| Category 3 or 4 | SHA-384 |
| Category 5 | SHA-512 |
This specification supports cryptosuites based on both the Universal RDF Dataset Canonicalization Algorithm [[RDF-CANON]], `rdfc` and JSON Canonicalization Scheme [[RFC8785]], `jcs`.
Implementations SHOULD fetch and cache verification method information as early as possible when adding or verifying proofs. Parameters passed to functions in this section use information from the verification method — such as the public key size — to determine function parameters — such as the cryptographic hashing algorithm.
When the RDF Dataset Canonicalization Algorithm [[RDF-CANON]] is used, implementations of that algorithm will detect dataset poisoning by default, and abort processing upon detection.
This algorithm is used to configure a cryptographic suite to be used by the Add Proof and Verify Proof functions in [[[VC-DATA-INTEGRITY-1.1]]]. The algorithm takes an options object ([=map=] |options|) as input and returns a [=data integrity cryptographic suite instance|cryptosuite instance=] ([=struct=] |cryptosuite|).
The Module-Lattice-Based Digital Signature Standard defined in [[[FIPS-204]]] [[FIPS-204]] defines parameter sets for three different claimed security strengths. The claimed security strengths, private key, public key, and signature sizes are summarized in [[[#MLSummaryTable]]].
| Name | Security | Private Key | Public Key | Signature |
|---|---|---|---|---|
| ML-DSA-44 | Category 2 | 2560 | 1312 | 2420 |
| ML-DSA-65 | Category 3 | 4032 | 1952 | 3309 |
| ML-DSA-87 | Category 5 | 4896 | 2592 | 4627 |
Supporting both the Universal RDF Dataset Canonicalization Algorithm [[RDF-CANON]], "`rdfc`", the JSON Canonicalization Scheme [[RFC8785]], "`jcs`", and a maximum security category of 2, leads to the family of ML-DSA cryptosuites given in [[[#MLSuitesTable]]].
| Name | Canonalization | Signature/Verification | Hash |
|---|---|---|---|
| `mldsa44-rdfc-2024` | RDFC | ML-DSA-44 | SHA-256 |
| `mldsa44-jcs-2024` | JCS | ML-DSA-44 | SHA-256 |
The Stateless Hash-Based Digital Signature Standard defined in [[[FIPS-205]]] [[FIPS-205]] defines parameter sets for three different claimed security strengths, optimized for size or speed, and a specified hash function family. This specification considers a subset of these parameter sets, optimized for smaller size, and based on the SHA2 hash function family, as shown in [[[#SLHSigTable]]].
| Name | Security | Private Key | Public Key | Signature |
|---|---|---|---|---|
| SLH-DSA-SHA2-128s | Category 1 | 64 | 32 | 7856 |
| SLH-DSA-SHA2-192s | Category 3 | 96 | 48 | 16224 |
| SLH-DSA-SHA2-256s | Category 5 | 128 | 64 | 29792 |
Supporting both Universal RDF Dataset Canonicalization Algorithm [[RDF-CANON]], "`rdfc`", JSON Canonicalization Scheme [[RFC8785]], "`jcs`", and a maximum security category of 1, leads to the family of ML-DSA cryptosuites given in [[[#SLHSuiteTable]]].
| Name | Canonizalization | Signature/Verification | Hash |
|---|---|---|---|
| `slhdsa128-rdfc-2024` | RDFC | SLH-DSA-SHA2-128s | SHA-256 |
| `slhdsa128-jcs-2024` | JCS | SLH-DSA-SHA2-128s | SHA-256 |
The [[FALCON]] signature algorithm is undergoing standardization by NIST. The information presented here is based on the Post-Quantum Cryptography Round 3 Submission information. This section will be updated when the NIST specification is issued.
[[FALCON]] is a lattice-based signature scheme. It stands for the following acronym: FAst Fourier Lattice-based COmpact signatures over NTRU. FALCON defines parameter sets for two different claimed security strengths. The claimed security strengths, private key, public key, and signature sizes are summarized in [[[#FalconSummaryTable]]].
| Name | Security | Private Key | Public Key | Signature |
|---|---|---|---|---|
| FALCON-512 | Category 1 | 1281 | 897 | 666 |
| FALCON-1024 | Category 5 | 2305 | 1793 | 1280 |
Private key size information from openquantumsafe.org.
Supporting both the Universal RDF Dataset Canonicalization Algorithm [[RDF-CANON]], "`rdfc`", the JSON Canonicalization Scheme [[RFC8785]], "`jcs`", and a maximum security category of 1, leads to the family of FALCON cryptosuites given in [[[#FALCONSuitesTable]]].
| Name | Canonalization | Signature/Verification | Hash |
|---|---|---|---|
| `falcon512-rdfc-2024` | RDFC | FALCON-512 | SHA-256 |
| `falcon512-jcs-2024` | JCS | FALCON-512 | SHA-256 |
The SQIsign signature algorithm has been submitted to NIST. SQIsign aims for very compact key and signature sizes. The information presented here is based on specification v2.01, 2025-07-07. This section will be updated as appropriate.
SQIsign relies on the hardness of a computational problem from number theory: computing the endomorphism ring of a supersingular elliptic curve, the endomorphism ring problem. SQIsign defines parameter sets for three different claimed security strengths. The claimed security strengths, private key, public key, and signature sizes are summarized in [[[#SQISummaryTable]]].
| Name | Security | Private Key | Public Key | Signature |
|---|---|---|---|---|
| SQIsign-I | Category 1 | 353 | 65 | 148 |
| SQIsign-III | Category 3 | 529 | 97 | 224 |
| SQIsign-V | Category 5 | 701 | 129 | 292 |
Supporting both the Universal RDF Dataset Canonicalization Algorithm [[RDF-CANON]], "`rdfc`", the JSON Canonicalization Scheme [[RFC8785]], "`jcs`", and a maximum security category of 1, leads to the family of SQIsign cryptosuites given in [[[#SQISuitesTable]]].
| Name | Canonalization | Signature/Verification | Hash |
|---|---|---|---|
| `sqisign1-rdfc-2024` | RDFC | SQIsign-I | SHA-256 |
| `sqisign1-jcs-2024` | JCS | SQIsign-I | SHA-256 |
The [[VC-DATA-INTEGRITY-1.1]] specification defines [=selective disclosure=] and defines common algorithms for implementing [=selective disclosure=] where the signature scheme does not natively support it. Two general approaches are defined (1) Signed Individual Claims ([=SIC=]) and (2) Salted Hash of Claims ([=SHoC=]). The size of the signature impacts the overall base and derived proof sizes as indicated in [[[VC-DATA-INTEGRITY-1.1#SDApproachTable]]]. For large signature sizes the [=SHoC=] approach would be used.
The selective disclosure cryptosuites defined in this specification are listed in [[[#SDCryptosuiteTable]]]. Note that all selective disclosure cryptosuites utilize the advanced features of [[RDF-CANON]].
| Name | SD Approach | Signature Algorithm | Signature Length | Details |
|---|---|---|---|---|
| `mldsa44-sd-2024` | [=SHoC=] | ML-DSA-44 | 2420 | ML-DSA |
| `slhdsa128-sd-2024` | [=SHoC=] | SLH-DSA-SHA2-128s | 7856 | SLH-DSA |
| `falcon512-sd-2024` | [=SIC=] or [=SHoC=] | FALCON-512 | 666 | FALCON |
| `sqisign1-sd-2024` | [=SIC=] | SQISign-I | 148 | SQIsign |
Before reading this section, readers are urged to familiarize themselves with general security advice provided in the Security Considerations section of the Data Integrity specification.
The following section describes security considerations that developers implementing this specification should be aware of in order to create secure software or protocols based on verifiable credentials signed using the cryptosuites defined here.
All signature suites in this specification are designed to satisfy either existential unforgeability under chosen-message attacks (EUF-CMA) or strong unforgeability under chosen message attacks (SUF-CMA) or both as defined below.
EUF-CMA (existential unforgeability under chosen message attacks) is usually the minimal security property required of a signature scheme. It guarantees that any efficient adversary who has the public key of the signer and received an arbitrary number of signatures on messages of its choice (in an adaptive manner): , cannot output a valid signature for a new message (except with negligible probability). If the attacker outputs a valid signature on a new message: , it is called an existential forgery.
SUF-CMA (strong unforgeability under chosen message attacks) is a stronger notion than EUF-CMA. It guarantees that for any efficient adversary who has the public key of the signer and received an arbitrary number of signatures on messages of its choice: , it cannot output a new valid signature pair , such that (except with negligible probability). Strong unforgeability implies that an adversary not only cannot sign new messages, but also cannot find a new signature on an old message. See [[Provable_Ed25519]] for a real world attack that would have been circumvented with SUF-CMA security over EUF-CMA security.
Besides EUF-CMA and SUF-CMA there are additional properties a digital signature scheme can possess that may be essential for overall software or protocol security depending on the application. These are discussed in [[BUFF]], which is also referenced by [[FIPS-204]] and [[FIPS-205]]. These additional properties are defined in [[BUFF]] as: exclusive ownership, message-bound signatures, and non re-signability.
Exclusive Ownership (EO): the property that a signature only verifies under a single public key. Without this property a system could be vunerable to an attack that allows constructing another key pair under which a given signature verifies, but never breaks the EUF-CMA property. Such an attack is documented in both [[BUFF]] and in [[Provable_Ed25519]] where it is called a "key substitution attack".
Message-Bound Signatures (MBS): the property that a signature is only valid for a unique message. This property is key for data integrity and all signature schemes chosen here currently support it. From [[BUFF]]: "A possible cause can be the presence of weak keys that verify multiple or even all messages. The absence of this property can lead to problems in protocols that depend on uniqueness properties in the presence of adversarially chosen keys."
Non Re-signability (NR): meaning that one cannot produce a signature under another key given a signature for some unknown message m, i.e., that an adversary cannot produce a legitimate signature verifying under its public key for a message it does not know. See [[BUFF]] for an example of a system that could be vulnerable without this property.
In [[[#SecurityProperties]]] we summarize the known security properties of the signature schemes in this specification.
| Name | EUF-CMA | SUF-CMA | EO | MBS | NR |
|---|---|---|---|---|---|
| ML-DSA | Yes | Yes | Yes | Yes | Yes |
| SLH-DSA | Yes | No | Unknown | Yes | Unknown |
| FALCON* | Yes | No | No | Yes | No |
| SQIsign | Yes | No | Yes | Yes | Yes |
Note*: This is based on the "third round FALCON" currently used hear and according to [[BUFF]] will be updated when FIPS-206 is released.
Before reading this section, readers are urged to familiarize themselves with general privacy advice provided in the Privacy Considerations section of the Data Integrity specification.
The following section describes privacy considerations that developers implementing this specification should be aware of in order to avoid violating privacy assumptions.
The cryptographic suites described in this specification do not support [=selective disclosure=] or [=unlinkable disclosure=]. If [=selective disclosure=] is a desired feature, readers might find the [[[?VC-DI-ECDSA]]] specification useful. If [=unlinkable disclosure=] is of interest, the [[[?VC-DI-BBS]]] specification provides an unlinkable digital signature mechanism.
A relatively efficient selective, but not unlinkable, disclosure mechanism can be created by combining the selective disclosure functions defined in [[[?VC-DI-ECDSA]]] with the "salted hash" approach of SD-JWT, if there is sufficient interest.
Inputs used in two or more test vectors are given in this section. They include the unsigned document, general proof options, and cryptographic keys.
The common unsecured data document used for generating all test vectors that require this input is given below.
A general template for the proof options used by test vectors that require this input is given below.
For each specific test case the `cryptosuite` and `verificationMethod` fields need to be set. For example, for the `slhdsa128-rdfc-2024` cryptosuite using the appropriate public key information from section [[[#TestKeys]]] the specific proof options is given below.
Cryptographic keys for used to generate output for specific signature suites are given below. This includes public and private (secret) keys in hexadeximal format and the public key as a `publicKeyMultibase`.
The Proof Configuration algorithm output is dependent on the specific proof options as well as the parameters, hence an output test vector for Proof Configuration is given for each supported `cryptosuite`.
In addition to the common unsecured data document the Transform algorithm takes parameters |canonScheme| and |hashName|. Only in the case of |canonScheme| equal to `rdfc` does the |hashName| parameter matter. This is reflected in the set of Transformation output test vectors given below.
The Hashing algorithm takes as inputs the results of the Proof Configuration and Transformation algorithms. Since the Proof Configuration algorithm output is cryptosuite specific the Hashing algorithm output is given for each cryptosuite test case. The Hashing output for each cryptosuite test case is given in hexadecimal format below.
The first half of the hexadecimal Hashing result is the hash of the output of the Proof Configuration algorithm, while the second half of the hexidecimal value is the hash of the output from the Transformation algorithm and both can be useful information when debugging.
The Create Proof algorithm output is cryptosuite specific and uses the outputs of the Proof Configuration, Transformation, Hashing, and Proof Serialization algorithms. The output for each cryptosuite test case is given below.
The output of the Proof Serialization common algorithm is not given separately since it is contained in the `proofValue` attribute in the following examples and can be quite lengthy for some quantum safe signature algorithms.
The Quantum-Safe-SD cryptosuites of [[[#SDCryptosuiteTable]]] use the [=SHoC=] approach of [[VC-DATA-INTEGRITY-1.1]], with the salted hashes of the non-mandatory claims aggregated in a Merkle tree. The test vectors in this section follow the algorithms of [[[VC-DATA-INTEGRITY-1.1#create-base-proof]]] and [[[VC-DATA-INTEGRITY-1.1#add-derived-proof]]]. They use the same set of common inputs described in [[[#test-vector-common-inputs]]], this includes the unsigned document, proof options and the example keys for ML-DSA-44, SLH-DSA-SHA2-128s, and FALCON-512.
For the base proof transformation of [[[VC-DATA-INTEGRITY-1.1#TransformSD]]], the example mandatory information specified by the issuer is given via an array of JSON pointers as shown below.
An HMAC key is used to shuffle the blank node identifiers of the transformed document. We use the following HMAC key for all selective disclosure test vectors.
The salts for the salted hashes are derived from a salt seed using [[[VC-DATA-INTEGRITY-1.1#DeriveSaltsSD]]]. We use the following salt seed for all selective disclosure test vectors.
The salt seed above was chosen so that these test vectors can be reproduced. [[[VC-DATA-INTEGRITY-1.1#MerkleizeSD]]] requires a fresh salt seed, generated with a cryptographically secure random number generator, for every base proof. Reusing a salt seed, or using a predictable one, can compromise the security of the credential, e.g., leaking data on undisclosed claims.
To create the derived proof in [[[VC-DATA-INTEGRITY-1.1#add-derived-proof]]], the holder indicates what, if anything else, they wish to reveal to the verifier by specifying JSON pointers for selective disclosure. The example selective pointers are shown below:
The results of [[[VC-DATA-INTEGRITY-1.1#TransformSD]]] depend on the document, HMAC key, and mandatory pointers but not the specific signature algorithm. The result contains appropriately modified maps of mandatory and non-mandatory claims in N-Quad format as shown below.
[[[VC-DATA-INTEGRITY-1.1#HashSD]]] computes a cryptosuite specific proofHash, shown in [[[#sd-base-signature-specific-outputs]]], and a cryptosuite independent mandatoryHash over the mandatory claims, shown below.
[[[VC-DATA-INTEGRITY-1.1#MerkleizeSD]]] sets the treeSize to the number of non-mandatory claims and derives one salt for each of them from the salt seed using [[[VC-DATA-INTEGRITY-1.1#DeriveSaltsSD]]]. The salts are shown below.
Each non-mandatory claim is then hashed together with its salt to give a leaf hash, and the leaf hashes are aggregated into a Merkle tree using [[[VC-DATA-INTEGRITY-1.1#MTH]]]. The leaf hashes and the resulting merkleRoot are shown below. Neither the salts nor the leaf hashes are included in the base proof; the holder recomputes them from the salt seed.
The cryptosuite specific outputs of the base proof start with the proofHash from [[[VC-DATA-INTEGRITY-1.1#HashSD]]]. In [[[VC-DATA-INTEGRITY-1.1#SerializeBase-SHoC]]], the data that is signed, toSign, is the concatenation of the proofHash, the mandatoryHash, the treeSize encoded as an 8-byte big-endian unsigned integer, and the merkleRoot. These values are summarized below.
The result of [[[VC-DATA-INTEGRITY-1.1#SerializeBase-SHoC]]] is integrated into the final output of [[[VC-DATA-INTEGRITY-1.1#create-base-proof]]] for each of the example cryptosuites as shown below. The signature values in hex are shown in [[[#example-pqc-signatures]]].
The signature values shown here were generated deterministically, so that the test vectors can be reproduced. Implementations generally use randomized signing and will produce different signature values. You can verify a signature value against its corresponding input message, but you cannot compare two signature values to validate these test vectors, i.e., your generated signature value can be valid, while differing from what is presented here.
The holder starts with [[[VC-DATA-INTEGRITY-1.1#CreateDisclosureData]]], based on the document, base proof, and selective pointers. In [[[VC-DATA-INTEGRITY-1.1#SerializeDerived-SHoC]]], the holder sets the leafIndexes to the positions of the disclosed non-mandatory claims, recomputes all the salts and leaf hashes from the salt seed, and creates a subtreeProof using [[[VC-DATA-INTEGRITY-1.1#CreateSubtreeProof]]]. Only the salts of the disclosed claims, the filteredSalts, are included in the derived proof. Except for the signature, the values that go into the derived proof are common across the cryptosuite test vectors and are shown below.
The same subtreeProof is shown below with the name of the tree node each value belongs to, as computed by [[[VC-DATA-INTEGRITY-1.1#ComputeTreeShape]]]. A node named `N_a_b` is the root of the subtree covering leaves `a` through `b` − 1, and `Leafj` is the leaf hash of leaf `j`. With 20 leaves and leaves 0, 1, 8, 13, 14, and 15 disclosed, the proof contains, in left-to-right order, the root of each largest subtree with no disclosed leaves.
The signature recovered from the base proof and included in the derived proof is shown below, where we have aggregated the different signature values.
The final output, i.e., the signed derived document, from [[[VC-DATA-INTEGRITY-1.1#add-derived-proof]]] for each of our example cryptosuites is shown below.
This section contains the substantive changes that have been made to this specification over time.
Added cryptosuite algorithms for Stateless Hash-Based Signatures, Falcon, and SQISign.