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.

Introduction

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

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.

Data Model

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.

Verification Methods

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.

Multikey

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.

Public Key Summary, all sizes in bytes.
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).

Secret Key Summary, all sizes in bytes.
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.

Proof Representations

This section details the proof representation formats that are defined by this specification.

DataIntegrityProof

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.

Full 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]]].

Algorithms

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]]].

Hashes for Signatures.
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.

Instantiate Cryptosuite

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|).

  1. Initialize |cryptosuite| to an empty [=struct=].
  2. If |options|.|type| does not equal `DataIntegrityProof`, return |cryptosuite|.
  3. If |options|.|cryptosuite| is listed in [[[#CryptosuiteTable]]] then:
    1. Set the values of the parameters `canonScheme`, `hashName`, `sigFunc`, and `verifyFunc`, as indicated in the section corresponding to the "Details" column in the [[[#CryptosuiteTable]]] with `proofEncoding` set to `base64`.
    2. Set |cryptosuite|.|createProof| to the algorithm in Section [[[VC-DATA-INTEGRITY-1.1#create-proof]]] passing in the above parameters.
    3. Set |cryptosuite|.|verifyProof| to the algorithm in Section [[[VC-DATA-INTEGRITY-1.1#verify-proof-0]]] passing in the above parameters.
  4. If |options|.|cryptosuite| is listed in [[[#SDCryptosuiteTable]]] then:
    1. Set the values of the parameters `approach`, `hashName`, `sigFunc`, and `verifyFunc`, as indicated in the corresponding column in the [[[#SDCryptosuiteTable]]].
    2. Set |cryptosuite|.|createBaseProof| to the algorithm in Section [[[VC-DATA-INTEGRITY-1.1#create-base-proof]]] passing in the above parameters.
    3. Set |cryptosuite|.|addDerivedProof| to the algorithm in Section [[[VC-DATA-INTEGRITY-1.1#add-derived-proof]]] passing in the above parameters.
    4. Set |cryptosuite|.|verifyDerivedProof| to the algorithm in Section [[[VC-DATA-INTEGRITY-1.1#verify-derived-proof]]] passing in the above parameters.
  5. Return |cryptosuite|.

ML-DSA Cryptosuites

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]]].

ML-DSA Signatures Summary, all sizes in bytes.
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]]].

Supported ML-DSA Cryptosuites.
Name Canonalization Signature/Verification Hash
`mldsa44-rdfc-2024` RDFC ML-DSA-44 SHA-256
`mldsa44-jcs-2024` JCS ML-DSA-44 SHA-256

SLH-DSA Cryptosuites

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]]].

SLH-DSA Signatures Summary, all sizes in bytes.
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]]].

Supported SLH-DSA Cryptosuites.
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

FALCON Cryptosuites

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]]].

FALCON Signatures Summary, all sizes in bytes.
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]]].

Supported FALCON Cryptosuites.
Name Canonalization Signature/Verification Hash
`falcon512-rdfc-2024` RDFC FALCON-512 SHA-256
`falcon512-jcs-2024` JCS FALCON-512 SHA-256

SQIsign Cryptosuites

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]]].

SQIsign Signatures Summary, all sizes in bytes.
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]]].

Supported SQIsign Cryptosuites.
Name Canonalization Signature/Verification Hash
`sqisign1-rdfc-2024` RDFC SQIsign-I SHA-256
`sqisign1-jcs-2024` JCS SQIsign-I SHA-256

Selective Disclosure Cryptosuites for Quantum Resistant Signatures

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]].

Selective Disclosure Cryptosuites.
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

Security Considerations

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.

Signature Security Properties

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 p k of the signer and received an arbitrary number of signatures on messages of its choice (in an adaptive manner): { m i , σ i } i = 1 N , cannot output a valid signature σ ∗ for a new message m ∗ ∉ { m i } i = 1 N (except with negligible probability). If the attacker outputs a valid signature on a new message: ( m ∗ , σ ∗ ) , 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 p k of the signer and received an arbitrary number of signatures on messages of its choice: { m i , σ i } i = 1 N , it cannot output a new valid signature pair ( m ∗ , σ ∗ ) , such that ( m ∗ , σ ∗ ) ∉ { m i , σ i } i = 1 N (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.

Security Properties of Signature Schemes.
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.

Privacy Considerations

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.

Selective and Unlinkable Disclosure

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.

Test Vectors

Test Vector Common Inputs

Inputs used in two or more test vectors are given in this section. They include the unsigned document, general proof options, and cryptographic keys.

Unsecured Data Document

The common unsecured data document used for generating all test vectors that require this input is given below.


        

Proof Options

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.

          
Example Cryptographic Keys

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`.

          
          
          
          

Common Algorithms: Proof Configuration

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`.

Proof Configuration (`rdfc`, `sha-256`)

          
          
          
          
Proof Configuration (`jcs`)
          
          
          
          

Common Algorithms: Transform

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.

Transform (`rdfc`, `sha-256`)

          
Transform (`rdfc`, `sha-384`)
          
Transform (`rdfc`, `sha-512`)
          
Transform (`jcs`)
          

Common Algorithms: Hashing

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.

        

Create Proof

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.

Cryptosuite `mldsa44-rdfc-2024`

          

Cryptosuite `mldsa44-jcs-2024`

          

Cryptosuite `slhdsa128-rdfc-2024`

          

Cryptosuite `slhdsa128-jcs-2024`

          

Cryptosuite `falcon512-rdfc-2024`

          

Cryptosuite `falcon512-jcs-2024`

          

Cryptosuite `sqisign1-rdfc-2024`

          

Cryptosuite `sqisign1-jcs-2024`

          

Quantum Safe Selective Disclosure

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.

Selective Disclosure Common Inputs

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:


        

SD Base Common Outputs

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.


        

SD Base Signature Specific Outputs

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.

SD Derive Common Outputs

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.



          

        

SD Derive Signature Specific Outputs

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.


          

          

        

Revision History

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.