Data Integrity ECDSA Cryptosuites v1.0

Abstract

This specification describes Data Integrity cryptosuites for use when generating a digital signature using the Elliptic Curve Digital Signature Algorithm (ECDSA).

The following section describes multiple Data Integrity cryptographic suites that utilize the Elliptic Curve Digital Signature Algorithm (ECDSA) [ FIPS-186-5 ]. When generating ECDSA signatures, the signature value MUST be expressed according to section 7 of [ RFC4754 ] (sometimes referred to as the IEEE P1363 format) and encoded according to the specific cryptosuite proof generation algorithm. All ECDSA signatures SHOULD use the deterministic variant of the algorithm defined in [ FIPS-186-5 ].

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 (RDFC-1.0) [ RDF-CANON ] is used with ECDSA algorithms, the cryptographic hashing function used by RDFC-1.0 is chosen based on the size of the associated public key. For P-256 keys, the default hashing function, SHA-2 with 256 bits of output, MUST be used. For P-384 keys, SHA-2 with 384-bits of output MUST be used, specified via the RDFC-1.0 implementation-specific parameter .

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 Verifiable Credential Data Integrity 1.0 . The algorithm takes an options object ( map options ) as input and returns a cryptosuite instance ( struct cryptosuite ).

Initialize cryptosuite to an empty struct .
If options. type does not equal DataIntegrityProof, return cryptosuite.
If options. cryptosuite is ecdsa-rdfc-2019 then:
1. Set cryptosuite. createProof to the algorithm in Section 3.2.1 Create Proof (ecdsa-rdfc-2019) .
2. Set cryptosuite. verifyProof to the algorithm in Section 3.2.7 Proof Verification (ecdsa-rdfc-2019) .
If options. cryptosuite is ecdsa-jcs-2019 then:
1. Set cryptosuite. createProof to the algorithm in Section 3.3.1 Create Proof (ecdsa-jcs-2019) .
2. Set cryptosuite. verifyProof to the algorithm in Section 3.3.7 Proof Verification (ecdsa-jcs-2019) .
If options. cryptosuite is ecdsa-sd-2023 then:
1. Set cryptosuite. createProof to the algorithm in Section 3.6.1 Create Base Proof (ecdsa-sd-2023) .
2. Set cryptosuite. verifyProof to the algorithm in Section 3.6.7 Verify Derived Proof (ecdsa-sd-2023) .
Return cryptosuite.

The ecdsa-rdfc-2019 cryptographic suite takes an input document, canonicalizes the document using the RDF Dataset Canonicalization [ RDF-CANON ], and then cryptographically hashes and signs the output resulting in the production of a data integrity proof. The algorithms in this section also include the verification of such a data integrity proof.

The following algorithm specifies how to create a data integrity proof given an unsecured data document . Required inputs are an unsecured data document ( map unsecuredDocument ), and a set of proof options ( map options ). A data integrity proof ( map ), or an error, is produced as output.

Let proof be a clone of the proof options, options.
Let proofConfig be the result of running the algorithm in Section 3.2.5 Proof Configuration (ecdsa-rdfc-2019) with options passed as a parameter.
Let transformedData be the result of running the algorithm in Section 3.2.3 Transformation (ecdsa-rdfc-2019) with unsecuredDocument, proofConfig, and options passed as parameters.
Let hashData be the result of running the algorithm in Section 3.2.4 Hashing (ecdsa-rdfc-2019) with transformedData and proofConfig passed as a parameters.
Let proofBytes be the result of running the algorithm in Section 3.2.6 Proof Serialization (ecdsa-rdfc-2019) with hashData and options passed as parameters.
Let proof. proofValue be a base58-btc-encoded Multibase value of the proofBytes.
Return proof as the data integrity proof .

The following algorithm specifies how to verify a data integrity proof given an secured data document . Required inputs are an secured data document ( map securedDocument ). This algorithm returns a verification result , which is a struct whose items are:

verified: true or false
verifiedDocument: Null , if verified is false ; otherwise, an unsecured data document

Let unsecuredDocument be a copy of securedDocument with the proof value removed.
Let proofConfig be a copy of securedDocument. proof with proofValue removed.
Let proofBytes be the Multibase decoded base58-btc value in securedDocument. proof. proofValue.
Let transformedData be the result of running the algorithm in Section 3.2.3 Transformation (ecdsa-rdfc-2019) with unsecuredDocument and proofConfig passed as parameters.
Let hashData be the result of running the algorithm in Section 3.2.4 Hashing (ecdsa-rdfc-2019) with transformedData and proofConfig passed as a parameters.
Let verified be the result of running the algorithm in Section 3.2.7 Proof Verification (ecdsa-rdfc-2019) algorithm on hashData, proofBytes, and proofConfig.
Return a verification result with items :

verified

verified

verifiedDocument

unsecuredDocument if verified is true, otherwise Null

The following algorithm specifies how to transform an unsecured input document into a transformed document that is ready to be provided as input to the hashing algorithm in Section 3.2.4 Hashing (ecdsa-rdfc-2019) .

If options. type is not set to the string DataIntegrityProof and options. cryptosuite is not set to the string ecdsa-rdfc-2019, an error MUST be raised and SHOULD convey an error type of PROOF_TRANSFORMATION_ERROR .
Let canonicalDocument be the result of converting unsecuredDocument to JSON-LD expanded form and then to RDF statements , applying the RDF Dataset Canonicalization Algorithm [ RDF-CANON ] to the result, and then serializing the result to a serialized canonical form [ RDF-CANON ]. For canonicalization, one is expected to use a hash algorithm that has an appropriate security level for the curve used; see further details .
Return canonicalDocument as the transformed data document .

The following algorithm specifies how to cryptographically hash a transformed data document and proof configuration into cryptographic hash data that is ready to be provided as input to the algorithms in Section 3.2.6 Proof Serialization (ecdsa-rdfc-2019) or Section 3.2.7 Proof Verification (ecdsa-rdfc-2019) . One must use the hash algorithm appropriate in security level to the curve used, i.e., for curve P-256 one uses SHA-256 and for curve P-384 one uses SHA-384.

The required inputs to this algorithm are a transformed data document ( transformedDocument ) and canonical proof configuration ( canonicalProofConfig ). A single hash data value represented as series of bytes is produced as output.

Let transformedDocumentHash be the result of applying the SHA-256 (SHA-2 with 256-bit output) or SHA-384 (SHA-2 with 384-bit output) cryptographic hashing algorithm [ RFC6234 ] to the respective curve P-256 or curve P-384 transformedDocument. Respective transformedDocumentHash will be exactly 32 or 48 bytes in size.
Let proofConfigHash be the result of applying the SHA-256 (SHA-2 with 256-bit output) or SHA-384 (SHA-2 with 384-bit output) cryptographic hashing algorithm [ RFC6234 ] to the respective curve P-256 or curve P-384 canonicalProofConfig. Respective proofConfigHash will be exactly 32 or 48 bytes in size.
Let hashData be the result of joining proofConfigHash (the first hash) with transformedDocumentHash (the second hash).
Return hashData as the hash data .

The following algorithm specifies how to generate a proof configuration from a set of proof options that is used as input to the proof hashing algorithm .

The required inputs to this algorithm are proof options ( options ). The proof options MUST contain a type identifier for the cryptographic suite ( type ) and MUST contain a cryptosuite identifier ( cryptosuite ). A proof configuration object is produced as output.

Let proofConfig be a clone of the options object.
If proofConfig. type is not set to DataIntegrityProof and/or proofConfig. cryptosuite is not set to ecdsa-rdfc-2019, an error MUST be raised and SHOULD convey an error type of PROOF_GENERATION_ERROR .
If proofConfig. created is set and if the value is not a valid [ XMLSCHEMA11-2 ] datetime, an error MUST be raised and SHOULD convey an error type of PROOF_GENERATION_ERROR .
Set proofConfig. @context to unsecuredDocument. @context.
Let canonicalProofConfig be the result of applying the RDF Dataset Canonicalization [ RDF-CANON ] to the proofConfig.
Return canonicalProofConfig.

The following algorithm specifies how to serialize a digital signature from a set of cryptographic hash data. This algorithm is designed to be used in conjunction with the algorithms defined in the Data Integrity [ VC-DATA-INTEGRITY ] specification, Section 4: Algorithms . Required inputs are cryptographic hash data ( hashData ) and proof options ( options ). The proof options MUST contain a type identifier for the cryptographic suite ( type ) and MAY contain a cryptosuite identifier ( cryptosuite ). A single digital proof value represented as series of bytes is produced as output.

Let privateKeyBytes be the result of retrieving the private key bytes (or a signing interface enabling the use of the private key bytes) associated with the verification method identified by the options. verificationMethod value.
Let proofBytes be the result of applying the Elliptic Curve Digital Signature Algorithm (ECDSA) [ FIPS-186-5 ], with hashData as the data to be signed using the private key specified by privateKeyBytes. proofBytes will be exactly 64 bytes in size for a P-256 key, and 96 bytes in size for a P-384 key.
Return proofBytes as the digital proof .

The following algorithm specifies how to verify a digital signature from a set of cryptographic hash data. This algorithm is designed to be used in conjunction with the algorithms defined in the Data Integrity [ VC-DATA-INTEGRITY ] specification, Section 4: Algorithms . Required inputs are cryptographic hash data ( hashData ), a digital signature ( proofBytes ) and proof options ( options ). A verification result represented as a boolean value is produced as output.

Let publicKeyBytes be the result of retrieving the public key bytes associated with the options. verificationMethod value as described in the Controlled Identifiers v1.0 specification, Section: Retrieve Verification Method .
Let verificationResult be the result of applying the verification algorithm Elliptic Curve Digital Signature Algorithm (ECDSA) [ FIPS-186-5 ], with hashData as the data to be verified against the proofBytes using the public key specified by publicKeyBytes.
Return verificationResult as the verification result .

The ecdsa-jcs-2019 cryptographic suite takes an input document, canonicalizes the document using the JSON Canonicalization Scheme [ RFC8785 ], and then cryptographically hashes and signs the output resulting in the production of a data integrity proof. The algorithms in this section also include the verification of such a data integrity proof.

Let proof be a clone of the proof options, options.
If unsecuredDocument. @context is present, set proof. @context to unsecuredDocument. @context.
Let proofConfig be the result of running the algorithm in Section 3.3.5 Proof Configuration (ecdsa-jcs-2019) with proof passed as the proof options parameter.
Let transformedData be the result of running the algorithm in Section 3.3.3 Transformation (ecdsa-jcs-2019) with unsecuredDocument and options passed as parameters.
Let hashData be the result of running the algorithm in Section 3.3.4 Hashing (ecdsa-jcs-2019) with transformedData and proofConfig passed as a parameters.
Let proofBytes be the result of running the algorithm in Section 3.3.6 Proof Serialization (ecdsa-jcs-2019) with hashData and options passed as parameters.
Let proof. proofValue be a base58-btc-encoded Multibase value of the proofBytes.
Return proof as the data integrity proof .

verified: true or false
verifiedDocument: if verified is true, an unsecured data document ; otherwise Null

Let unsecuredDocument be a copy of securedDocument with the proof value removed.
Let proofOptions be the result of a copy of securedDocument. proof with proofValue removed.
Let proofBytes be the Multibase decoded base58-btc value in securedDocument. proof. proofValue.
If proofOptions. @context exists:
1. Check that the securedDocument. @context starts with all values contained in the proofOptions. @context in the same order. Otherwise, set verified to false and skip to the last step.
2. Set unsecuredDocument. @context equal to proofOptions. @context.
Let transformedData be the result of running the algorithm in Section 3.3.3 Transformation (ecdsa-jcs-2019) with unsecuredDocument and proofOptions passed as parameters.
Let proofConfig be the result of running the algorithm in Section 3.3.5 Proof Configuration (ecdsa-jcs-2019) with proofOptions passed as the parameter.
Let hashData be the result of running the algorithm in Section 3.3.4 Hashing (ecdsa-jcs-2019) with transformedData and proofConfig passed as a parameters.
Let verified be the result of running the algorithm in Section 3.3.7 Proof Verification (ecdsa-jcs-2019) on hashData, proofBytes, and proofConfig.
Return a verification result with items :

verified

verified

verifiedDocument

if verified is true, unsecuredDocument ; otherwise, Null

If options. type is not set to the string DataIntegrityProof or options. cryptosuite is not set to the string ecdsa-jcs-2019, an error MUST be raised and SHOULD convey an error type of PROOF_TRANSFORMATION_ERROR .
Let canonicalDocument be the result of applying the JSON Canonicalization Scheme [ RFC8785 ] to a JSON serialization of the unsecuredDocument.
Return canonicalDocument as the transformed data document .

The following algorithm specifies how to cryptographically hash a transformed data document and proof configuration into cryptographic hash data that is ready to be provided as input to the algorithms in Section 3.3.6 Proof Serialization (ecdsa-jcs-2019) or Section 3.3.7 Proof Verification (ecdsa-jcs-2019) . One must use the hash algorithm appropriate in security level to the curve used, i.e., for curve P-256 one uses SHA-256, and for curve P-384 one uses SHA-384.

The required inputs to this algorithm are a transformed data document ( transformedDocument ) and a canonical proof configuration ( canonicalProofConfig ). A single hash data value represented as series of bytes is produced as output.

Let transformedDocumentHash be the result of applying the SHA-256 (SHA-2 with 256-bit output) or SHA-384 (SHA-2 with 384-bit output) cryptographic hashing algorithm [ RFC6234 ] to the respective curve P-256 or curve P-384 transformedDocument. Respective transformedDocumentHash will be exactly 32 or 48 bytes in size.
Let proofConfigHash be the result of applying the SHA-256 (SHA-2 with 256-bit output) or SHA-384 (SHA-2 with 384-bit output) cryptographic hashing algorithm [ RFC6234 ] to the respective curve P-256 or curve P-384 canonicalProofConfig. Respective proofConfigHash will be exactly 32 or 48 bytes in size.
Let hashData be the result of concatenating proofConfigHash (the first hash) followed by transformedDocumentHash (the second hash).
Return hashData as the hash data .

The following algorithm specifies how to generate a proof configuration from a set of proof options that is used as input to the proof hashing algorithm .

The required inputs to this algorithm are the proof options ( options ). The proof options MUST contain a type identifier for the cryptographic suite ( type ) and MUST contain a cryptosuite identifier ( cryptosuite ). A proof configuration object is produced as output.

Let proofConfig be a clone of the options object.
If proofConfig. type is not set to DataIntegrityProof and/or proofConfig. cryptosuite is not set to ecdsa-jcs-2019, an error MUST be raised and SHOULD convey an error type of PROOF_GENERATION_ERROR .
If proofConfig. created is set and if the value is not a valid [ XMLSCHEMA11-2 ] datetime, an error MUST be raised and SHOULD convey an error type of PROOF_GENERATION_ERROR .
Let canonicalProofConfig be the result of applying the JSON Canonicalization Scheme [ RFC8785 ] to the proofConfig.
Return canonicalProofConfig.

Let privateKeyBytes be the result of retrieving the private key bytes associated with the options. verificationMethod value.
Let proofBytes be the result of applying the Elliptic Curve Digital Signature Algorithm (ECDSA) [ FIPS-186-5 ], with hashData as the data to be signed using the private key specified by privateKeyBytes. proofBytes will be exactly 64 bytes in size for a P-256 key, and 96 bytes in size for a P-384 key.
Return proofBytes as the digital proof .

The following algorithm specifies how to verify a digital signature from a set of cryptographic hash data. This algorithm is designed to be used in conjunction with the algorithms defined in the Data Integrity [ VC-DATA-INTEGRITY ] specification, Section 4: Algorithms . Required inputs are cryptographic hash data ( hashData ), a digital signature ( proofBytes ), and proof options ( options ). A verification result represented as a boolean value is produced as output.

Let publicKeyBytes be the result of retrieving the public key bytes associated with the options. verificationMethod value as described in the Controlled Identifiers v1.0 specification, Section: Retrieve Verification Method .
Let verificationResult be the result of applying the verification algorithm, Elliptic Curve Digital Signature Algorithm (ECDSA) [ FIPS-186-5 ], with hashData as the data to be verified against the proofBytes using the public key specified by publicKeyBytes.
Return verificationResult as the verification result .

The following section contains a set of functions that are used throughout cryptographic suites that perform selective disclosure.

The following algorithm canonicalizes an array of N-Quad [ N-QUADS ] strings and replaces any blank node identifiers in the canonicalized result using a label map factory function, labelMapFactoryFunction. The required inputs are an array of N-Quad strings ( nquads ), and a label map factory function ( labelMapFactoryFunction ). Any custom options can also be passed. An N-Quads representation of the canonicalNQuads as an array of N-Quad strings, with the replaced blank node labels, and a map from the old blank node IDs to the new blank node IDs, labelMap , is produced as output.

Run the RDF Dataset Canonicalization Algorithm [ RDF-CANON ] on the joined nquads, passing any custom options, and as output, get the canonicalized dataset, which includes a canonical bnode identifier map, canonicalIdMap.
Pass canonicalIdMap to labelMapFactoryFunction to produce a new bnode identifier map, labelMap .
Use the canonicalized dataset and labelMap to produce the canonical N-Quads representation as an array of N-Quad strings, canonicalNQuads .
Return an object containing labelMap and canonicalNQuads .

The following algorithm canonicalizes a JSON-LD document and replaces any blank node identifiers in the canonicalized result using a label map factory function, labelMapFactoryFunction. The required inputs are a JSON-LD document ( document ) and a label map factory function ( labelMapFactoryFunction ). Additional custom options (such as a document loader) can also be passed. An N-Quads representation of the canonicalNQuads as an array of N-Quad strings, with the replaced blank node labels, and a map from the old blank node IDs to the new blank node IDs, labelMap , is produced as output.

Deserialize the JSON-LD document to RDF, rdf, using the Deserialize JSON-LD to RDF algorithm , passing any custom options (such as a document loader).
Serialize rdf to an array of N-Quad strings, nquads.
Return the result of calling the algorithm in Section 3.4.1 labelReplacementCanonicalizeNQuads , passing nquads, labelMapFactoryFunction, and any custom options.

The following algorithm creates a label map factory function that uses an input label map to replace canonical blank node identifiers with another value. The required input is a label map, labelMap. A function, labelMapFactoryFunction , is produced as output.

Create a function, labelMapFactoryFunction, with one required input (a canonical node identifier map, canonicalIdMap ), that will return a blank node identifier map, bnodeIdMap , as output. Set the function's implementation to:
1. Generate a new empty bnode identifier map, bnodeIdMap .
2. For each map entry, entry , in canonicalIdMap:
  1. Use the canonical identifier from the value in entry as a key in labelMap to get the new label, newLabel .
  2. Add a new entry, newEntry, to bnodeIdMap using the key from entry and newLabel as the value.
3. Return bnodeIdMap .
Return labelMapFactoryFunction.

The following algorithm creates a label map factory function that uses an HMAC to replace canonical blank node identifiers with their encoded HMAC digests. The required input is an HMAC (previously initialized with a secret key), HMAC. A function, labelMapFactoryFunction , is produced as output.

Create a function, labelMapFactoryFunction, with one required input (a canonical node identifier map, canonicalIdMap ), that will return a blank node identifier map, bnodeIdMap , as output. Set the function's implementation to:
1. Generate a new empty bnode identifier map, bnodeIdMap .
2. For each map entry, entry , in canonicalIdMap:
  1. HMAC the canonical identifier from the value in entry to get an HMAC digest, digest .
  2. Generate a new string value, b64urlDigest , and initialize it to "u" followed by appending a base64url-no-pad encoded version of the digest value.
  3. Add a new entry, newEntry, to bnodeIdMap using the key from entry and b64urlDigest as the value.
3. Return bnodeIdMap .
Return labelMapFactoryFunction.

Note : Other algorithms are possible

A different primitive could be created that returned a label map factory function that would instead sort the resulting HMAC digests and assign labels in the produced label map using a prefix and integers based on their sorted order. This primitive might be useful for selective disclosure schemes, such as BBS, that favor unlinkability over minimizing unrevealed data leakage.

The following algorithm replaces all blank node identifiers in an array of N-Quad strings with custom scheme URNs. The required inputs are an array of N-Quad strings ( inputNQuads ) and a URN scheme ( urnScheme ). An array of N-Quad strings, skolemizedNQuads , is produced as output. This operation is intended to be reversible through the use of the algorithm in Section 3.4.6 deskolemizeNQuads .

Create a new array of N-Quad strings, skolemizedNQuads .
For each N-Quad string, s1 , in inputNQuads:
1. Create a new string, s2 , that is a copy of s1 replacing any occurrence of a blank node identifier with a URN ("urn:"), plus the input custom scheme ( urnScheme ), plus a colon (":"), and the value of the blank node identifier. For example, a regular expression of a similar form to the following would achieve the desired result: s1.replace(/(_:([^\s]+))/g, '<urn:custom-scheme:$2>').
2. Append s2 to skolemizedNQuads .
Return skolemizedNQuads .

The following algorithm replaces all custom scheme URNs in an array of N-Quad statements with a blank node identifier. The required inputs are an array of N-Quad strings ( inputNQuads ) and a URN scheme ( urnScheme ). An array of N-Quad strings, deskolemizedNquads , is produced as output. This operation is intended to reverse use of the algorithm in Section 3.4.6 deskolemizeNQuads .

Create a new array of N-Quad strings, deskolemizedNQuads .
For each N-Quad string, s1 , in inputNQuads:
1. Create a new string, s2 , that is a copy of s1 replacing any occurrence of a URN ("urn:"), plus the input custom scheme ( urnScheme ), plus a colon (":"), and the value of the blank node identifier with a blank node prefix ("_:"), plus the value of the blank node identifier. For example, a regular expression of a similar form to the following would achieve the desired result: s1.replace(/(<urn:custom-scheme:([^>]+)>)/g, '_:$2')..
2. Append s2 to deskolemizedNQuads .
Return deskolemizedNQuads .

The following algorithm replaces all blank node identifiers in an expanded JSON-LD document with custom-scheme URNs, including assigning such URNs to blank nodes that are unlabeled. The required inputs are an expanded JSON-LD document ( expanded ), a custom URN scheme ( urnScheme ), a UUID string or other comparably random string ( randomString ), and reference to a shared integer ( count ). Any additional custom options (such as a document loader) can also be passed. It produces the expanded form of the skolemized JSON-LD document ( skolemizedExpandedDocument as output. The skolemization used in this operation is intended to be reversible through the use of the algorithm in Section 3.4.9 toDeskolemizedNQuads .

Initialize skolemizedExpandedDocument to an empty array.
For each element in expanded:
1. If either element is not an object or it contains the key @value , append a copy of element to skolemizedExpandedDocument and continue to the next element.
2. Otherwise, initialize skolemizedNode to an object, and for each property and value in element:
  1. If value is an array, set the value of property in skolemizedNode to the result of calling this algorithm recursively passing value for expanded and keeping the other parameters the same.
  2. Otherwise, set the value of property in skolemizedNode to the first element in the array result of calling this algorithm recursively passing an array with value as its only element for expanded and keeping the other parameters the same.
3. If skolemizedNode has no @id property, set the value of the @id property in skolemizedNode to the concatenation of "urn:", urnScheme, "_", randomString, "_" and the value of count, incrementing the value of count afterwards.
4. Otherwise, if the value of the @id property in skolemizedNode starts with "_:", preserve the existing blank node identifier when skolemizing by setting the value of the @id property in skolemizedNode to the concatenation of "urn:", urnScheme, and the blank node identifier (i.e., the existing value of the @id property minus the "_:" prefix; e.g., if the existing value of the @id property is _:b0, the blank node identifier is b0 ).
5. Append skolemizedNode to skolemizedExpandedDocument.
Return skolemizedExpandedDocument.

The following algorithm replaces all blank node identifiers in a compact JSON-LD document with custom-scheme URNs. The required inputs are a compact JSON-LD document ( document ) and a custom URN scheme ( urnScheme ) which defaults to "custom-scheme:". The document is assumed to use only one @context property at the top level of the document. Any additional custom options (such as a document loader) can also be passed. It produces both an expanded form of the skolemized JSON-LD document ( skolemizedExpandedDocument and a compact form of the skolemized JSON-LD document ( skolemizedCompactDocument ) as output. The skolemization used in this operation is intended to be reversible through the use of the algorithm in Section 3.4.9 toDeskolemizedNQuads which uses the same custom URN scheme ( urnScheme ).

Initialize expanded to the result of the JSON-LD Expansion Algorithm , passing document and any custom options.
Initialize skolemizedExpandedDocument to the result of the algorithm in Section 3.4.7 skolemizeExpandedJsonLd .
Initialize skolemizedCompactDocument to the result of the JSON-LD Compaction Algorithm , passing skolemizedExpandedDocument and any custom options.
Return an object with both skolemizedExpandedDocument and skolemizedCompactDocument.

The following algorithm converts a skolemized JSON-LD document, such as one created using the algorithm in Section 3.4.8 skolemizeCompactJsonLd , to an array of deskolemized N-Quads. The required input is a JSON-LD document, skolemizedDocument . Additional custom options (such as a document loader) can be passed. An array of deskolemized N-Quad strings ( deskolemizedNQuads ) is produced as output.

Initialize skolemizedDataset to the result of the Deserialize JSON-LD to RDF algorithm, passing any custom options (such as a document loader), to convert skolemizedDocument from JSON-LD to RDF in N-Quads format.
Split skolemizedDataset into an array of individual N-Quads, skolemizedNQuads.
Set deskolemizedNQuads to the result of the algorithm in Section 3.4.6 deskolemizeNQuads with skolemizedNQuads and "custom-scheme:" as parameters. Implementations MAY choose a different urnScheme that is different than "custom-scheme:" so long as the same scheme name was used to generate skolemizedDocument .
Return deskolemizedNQuads.

The following algorithm converts a JSON Pointer [ RFC6901 ] to an array of paths into a JSON tree. The required input is a JSON Pointer string ( pointer ). An array of paths ( paths ) is produced as output.

Initialize paths to an empty array.
Initialize splitPath to an array by splitting pointer on the "/" character and skipping the first, empty, split element. In Javascript notation, this step is equivalent to the following code: pointer.split('/').slice(1)
For each path in splitPath:
1. If path does not include ~, then add path to paths, converting it to an integer if it parses as one, leaving it as a string if it does not.
2. Otherwise, unescape any JSON pointer escape sequences in path and add the result to paths.
Return paths.

The following algorithm creates an initial selection (a fragment of a JSON-LD document) based on a JSON-LD object. This is a helper function used within the algorithm in Section 3.4.13 selectJsonLd . The required input is a JSON-LD object ( source ). A JSON-LD document fragment object ( selection ) is produced as output.

Initialize selection to an empty object.
If source has an id that is not a blank node identifier, set selection. id to its value. Note: All non-blank node identifiers in the path of any JSON Pointer MUST be included in the selection, this includes any root document identifier.
If source. type is set, set selection. type to its value. Note: The selection MUST include all type s in the path of any JSON Pointer, including any root document type.
Return selection.

The following algorithm selects a portion of a compact JSON-LD document using paths parsed from a parsed JSON Pointer. This is a helper function used within the algorithm in Section 3.4.13 selectJsonLd . The required inputs are an array of paths ( paths ) parsed from a JSON Pointer, a compact JSON-LD document ( document ), a selection document ( selectionDocument ) to be populated, and an array of arrays ( arrays ) for tracking selected arrays. This algorithm produces no output; instead it populates the given selectionDocument with any values selected via paths.

Initialize parentValue to document.
Initialize value to parentValue.
Initialize selectedParent to selectionDocument.
Initialize selectedValue to selectedParent.
For each path in paths:
1. Set selectedParent to selectedValue.
2. Set parentValue to value.
3. Set value to parentValue. path. If value is now undefined, an error MUST be raised and SHOULD convey an error type of PROOF_GENERATION_ERROR , indicating that the JSON pointer does not match the given document.
4. Set selectedValue to selectedParent. path.
5. If selectedValue is now undefined:
  1. If value is an array, set selectedValue to an empty array and append selectedValue to arrays.
  2. Otherwise, set selectedValue to an initial selection passing value as source to the algorithm in Section 3.4.11 createInitialSelection .
  3. Set selectedParent. path to selectedValue.
Note: With path traversal complete at the target value, the selected value will now be computed.
If value is a literal, set selectedValue to value.
If value is an array, Set selectedValue to a copy of value.
In all other cases, set selectedValue to an object that merges a shallow copy of selectedValue with a deep copy of value, e.g., {...selectedValue, …deepCopy(value)}.
Get the last path, lastPath, from paths.
Set selectedParent. lastPath to selectedValue.

The following algorithm selects a portion of a compact JSON-LD document using an array of JSON Pointers. The required inputs are an array of JSON Pointers ( pointers ) and a compact JSON-LD document ( document ). The document is assumed to use a JSON-LD context that aliases @id and @type to id and type, respectively, and to use only one @context property at the top level of the document. A new JSON-LD document that represents a selection ( selectionDocument ) of the original JSON-LD document is produced as output.

If pointers is empty, return null. This indicates nothing has been selected from the original document.
Initialize arrays to an empty array. This variable will be used to track selected sparse arrays to make them dense after all pointers have been processed.
Initialize selectionDocument to an initial selection passing document as source to the algorithm in Section 3.4.11 createInitialSelection .
Set the value of the @context property in selectionDocument to a copy of the value of the @context property in document.
For each pointer in pointers, walk the document from root to the pointer target value, building the selectionDocument:
1. Parse the pointer into an array of paths, paths, using the algorithm in Section 3.4.10 jsonPointerToPaths .
2. Use the algorithm in Section 3.4.12 selectPaths , passing document, paths, selectionDocument, and arrays.
For each array in arrays:
1. Make array dense by removing any undefined elements between elements that are defined.
Return selectionDocument.

The following algorithm relabels the blank node identifiers in an array of N-Quad strings using a blank node label map. The required inputs are an array of N-Quad strings ( nquads ) and a blank node label map ( labelMap ). An array of N-Quad strings with relabeled blank node identifiers ( relabeledNQuads ) is produced as output.

Create a new array of N-Quad strings, relabeledNQuads .
For each N-Quad string, s1 , in nquads:
1. Create a new string, s2 , such it that is a copy of s1 except each blank node identifier therein has been replaced with the value associated with it as a key in labelMap.
2. Append s2 to relabeledNQuads .
Return relabeledNQuads .

The following algorithm selects a portion of a skolemized compact JSON-LD document using an array of JSON Pointers, and outputs the resulting canonical N-Quads with any blank node labels replaced using the given label map. The required inputs are an array of JSON Pointers ( pointers ), a skolemized compact JSON-LD document ( skolemizedCompactDocument ), and a blank node label map ( labelMap ). Additional custom options (such as a document loader) can be passed. The document is assumed to use a JSON-LD context that aliases @id and @type to id and type, respectively, and to use only one @context property at the top level of the document. An object containing the new JSON-LD document that represents a selection of the original JSON-LD document ( selectionDocument ), an array of deskolemized N-Quad strings ( deskolemizedNQuads ), and an array of canonical N-Quads with replacement blank node labels ( nquads ) is produced as output.

Initialize selectionDocument to the result of the algorithm in Section 3.4.13 selectJsonLd , passing pointers, and skolemizedCompactDocument as document .
Initialize deskolemizedNQuads to the result of the algorithm in Section 3.4.9 toDeskolemizedNQuads , passing selectionDocument as skolemizedCompactDocument, and any custom options.
Initialize nquads to the result of the algorithm in Section 3.4.14 relabelBlankNodes , passing labelMap, and deskolemizedNQuads as nquads.
Return an object containing selectionDocument, deskolemizedNQuads, and nquads.

The following algorithm is used to output canonical N-Quad strings that match custom selections of a compact JSON-LD document. It does this by canonicalizing a compact JSON-LD document (replacing any blank node identifiers using a label map) and grouping the resulting canonical N-Quad strings according to the selection associated with each group. Each group will be defined using an assigned name and array of JSON pointers. The JSON pointers will be used to select portions of the skolemized document, such that the output can be converted to canonical N-Quads to perform group matching.

The required inputs are a compact JSON-LD document ( document ), a label map factory function ( labelMapFactoryFunction ), and a map of named group definitions ( groupDefinitions ). Additional custom options (such as a document loader) can be passed. The document is assumed to use a JSON-LD context that aliases @id and @type to id and type, respectively, and to use only one @context property at the top level of the document. An object containing the created groups ( groups ), the skolemized compact JSON-LD document ( skolemizedCompactDocument ), the skolemized expanded JSON-LD document ( skolemizedExpandedDocument ), the deskolemized N-Quad strings ( deskolemizedNQuads ), the blank node label map ( labelMap ), and the canonical N-Quad strings nquads, is produced as output.

Initialize skolemizedExpandedDocument and skolemizedCompactDocument to their associated values in the result of the algorithm in Section 3.4.8 skolemizeCompactJsonLd , passing document and any custom options.
Initialize deskolemizedNQuads to the result of the algorithm in Section 3.4.9 toDeskolemizedNQuads , passing skolemizedExpandedDocument and any custom options.
Initialize nquads and labelMap to their associated values in the result of the algorithm in Section 3.4.1 labelReplacementCanonicalizeNQuads , passing labelMapFactoryFunction, deskolemizedNQuads as nquads, and any custom options.
Initialize selections to a new map.
For each key ( name ) and value ( pointers ) entry in groupDefinitions:
1. Add an entry with a key of name and a value that is the result of the algorithm in Section 3.4.15 selectCanonicalNQuads , passing pointers, labelMap, skolemizedCompactDocument as document, and any custom options.
Initialize groups to an empty object.
For each key ( name ) and value ( selectionResult ) entry in selections:
1. Initialize matching to an empty map.
2. Initialize nonMatching to an empty map.
3. Initialize selectedNQuads to nquads from selectionResult.
4. Initialize selectedDeskolemizedNQuads from deskolemizedNQuads from selectionResult.
5. For each element ( nq ) and index ( index ) in nquads:
  1. Create a map entry, entry, with a key of index and a value of nq.
  2. If selectedNQuads includes nq then add entry to matching ; otherwise, add entry to nonMatching.
6. Set name in groups to an object containing matching, nonMatching, and selectedDeskolemizedNQuads as deskolemizedNQuads.
Return an object containing groups, skolemizedExpandedDocument, skolemizedCompactDocument, deskolemizedNQuads, labelMap, and nquads.

The following algorithm cryptographically hashes an array of mandatory to disclose N-Quads using a provided hashing API. The required input is an array of mandatory to disclose N-Quads ( mandatory ) and a hashing function ( hasher ). A cryptographic hash ( mandatoryHash ) is produced as output.

Initialize bytes to the UTF-8 representation of the joined mandatory N-Quads.
Initialize mandatoryHash to the result of using hasher to hash bytes.
Return mandatoryHash.

This section contains subalgorithms that are useful to the ecdsa-sd-2023 cryptographic suite.

The following algorithm serializes the data that is to be signed by the private key associated with the base proof verification method. The required inputs are the proof options hash ( proofHash ), the proof-scoped multikey-encoded public key ( publicKey ), and the mandatory hash ( mandatoryHash ). A single sign data value, represented as series of bytes, is produced as output.

Return the concatenation of proofHash, publicKey, and mandatoryHash, in that order, as sign data .

The following algorithm serializes the base proof value, including the base signature, public key, HMAC key, signatures, and mandatory pointers. The required inputs are a base signature baseSignature, a public key publicKey, an HMAC key hmacKey, an array of signatures, and an array of mandatoryPointers. A single base proof string value is produced as output.

Initialize a byte array, proofValue, that starts with the ECDSA-SD base proof header bytes 0xd9, 0x5d, and 0x00.
Initialize components to an array with five elements containing the values of: baseSignature, publicKey, hmacKey, signatures, and mandatoryPointers.
CBOR-encode components per [ RFC8949 ] where CBOR tagging MUST NOT be used on any of the components. Append the produced encoded value to proofValue.
Initialize baseProof to a string with the Multibase base64url-no-pad-encoding of proofValue as described in the Multibase section of Controlled Identifiers v1.0 . That is, return a string starting with " u " and ending with the base64url-no-pad-encoded value of proofValue.
Return baseProof as base proof .

The following algorithm parses the components of an ecdsa-sd-2023 selective disclosure base proof value. The required inputs are a proof value ( proofValue ). A single object parsed base proof , containing five elements, using the names baseSignature, publicKey, hmacKey, signatures, and mandatoryPointers, is produced as output.

If the proofValue string does not start with u, indicating that it is a multibase-base64url-no-pad-encoded value, an error MUST be raised and SHOULD convey an error type of PROOF_VERIFICATION_ERROR .
Initialize decodedProofValue to the result of base64url-no-pad-decoding the substring after the leading u in proofValue.
If the decodedProofValue does not start with the ECDSA-SD base proof header bytes 0xd9, 0x5d, and 0x00, an error MUST be raised and SHOULD convey an error type of PROOF_VERIFICATION_ERROR .
Initialize components to an array that is the result of CBOR-decoding the bytes that follow the three-byte ECDSA-SD base proof header. Confirm that the result is an array of five elements.
Return an object with properties set to the five elements, using the names baseSignature, publicKey, hmacKey, signatures, and mandatoryPointers, respectively.

The following algorithm creates data to be used to generate a derived proof. The inputs include a JSON-LD document ( document ), an ECDSA-SD base proof ( proof ), an array of JSON pointers to use to selectively disclose statements ( selectivePointers ), and any custom JSON-LD API options, such as a document loader). A single object, disclosure data , is produced as output, which contains the "baseSignature", "publicKey", "signatures" for "filteredSignatures", "labelMap", "mandatoryIndexes", and "revealDocument" fields.

Initialize baseSignature, publicKey, hmacKey, signatures, and mandatoryPointers to the values of the associated properties in the object returned when calling the algorithm in Section 3.5.3 parseBaseProofValue , passing the proofValue from proof.
Initialize hmac to an HMAC API using hmacKey. The HMAC uses the same hash algorithm used in the signature algorithm, i.e., SHA-256 for a P-256 curve.
Initialize labelMapFactoryFunction to the result of calling the algorithm of section 3.4.4 createHmacIdLabelMapFunction , passing hmac.
Initialize combinedPointers to the concatenation of mandatoryPointers and selectivePointers.
Initialize groupDefinitions to a map with the following entries: key of the string "mandatory" and value of mandatoryPointers, key of the string "selective" and value of selectivePointers, and key of the string "combined" and value of combinedPointers.
Initialize groups and labelMap to their associated values in the result of calling the algorithm in Section 3.4.16 canonicalizeAndGroup , passing document, labelMapFactoryFunction, groupDefinitions, and any custom JSON-LD API options as parameters. Note: This step transforms the document into an array of canonical N-Quad strings with pseudorandom blank node identifiers based on hmac, and groups the N-Quad strings according to selections based on JSON pointers.
Initialize relativeIndex to zero.
Initialize mandatoryIndexes to an empty array.
For each absoluteIndex in the keys in groups. combined. matching, convert the absolute index of any mandatory N-Quad to an index relative to the combined output that is to be revealed:
1. If groups. mandatory. matching has absoluteIndex as a key, then append relativeIndex to mandatoryIndexes.
2. Increment relativeIndex.
Determine which signatures match a selectively disclosed statement, which requires incrementing an index counter while iterating over all signatures, skipping over any indexes that match the mandatory group.
1. Initialize index to 0.
2. Initialize filteredSignatures to an empty array.
3. For each signature in signatures:
  1. While index is in groups. mandatory. matching, increment index.
  2. If index is in groups. selective. matching, add signature to filteredSignatures.
  3. Increment index.
Initialize revealDocument to the result of the calling the algorithm in Section 3.4.13 selectJsonLd , passing document, and combinedPointers as pointers.
Run the RDF Dataset Canonicalization Algorithm [ RDF-CANON ] on the joined |combinedGroup.deskolemizedNQuads|, passing any custom options, and get the canonical bnode identifier map, canonicalIdMap. Note: This map includes the canonical blank node identifiers that a verifier will produce when they canonicalize the reveal document.
Initialize verifierLabelMap to an empty map. This map will map the canonical blank node identifiers the verifier will produce when they canonicalize the revealed document to the blank node identifiers that were originally signed in the base proof.
For each key ( inputLabel ) and value ( verifierLabel ) in canonicalIdMap:
1. Add an entry to verifierLabelMap using verifierLabel as the key and the value associated with inputLabel as a key in labelMap as the value.
Return an object with properties matching baseSignature, publicKey, signatures for filteredSignatures, verifierLabelMap for labelMap, mandatoryIndexes, and revealDocument.

The following algorithm compresses a label map. The required inputs are label map ( labelMap ). The output is a compressed label map .

Initialize map to an empty map.
For each entry ( k, v ) in labelMap:
1. Add an entry to map with a key that is a base-10 integer parsed from the characters following the "c14n" prefix in k and a value that is a byte array resulting from base64url-no-pad-decoding the characters after the "u" prefix in v.
Return map as compressed label map .

The following algorithm decompresses a label map. The required input is a compressed label map ( compressedLabelMap ). The output is a decompressed label map .

Initialize map to an empty map.
For each entry ( k, v ) in compressedLabelMap:
1. Add an entry to map with a key that adds the prefix "c14n" to k and a value that adds a prefix of "u" to the base64url-no-pad-encoded value for v.
Return map as decompressed label map .

The following algorithm serializes a derived proof value. The required inputs are a base signature ( baseSignature ), public key ( publicKey ), an array of signatures ( signatures ), a label map ( labelMap ), and an array of mandatory indexes ( mandatoryIndexes ). A single derived proof value, serialized as a byte string, is produced as output.

Initialize compressedLabelMap to the result of calling the algorithm in Section 3.5.5 compressLabelMap , passing labelMap as the parameter.
Initialize a byte array, proofValue, that starts with the ECDSA-SD disclosure proof header bytes 0xd9, 0x5d, and 0x01.
Initialize components to an array with five elements containing the values of: baseSignature, publicKey, signatures, compressedLabelMap, and mandatoryIndexes.
CBOR-encode components per [ RFC8949 ] where CBOR tagging MUST NOT be used on any of the components. Append the produced encoded value to proofValue.
Return the derived proof as a string with the base64url-no-pad-encoding of proofValue as described in the Multibase section of Controlled Identifiers v1.0 . That is, return a string starting with " u " and ending with the base64url-no-pad-encoded value of proofValue.

The following algorithm parses the components of the derived proof value. The required input is a derived proof value ( proofValue ). A single derived proof value value object is produced as output, which contains a set to five elements, using the names "baseSignature", "publicKey", "signatures", "labelMap", and "mandatoryIndexes".

If the proofValue string does not start with u, indicating that it is a multibase-base64url-no-pad-encoded value, an error MUST be raised and SHOULD convey an error type of PROOF_VERIFICATION_ERROR .
Initialize decodedProofValue to the result of base64url-no-pad-decoding the substring after the leading u in proofValue.
If the decodedProofValue does not start with the ECDSA-SD disclosure proof header bytes 0xd9, 0x5d, and 0x01, an error MUST be raised and SHOULD convey an error type of PROOF_VERIFICATION_ERROR .
Initialize components to an array that is the result of CBOR-decoding the bytes that follow the three-byte ECDSA-SD disclosure proof header. If the result is not an array of the following five elements — a byte array of length 64; a byte array of length 36; an array of byte arrays, each of length 64; a map of integers to byte arrays, each of length 32; and an array of integers — an error MUST be raised and SHOULD convey an error type of PROOF_VERIFICATION_ERROR .
Replace the fourth element in components using the result of calling the algorithm in Section 3.5.6 decompressLabelMap , passing the existing fourth element of components as compressedLabelMap.
Return derived proof value as an object with properties set to the five elements, using the names "baseSignature", "publicKey", "signatures", "labelMap", and "mandatoryIndexes", respectively.

The following algorithm creates the data needed to perform verification of an ECDSA-SD-protected verifiable credential . The inputs include a JSON-LD document ( document ), an ECDSA-SD disclosure proof ( proof ), and any custom JSON-LD API options, such as a document loader. A single verify data object value is produced as output containing the following fields: "baseSignature", "proofHash", "publicKey", "signatures", "nonMandatory", and "mandatoryHash".

Initialize proofHash to the result of perform RDF Dataset Canonicalization [ RDF-CANON ] on the proof options. The hash used is the same as the one used in the signature algorithm, i.e., SHA-256 for a P-256 curve. Note: This step can be performed in parallel; it only needs to be completed before this algorithm needs to use the proofHash value.
Initialize baseSignature, publicKey, signatures, labelMap, and mandatoryIndexes, to the values associated with their property names in the object returned when calling the algorithm in Section 3.5.8 parseDerivedProofValue , passing proofValue from proof.
Initialize labelMapFactoryFunction to the result of calling the algorithm of Section 3.4.3 createLabelMapFunction .
Initialize nquads to the result of calling the algorithm of section 3.4.2 labelReplacementCanonicalizeJsonLd , passing document, labelMapFactoryFunction, and any custom JSON-LD API options. Note: This step transforms the document into an array of canonical N-Quads with pseudorandom blank node identifiers based on labelMap.
Initialize mandatory to an empty array.
Initialize nonMandatory to an empty array.
For each entry ( index, nq ) in nquads, separate the N-Quads into mandatory and non-mandatory categories:
1. If mandatoryIndexes includes index, add nq to mandatory.
2. Otherwise, add nq to nonMandatory.
Initialize mandatoryHash to the result of calling the "hashMandatory" primitive, passing mandatory.
Return an object with properties matching baseSignature, proofHash, publicKey, signatures, nonMandatory, and mandatoryHash.

The ecdsa-sd-2023 cryptographic suite takes an input document, canonicalizes the document using the RDF Dataset Canonicalization [ RDF-CANON ], and then cryptographically hashes and signs the output resulting in the production of a data integrity proof. The algorithms in this section also include the verification of such a data integrity proof.

Let proof be a clone of the proof options, options.
Let proofConfig be the result of running the algorithm in Section 3.6.4 Base Proof Configuration (ecdsa-sd-2023) with options passed as a parameter.
Let transformedData be the result of running the algorithm in Section 3.6.2 Base Proof Transformation (ecdsa-sd-2023) with unsecuredDocument, proofConfig, and options passed as parameters.
Let hashData be the result of running the algorithm in Section 3.6.3 Base Proof Hashing (ecdsa-sd-2023) with transformedData and proofConfig passed as a parameters.
Let proofBytes be the result of running the algorithm in Section 3.6.5 Base Proof Serialization (ecdsa-sd-2023) with hashData and options passed as parameters.
Let proof. proofValue be a base64-url-encoded Multibase value of the proofBytes.
Return proof as the data integrity proof .

Required inputs to this algorithm are an unsecured data document ( unsecuredDocument ) and transformation options ( options ). The transformation options MUST contain a type identifier for the cryptographic suite ( type ), a cryptosuite identifier ( cryptosuite ), and a verification method ( verificationMethod ). The transformation options MUST contain an array of mandatory JSON pointers ( mandatoryPointers ) and MAY contain additional options, such as a JSON-LD document loader. A transformed data document is produced as output. Whenever this algorithm encodes strings, it MUST use UTF-8 encoding.

Initialize hmac to an HMAC API using a locally generated and exportable HMAC key. The HMAC uses the same hash algorithm used in the signature algorithm, which is detected via the verificationMethod provided to the function, i.e., SHA-256 for a P-256 curve. Per the recommendations of [ RFC2104 ], the HMAC key MUST be the same length as the digest size; for SHA-256, this is 256 bits or 32 bytes.
Initialize labelMapFactoryFunction to the result of calling the algorithm of Section 3.4.4 createHmacIdLabelMapFunction , passing hmac.
Initialize groupDefinitions to a map with an entry with a key of the string "mandatory" and a value of mandatoryPointers.
Initialize groups to the result of calling the algorithm in Section 3.4.16 canonicalizeAndGroup , passing labelMapFactoryFunction, groupDefinitions, unsecuredDocument as document, and any custom JSON-LD API options. Note: This step transforms the document into an array of canonical N-Quads with pseudorandom blank node identifiers based on hmac, and groups the N-Quad strings according to selections based on JSON pointers.
Initialize mandatory to the values in the groups. mandatory. matching map.
Initialize nonMandatory to the values in the groups. mandatory. nonMatching map.
Initialize hmacKey to the result of exporting the HMAC key from hmac.
Return an object with mandatoryPointers set to mandatoryPointers, mandatory set to mandatory, nonMandatory set to nonMandatory, and hmacKey set to hmacKey.

The required inputs to this algorithm are a transformed data document ( transformedDocument ) and canonical proof configuration ( canonicalProofConfig ). A hash data value represented as an object is produced as output.

Initialize proofHash to the result of calling the RDF Dataset Canonicalization algorithm [ RDF-CANON ] on canonicalProofConfig and then cryptographically hashing the result using the same hash that is used by the signature algorithm, i.e., SHA-256 for a P-256 curve. Note: This step can be performed in parallel; it only needs to be completed before this algorithm terminates as the result is part of the return value.
Initialize mandatoryHash to the result of calling the the algorithm in Section 3.4.17 hashMandatoryNQuads , passing transformedDocument. mandatory.
Initialize hashData as a deep copy of transformedDocument and add proofHash as proofHash and mandatoryHash as mandatoryHash to that object.
Return hashData as hash data .

The following algorithm specifies how to generate a proof configuration from a set of proof options that is used as input to the base proof hashing algorithm .

The required inputs to this algorithm are proof options ( options ) and the unsecured data document ( unsecuredDocument ). The proof options MUST contain a type identifier for the cryptographic suite ( type ) and MUST contain a cryptosuite identifier ( cryptosuite ). A proof configuration object is produced as output.

Let proofConfig be a clone of the options object.
If proofConfig. type is not set to DataIntegrityProof and/or proofConfig. cryptosuite is not set to ecdsa-sd-2023, an error MUST be raised and SHOULD convey an error type of PROOF_GENERATION_ERROR .
If proofConfig. created is set and if the value is not a valid [ XMLSCHEMA11-2 ] datetime, an error MUST be raised and SHOULD convey an error type of PROOF_GENERATION_ERROR .
Set proofConfig. @context to unsecuredDocument. @context.
Let canonicalProofConfig be the result of applying the RDF Dataset Canonicalization [ RDF-CANON ] to the proofConfig.
Return canonicalProofConfig.

The following algorithm specifies how to create a base proof; called by an issuer of an ECDSA-SD-protected Verifiable Credential. The base proof is to be given only to the holder, who is responsible for generating a derived proof from it, exposing only selectively disclosed details in the proof to a verifier. This algorithm is designed to be used in conjunction with the algorithms defined in the Data Integrity [ VC-DATA-INTEGRITY ] specification, Section 4: Algorithms . Required inputs are cryptographic hash data ( hashData ) and proof options ( options ). The proof options MUST contain a type identifier for the cryptographic suite ( type ) and MAY contain a cryptosuite identifier ( cryptosuite ). A single digital proof value represented as series of bytes is produced as output.

Initialize proofHash, mandatoryPointers, mandatoryHash, nonMandatory, and hmacKey to the values associated with their property names hashData.
Initialize proofScopedKeyPair to a locally generated P-256 ECDSA key pair. Note: This key pair is scoped to the specific proof; it is not used for anything else and the private key will be destroyed when this algorithm terminates.
Initialize signatures to an array where each element holds the result of digitally signing the UTF-8 representation of each N-Quad string in nonMandatory, in order. The digital signature algorithm is ES256, i.e., uses a P-256 curve over a SHA-256 digest, and uses the private key from proofScopedKeyPair. Note: This step generates individual signatures for each statement that can be selectively disclosed using a local, proof-scoped key pair that binds them together; this key pair will be bound to the proof by a signature over its public key using the private key associated with the base proof verification method.
Initialize publicKey to the multikey expression of the public key exported from proofScopedKeyPair. That is, an array of bytes starting with the bytes 0x80 and 0x24 (which is the multikey p256-pub header (0x1200) expressed as a varint) followed by the compressed public key bytes (the compressed header with 2 for an even y coordinate and 3 for an odd one followed by the x coordinate of the public key).
Initialize toSign to the result of calling the algorithm in Section 3.5.1 serializeSignData , passing proofHash, publicKey, and mandatoryHash as parameters to the algorithm.
Initialize baseSignature to the result of digitally signing toSign using the private key associated with the base proof verification method.
Initialize proofValue to the result of calling the algorithm in Section 3.5.2 serializeBaseProofValue , passing baseSignature, publicKey, hmacKey, signatures, and mandatoryPointers as parameters to the algorithm.
Return proofValue as digital proof .

The following algorithm creates a selective disclosure derived proof; called by a holder of an ecdsa-sd-2023 -protected verifiable credential . The derived proof is to be given to the verifier . The inputs include a JSON-LD document ( document ), an ECDSA-SD base proof ( proof ), an array of JSON pointers to use to selectively disclose statements ( selectivePointers ), and any custom JSON-LD API options, such as a document loader. A single selectively revealed document value, represented as an object, is produced as output.

Initialize baseSignature, publicKey, signatures, labelMap, mandatoryIndexes, revealDocument to the values associated with their property names in the object returned when calling the algorithm in Section 3.5.4 createDisclosureData , passing the document, proof, selectivePointers, and any custom JSON-LD API options, such as a document loader.
Initialize newProof to a shallow copy of proof.
Replace proofValue in newProof with the result of calling the algorithm in Section 3.5.7 serializeDerivedProofValue , passing baseSignature, publicKey, signatures, labelMap, and mandatoryIndexes.
Set the value of the "proof" property in revealDocument to newProof.
Return revealDocument as the selectively revealed document .

The following algorithm attempts verification of an ecdsa-sd-2023 derived proof. This algorithm is called by a verifier of an ECDSA-SD-protected verifiable credential . The inputs include a JSON-LD document ( document ), an ECDSA-SD disclosure proof ( proof ), and any custom JSON-LD API options, such as a document loader. This algorithm returns a verification result :

Let unsecuredDocument be a copy of document with the proof value removed.
Initialize baseSignature, proofHash, publicKey, signatures, nonMandatory, and mandatoryHash to the values associated with their property names in the object returned when calling the algorithm in Section 3.5.9 createVerifyData , passing the document, proof, and any custom JSON-LD API options, such as a document loader.
If the length of signatures does not match the length of nonMandatory, an error MUST be raised and SHOULD convey an error type of PROOF_VERIFICATION_ERROR , indicating that the signature count does not match the non-mandatory message count.
Initialize publicKeyBytes to the public key bytes expressed in publicKey. Instructions on how to decode the public key value can be found in Section 2.1.1 Multikey .
Initialize toVerify to the result of calling the algorithm in Setion 3.5.1 serializeSignData , passing proofHash, publicKey, and mandatoryHash.
Initialize verified to true.
Initialize verificationCheck be the result of applying the verification algorithm of the Elliptic Curve Digital Signature Algorithm (ECDSA) [FIPS-186-5], with toVerify as the data to be verified against the baseSignature using the public key specified by publicKeyBytes. If verificationCheck is false, set verified to false.
For every entry ( index, signature ) in signatures, verify every signature for every selectively disclosed (non-mandatory) statement:
1. Initialize verificationCheck to the result of applying the verification algorithm Elliptic Curve Digital Signature Algorithm (ECDSA) [FIPS-186-5], with the UTF-8 representation of the value at index of nonMandatory as the data to be verified against signature using the public key specified by publicKeyBytes.
2. If verificationCheck is false, set verified to false.
Return a verification result with items :

verified

The value of verified

verifiedDocument

unsecuredDocument if verified is true, otherwise Null

This section is non-normative.

Note

All test vectors are produced using deterministic ECDSA . The implementation was validated against the test vectors in [ RFC6979 ].

The signer needs to generate a private/public key pair with the private key used for signing and the public key made available for verification. The representation of the public key, and the representation of the private key, are shown below.

Example 5 : Private and Public keys for Signature

{
  "publicKeyMultibase": "zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
  "secretKeyMultibase": "z42twTcNeSYcnqg1FLuSFs2bsGH3ZqbRHFmvS9XMsYhjxvHN"
}

Signing begins with a credential without an attached proof, which is converted to canonical form, which is then hashed, as shown in the following three examples.

Example 6 : Credential without Proof

{
    "@context": [
        "https://www.w3.org/ns/credentials/v2",
        "https://www.w3.org/ns/credentials/examples/v2"
    ],
    "id": "urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33",
    "type": ["VerifiableCredential", "AlumniCredential"],
    "name": "Alumni Credential",
    "description": "A minimum viable example of an Alumni Credential.",
    "issuer": "https://vc.example/issuers/5678",
    "validFrom": "2023-01-01T00:00:00Z",
    "credentialSubject": {
        "id": "did:example:abcdefgh",
        "alumniOf": "The School of Examples"
    }
}

Example 7 : Canonical Credential without Proof

<did:example:abcdefgh> <https://www.w3.org/ns/credentials/examples#alumniOf> "The School of Examples" .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/2018/credentials#VerifiableCredential> .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/ns/credentials/examples#AlumniCredential> .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <https://schema.org/description> "A minimum viable example of an Alumni Credential." .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <https://schema.org/name> "Alumni Credential" .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <https://www.w3.org/2018/credentials#credentialSubject> <did:example:abcdefgh> .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <https://www.w3.org/2018/credentials#issuer> <https://vc.example/issuers/5678> .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33>
<https://www.w3.org/2018/credentials#validFrom>
"2023-01-01T00:00:00Z"^^<http://www.w3.org/2001/XMLSchema#dateTime>
.

Example 8 : Hash of Canonical Credential without Proof (hex)

517744132ae165a5349155bef0bb0cf2258fff99dfe1dbd914b938d775a36017

The next step is to take the proof options document, convert it to canonical form, and obtain its hash, as shown in the next three examples.

Example 9 : Proof Options Document

{
  "type": "DataIntegrityProof",
  "cryptosuite": "ecdsa-rdfc-2019",
  "created": "2023-02-24T23:36:38Z",
  "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
  "proofPurpose": "assertionMethod",
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://www.w3.org/ns/credentials/examples/v2"
  ]
}

Example 10 : Canonical Proof Options Document

_:c14n0 <http://purl.org/dc/terms/created> "2023-02-24T23:36:38Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/security#DataIntegrityProof> .
_:c14n0 <https://w3id.org/security#cryptosuite> "ecdsa-rdfc-2019"^^<https://w3id.org/security#cryptosuiteString> .
_:c14n0 <https://w3id.org/security#proofPurpose> <https://w3id.org/security#assertionMethod> .
_:c14n0
<https://w3id.org/security#verificationMethod>
<did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP>
.

Example 11 : Hash of Canonical Proof Options Document (hex)

3a8a522f689025727fb9d1f0fa99a618da023e8494ac74f51015d009d35abc2e

Finally, we concatenate the hash of the proof options followed by the hash of the credential without proof, use the private key with the combined hash to compute the ECDSA signature, and then base-58-btc encode the signature.

Example 12 : Combine hashes of Proof Options and Credential (hex)

3a8a522f689025727fb9d1f0fa99a618da023e8494ac74f51015d009d35abc2e517744132ae165a5349155bef0bb0cf2258fff99dfe1dbd914b938d775a36017

Example 13 : Signature of Combined Hashes (hex)

1cb4290918ffb04a55ff7ae1e55e316a9990fda8eec67325eac7fcbf2ddf9dd2b06716a657e72b284c9604df3a172ecbf06a1a475b49ac807b1d9162df855636

Example 14 : Signature of Combined Hashes base-58-btc

zaHXrr7AQdydBk3ahpCDpWbxfLokDqmCToYm2dyWvpcFVyWooC2he63w1f7UNQoAMKdhaRtcnaE2KTo5o5vTCcfw

Assemble the signed credential with the following two steps:

Add the proofValue field with the previously computed base-58-btc value to the proof options document.
Set the proof field of the credential to the augmented proof option document.

Example 15 : Signed Credential

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://www.w3.org/ns/credentials/examples/v2"
  ],
  "id": "urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33",
  "type": [
    "VerifiableCredential",
    "AlumniCredential"
  ],
  "name": "Alumni Credential",
  "description": "A minimum viable example of an Alumni Credential.",
  "issuer": "https://vc.example/issuers/5678",
  "validFrom": "2023-01-01T00:00:00Z",
  "credentialSubject": {
    "id": "did:example:abcdefgh",
    "alumniOf": "The School of Examples"
  },
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "ecdsa-rdfc-2019",
    "created": "2023-02-24T23:36:38Z",
    "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
    "proofPurpose": "assertionMethod",
    "proofValue": "zaHXrr7AQdydBk3ahpCDpWbxfLokDqmCToYm2dyWvpcFVyWooC2he63w1f7UNQoAMKdhaRtcnaE2KTo5o5vTCcfw"
  }
}

Here we again go through the steps of creating an ecdsa-rdfc-2019 with curve P-256 signed credential but with a more complicated input document. The representation of the public key, and the representation of the private key, are shown below.

Example 16 : Private and Public keys for Signature

{
  "publicKeyMultibase": "zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
  "secretKeyMultibase": "z42twTcNeSYcnqg1FLuSFs2bsGH3ZqbRHFmvS9XMsYhjxvHN"
}

Signing begins with a credential without an attached proof, which is converted to canonical form, which is then hashed, as shown in the following three examples.

Example 17 : Employment Authorization Credential without Proof

{
    "@context": [
      "https://www.w3.org/ns/credentials/v2",
      "https://w3id.org/citizenship/v4rc1"
    ],
    "type": [
      "VerifiableCredential",
      "EmploymentAuthorizationDocumentCredential"
    ],
    "issuer": {
      "id": "did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76",
      "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg=="
    },
    "credentialSubject": {
      "type": [
        "Person",
        "EmployablePerson"
      ],
      "givenName": "JOHN",
      "additionalName": "JACOB",
      "familyName": "SMITH",
      "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2Ng+M/wHwAEAQH/7yMK/gAAAABJRU5ErkJggg==",
      "gender": "Male",
      "residentSince": "2015-01-01",
      "birthCountry": "Bahamas",
      "birthDate": "1999-07-17",
      "employmentAuthorizationDocument": {
        "type": "EmploymentAuthorizationDocument",
        "identifier": "83627465",
        "lprCategory": "C09",
        "lprNumber": "999-999-999"
      }
    },
    "name": "Employment Authorization Document",
    "description": "Example Employment Authorization Document.",
    "validFrom": "2019-12-03T00:00:00Z",
    "validUntil": "2029-12-03T00:00:00Z"
}

Example 18 : Canonical Employment Authorization Credential without Proof

<did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76> <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg==> .
_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmploymentAuthorizationDocumentCredential> .
_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/2018/credentials#VerifiableCredential> .
_:c14n0 <https://schema.org/description> "Example Employment Authorization Document." .
_:c14n0 <https://schema.org/name> "Employment Authorization Document" .
_:c14n0 <https://www.w3.org/2018/credentials#credentialSubject> _:c14n1 .
_:c14n0 <https://www.w3.org/2018/credentials#issuer> <did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76> .
_:c14n0 <https://www.w3.org/2018/credentials#validFrom> "2019-12-03T00:00:00Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n0 <https://www.w3.org/2018/credentials#validUntil> "2029-12-03T00:00:00Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://schema.org/Person> .
_:c14n1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmployablePerson> .
_:c14n1 <https://schema.org/additionalName> "JACOB" .
_:c14n1 <https://schema.org/birthDate> "1999-07-17"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n1 <https://schema.org/familyName> "SMITH" .
_:c14n1 <https://schema.org/gender> "Male" .
_:c14n1 <https://schema.org/givenName> "JOHN" .
_:c14n1 <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2Ng+M/wHwAEAQH/7yMK/gAAAABJRU5ErkJggg==> .
_:c14n1 <https://w3id.org/citizenship#birthCountry> "Bahamas" .
_:c14n1 <https://w3id.org/citizenship#employmentAuthorizationDocument> _:c14n2 .
_:c14n1 <https://w3id.org/citizenship#residentSince> "2015-01-01"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmploymentAuthorizationDocument> .
_:c14n2 <https://schema.org/identifier> "83627465" .
_:c14n2 <https://w3id.org/citizenship#lprCategory> "C09" .
_:c14n2
<https://w3id.org/citizenship#lprNumber>
"999-999-999"
.

Example 19 : Hash of Canonical Credential without Proof (hex)

03f59e5b04ab575b1172cb684f22eede72f0e9033e0b5c67d0e2506768d6ce11

The next step is to take the proof options document, convert it to canonical form, and obtain its hash, as shown in the next three examples.

Example 20 : Proof Options Document

{
  "type": "DataIntegrityProof",
  "cryptosuite": "ecdsa-rdfc-2019",
  "created": "2023-02-24T23:36:38Z",
  "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
  "proofPurpose": "assertionMethod",
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ]
}

Example 21 : Canonical Proof Options Document

_:c14n0 <http://purl.org/dc/terms/created> "2023-02-24T23:36:38Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/security#DataIntegrityProof> .
_:c14n0 <https://w3id.org/security#cryptosuite> "ecdsa-rdfc-2019"^^<https://w3id.org/security#cryptosuiteString> .
_:c14n0 <https://w3id.org/security#proofPurpose> <https://w3id.org/security#assertionMethod> .
_:c14n0
<https://w3id.org/security#verificationMethod>
<did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP>
.

Example 22 : Hash of Canonical Proof Options Document (hex)

3a8a522f689025727fb9d1f0fa99a618da023e8494ac74f51015d009d35abc2e

Example 23 : Combine hashes of Proof Options and Credential (hex)

3a8a522f689025727fb9d1f0fa99a618da023e8494ac74f51015d009d35abc2e03f59e5b04ab575b1172cb684f22eede72f0e9033e0b5c67d0e2506768d6ce11

Example 24 : Signature of Combined Hashes (hex)

c6798ff29f725dfd39aa4daf60fbb423cf9baf4e157f6b49f112c201015c6e730dc877154e65cf467f8ee2b61ec86d98ed78334b1cc9f3dba2e1745f37205e92

Example 25 : Signature of Combined Hashes base-58-btc

z4y9rJ7JxwfZZUBAHgDHJh7FzMbsycPhEtcSHqrfyn7fx3S5MWdajNu1r6SsJmirzfcWHe7vp9XKHmRqW6qe7u3d3

Assemble the signed credential with the following two steps:

Add the proofValue field with the previously computed base-58-btc value to the proof options document.
Set the proof field of the credential to the augmented proof option document.

Example 26 : Signed Employment Authorization Credential

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ],
  "type": [
    "VerifiableCredential",
    "EmploymentAuthorizationDocumentCredential"
  ],
  "issuer": {
    "id": "did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg=="
  },
  "credentialSubject": {
    "type": [
      "Person",
      "EmployablePerson"
    ],
    "givenName": "JOHN",
    "additionalName": "JACOB",
    "familyName": "SMITH",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2Ng+M/wHwAEAQH/7yMK/gAAAABJRU5ErkJggg==",
    "gender": "Male",
    "residentSince": "2015-01-01",
    "birthCountry": "Bahamas",
    "birthDate": "1999-07-17",
    "employmentAuthorizationDocument": {
      "type": "EmploymentAuthorizationDocument",
      "identifier": "83627465",
      "lprCategory": "C09",
      "lprNumber": "999-999-999"
    }
  },
  "name": "Employment Authorization Document",
  "description": "Example Employment Authorization Document.",
  "validFrom": "2019-12-03T00:00:00Z",
  "validUntil": "2029-12-03T00:00:00Z",
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "ecdsa-rdfc-2019",
    "created": "2023-02-24T23:36:38Z",
    "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
    "proofPurpose": "assertionMethod",
    "proofValue": "z4y9rJ7JxwfZZUBAHgDHJh7FzMbsycPhEtcSHqrfyn7fx3S5MWdajNu1r6SsJmirzfcWHe7vp9XKHmRqW6qe7u3d3"
  }
}

Example 27 : Private and Public keys for Signature

{
  "publicKeyMultibase": "z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ",
  "secretKeyMultibase": "z2fanyY7zgwNpZGxX5fXXibvScNaUWNprHU9dKx7qpVj7mws9J8LLt4mDB5TyH2GLHWkUc"
}

Signing begins with a credential without an attached proof, which is converted to canonical form, and then hashed, as shown in the following three examples.

Example 28 : Credential without Proof

{
    "@context": [
        "https://www.w3.org/ns/credentials/v2",
        "https://www.w3.org/ns/credentials/examples/v2"
    ],
    "id": "urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33",
    "type": ["VerifiableCredential", "AlumniCredential"],
    "name": "Alumni Credential",
    "description": "A minimum viable example of an Alumni Credential.",
    "issuer": "https://vc.example/issuers/5678",
    "validFrom": "2023-01-01T00:00:00Z",
    "credentialSubject": {
        "id": "did:example:abcdefgh",
        "alumniOf": "The School of Examples"
    }
}

Example 29 : Canonical Credential without Proof

<did:example:abcdefgh> <https://www.w3.org/ns/credentials/examples#alumniOf> "The School of Examples" .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/2018/credentials#VerifiableCredential> .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/ns/credentials/examples#AlumniCredential> .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <https://schema.org/description> "A minimum viable example of an Alumni Credential." .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <https://schema.org/name> "Alumni Credential" .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <https://www.w3.org/2018/credentials#credentialSubject> <did:example:abcdefgh> .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33> <https://www.w3.org/2018/credentials#issuer> <https://vc.example/issuers/5678> .
<urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33>
<https://www.w3.org/2018/credentials#validFrom>
"2023-01-01T00:00:00Z"^^<http://www.w3.org/2001/XMLSchema#dateTime>
.

Example 30 : Hash of Canonical Credential without Proof (hex)

8bf6e01df72c5b62f91b685231915ac4b8c58ea95f002c6b8f6bfafa1b251df476b56b8e01518e317dab099d3ecbff96

The next step is to take the proof options document, convert it to canonical form, and obtain its hash, as shown in the next three examples.

Example 31 : Proof Options Document

{
  "type": "DataIntegrityProof",
  "cryptosuite": "ecdsa-rdfc-2019",
  "created": "2023-02-24T23:36:38Z",
  "verificationMethod": "did:key:z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ#z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ",
  "proofPurpose": "assertionMethod",
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://www.w3.org/ns/credentials/examples/v2"
  ]
}

Example 32 : Canonical Proof Options Document

_:c14n0 <http://purl.org/dc/terms/created> "2023-02-24T23:36:38Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/security#DataIntegrityProof> .
_:c14n0 <https://w3id.org/security#cryptosuite> "ecdsa-rdfc-2019"^^<https://w3id.org/security#cryptosuiteString> .
_:c14n0 <https://w3id.org/security#proofPurpose> <https://w3id.org/security#assertionMethod> .
_:c14n0
<https://w3id.org/security#verificationMethod>
<did:key:z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ#z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ>
.

Example 33 : Hash of Canonical Proof Options Document (hex)

e32805a26492eac777aa7a138f6d8da3c74e0c7be7b296dcaccf97420c3b92eaad7be6449ca565e165031567f5c7cbc1

Example 34 : Combine hashes of Proof Options and Credential (hex)

e32805a26492eac777aa7a138f6d8da3c74e0c7be7b296dcaccf97420c3b92eaad7be6449ca565e165031567f5c7cbc18bf6e01df72c5b62f91b685231915ac4b8c58ea95f002c6b8f6bfafa1b251df476b56b8e01518e317dab099d3ecbff96

Example 35 : Signature of Combined Hashes (hex)

177ac088806c2506d49f0bfec16056a6a80ace62cd029888ad561aba22a59d192d77d9b1fc28df80dea5ee6c8bceb16f1b8bff6bd6ff2d8f8778bdde48bafa7b6cc1f914c0168b5c04499882f632deea9cb7d977e888bb0e1ee9fb20ff03b025

Example 36 : Signature of Combined Hashes base-58-btc

z967Mvv5bxtmLNqTzPZ8KmJjFmFXaAKeQNzq7GWnQkMcLtaGSSmuozE5WtJ8PipMe178B1tE28K1vsJur9bGVJhz6jgSJsRHFSQeqgH8hhjcg8gZDFJC1b9FsR5ggNmDBqHv

Assemble the signed credential with the following two steps:

Add the proofValue field with the previously computed base-58-btc value to the proof options document.
Set the proof field of the credential to the augmented proof option document.

Example 37 : Signed Credential

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://www.w3.org/ns/credentials/examples/v2"
  ],
  "id": "urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33",
  "type": [
    "VerifiableCredential",
    "AlumniCredential"
  ],
  "name": "Alumni Credential",
  "description": "A minimum viable example of an Alumni Credential.",
  "issuer": "https://vc.example/issuers/5678",
  "validFrom": "2023-01-01T00:00:00Z",
  "credentialSubject": {
    "id": "did:example:abcdefgh",
    "alumniOf": "The School of Examples"
  },
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "ecdsa-rdfc-2019",
    "created": "2023-02-24T23:36:38Z",
    "verificationMethod": "did:key:z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ#z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ",
    "proofPurpose": "assertionMethod",
    "proofValue": "z967Mvv5bxtmLNqTzPZ8KmJjFmFXaAKeQNzq7GWnQkMcLtaGSSmuozE5WtJ8PipMe178B1tE28K1vsJur9bGVJhz6jgSJsRHFSQeqgH8hhjcg8gZDFJC1b9FsR5ggNmDBqHv"
  }
}

Here we again go through the steps of creating an ecdsa-rdfc-2019 with curve P-384 signed credential but with a more complicated input document. The representation of the public key, and the representation of the private key, are shown below.

Example 38 : Private and Public keys for Signature

{
  "publicKeyMultibase": "z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ",
  "secretKeyMultibase": "z2fanyY7zgwNpZGxX5fXXibvScNaUWNprHU9dKx7qpVj7mws9J8LLt4mDB5TyH2GLHWkUc"
}

Signing begins with a credential without an attached proof, which is converted to canonical form, and then hashed, as shown in the following three examples.

Example 39 : Employment Authorization Credential without Proof

{
    "@context": [
      "https://www.w3.org/ns/credentials/v2",
      "https://w3id.org/citizenship/v4rc1"
    ],
    "type": [
      "VerifiableCredential",
      "EmploymentAuthorizationDocumentCredential"
    ],
    "issuer": {
      "id": "did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76",
      "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg=="
    },
    "credentialSubject": {
      "type": [
        "Person",
        "EmployablePerson"
      ],
      "givenName": "JOHN",
      "additionalName": "JACOB",
      "familyName": "SMITH",
      "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2Ng+M/wHwAEAQH/7yMK/gAAAABJRU5ErkJggg==",
      "gender": "Male",
      "residentSince": "2015-01-01",
      "birthCountry": "Bahamas",
      "birthDate": "1999-07-17",
      "employmentAuthorizationDocument": {
        "type": "EmploymentAuthorizationDocument",
        "identifier": "83627465",
        "lprCategory": "C09",
        "lprNumber": "999-999-999"
      }
    },
    "name": "Employment Authorization Document",
    "description": "Example Employment Authorization Document.",
    "validFrom": "2019-12-03T00:00:00Z",
    "validUntil": "2029-12-03T00:00:00Z"
}

Example 40 : Canonical Employment Authorization Credential without Proof

<did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76> <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg==> .
_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmploymentAuthorizationDocument> .
_:c14n0 <https://schema.org/identifier> "83627465" .
_:c14n0 <https://w3id.org/citizenship#lprCategory> "C09" .
_:c14n0 <https://w3id.org/citizenship#lprNumber> "999-999-999" .
_:c14n1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://schema.org/Person> .
_:c14n1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmployablePerson> .
_:c14n1 <https://schema.org/additionalName> "JACOB" .
_:c14n1 <https://schema.org/birthDate> "1999-07-17"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n1 <https://schema.org/familyName> "SMITH" .
_:c14n1 <https://schema.org/gender> "Male" .
_:c14n1 <https://schema.org/givenName> "JOHN" .
_:c14n1 <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2Ng+M/wHwAEAQH/7yMK/gAAAABJRU5ErkJggg==> .
_:c14n1 <https://w3id.org/citizenship#birthCountry> "Bahamas" .
_:c14n1 <https://w3id.org/citizenship#employmentAuthorizationDocument> _:c14n0 .
_:c14n1 <https://w3id.org/citizenship#residentSince> "2015-01-01"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmploymentAuthorizationDocumentCredential> .
_:c14n2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/2018/credentials#VerifiableCredential> .
_:c14n2 <https://schema.org/description> "Example Employment Authorization Document." .
_:c14n2 <https://schema.org/name> "Employment Authorization Document" .
_:c14n2 <https://www.w3.org/2018/credentials#credentialSubject> _:c14n1 .
_:c14n2 <https://www.w3.org/2018/credentials#issuer> <did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76> .
_:c14n2 <https://www.w3.org/2018/credentials#validFrom> "2019-12-03T00:00:00Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n2
<https://www.w3.org/2018/credentials#validUntil>
"2029-12-03T00:00:00Z"^^<http://www.w3.org/2001/XMLSchema#dateTime>
.

Example 41 : Hash of Canonical Credential without Proof (hex)

1033878f36ffb458c6495fec9c8814dad5215aad131041e6667db28fef6ea718d0de0eb4546bf527746ad2bc908a4320

The next step is to take the proof options document, convert it to canonical form, and obtain its hash, as shown in the next three examples.

Example 42 : Proof Options Document

{
  "type": "DataIntegrityProof",
  "cryptosuite": "ecdsa-rdfc-2019",
  "created": "2023-02-24T23:36:38Z",
  "verificationMethod": "did:key:z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ#z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ",
  "proofPurpose": "assertionMethod",
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ]
}

Example 43 : Canonical Proof Options Document

_:c14n0 <http://purl.org/dc/terms/created> "2023-02-24T23:36:38Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/security#DataIntegrityProof> .
_:c14n0 <https://w3id.org/security#cryptosuite> "ecdsa-rdfc-2019"^^<https://w3id.org/security#cryptosuiteString> .
_:c14n0 <https://w3id.org/security#proofPurpose> <https://w3id.org/security#assertionMethod> .
_:c14n0
<https://w3id.org/security#verificationMethod>
<did:key:z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ#z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ>
.

Example 44 : Hash of Canonical Proof Options Document (hex)

e32805a26492eac777aa7a138f6d8da3c74e0c7be7b296dcaccf97420c3b92eaad7be6449ca565e165031567f5c7cbc1

Example 45 : Combine hashes of Proof Options and Credential (hex)

e32805a26492eac777aa7a138f6d8da3c74e0c7be7b296dcaccf97420c3b92eaad7be6449ca565e165031567f5c7cbc11033878f36ffb458c6495fec9c8814dad5215aad131041e6667db28fef6ea718d0de0eb4546bf527746ad2bc908a4320

Example 46 : Signature of Combined Hashes (hex)

a5999d1154a3fb5db8805fa762c8c41c1b7f40a231a5d42460d36245349771835f43fe0005295d2061be1789589c1f6385312f0e2e36709c310c77e8289587b79b29ecf7aad14ef61a1393cc2e1f93a7a354bd76bab47d558df060c6ae218975

Example 47 : Signature of Combined Hashes base-58-btc

zz3ca1oME3iYPHM8SgApWFUFVQjiaL9moPqCZ1NAENj3biEQ34qc1ex5VJNLD4jh4N4MY2cmDyDCYGv7EyD87yCGYwag8wRwiJE1xiHKLhTEhDQFNfuNMsgLiZnqpkCDJPye

Assemble the signed credential with the following two steps:

Add the proofValue field with the previously computed base-58-btc value to the proof options document.
Set the proof field of the credential to the augmented proof option document.

Example 48 : Signed Employment Authorization Credential

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ],
  "type": [
    "VerifiableCredential",
    "EmploymentAuthorizationDocumentCredential"
  ],
  "issuer": {
    "id": "did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg=="
  },
  "credentialSubject": {
    "type": [
      "Person",
      "EmployablePerson"
    ],
    "givenName": "JOHN",
    "additionalName": "JACOB",
    "familyName": "SMITH",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2Ng+M/wHwAEAQH/7yMK/gAAAABJRU5ErkJggg==",
    "gender": "Male",
    "residentSince": "2015-01-01",
    "birthCountry": "Bahamas",
    "birthDate": "1999-07-17",
    "employmentAuthorizationDocument": {
      "type": "EmploymentAuthorizationDocument",
      "identifier": "83627465",
      "lprCategory": "C09",
      "lprNumber": "999-999-999"
    }
  },
  "name": "Employment Authorization Document",
  "description": "Example Employment Authorization Document.",
  "validFrom": "2019-12-03T00:00:00Z",
  "validUntil": "2029-12-03T00:00:00Z",
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "ecdsa-rdfc-2019",
    "created": "2023-02-24T23:36:38Z",
    "verificationMethod": "did:key:z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ#z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ",
    "proofPurpose": "assertionMethod",
    "proofValue": "zz3ca1oME3iYPHM8SgApWFUFVQjiaL9moPqCZ1NAENj3biEQ34qc1ex5VJNLD4jh4N4MY2cmDyDCYGv7EyD87yCGYwag8wRwiJE1xiHKLhTEhDQFNfuNMsgLiZnqpkCDJPye"
  }
}

Example 49 : Private and Public keys for Signature

{
  "publicKeyMultibase": "zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
  "secretKeyMultibase": "z42twTcNeSYcnqg1FLuSFs2bsGH3ZqbRHFmvS9XMsYhjxvHN"
}

Signing begins with a credential without an attached proof, which is converted to canonical form, which is then hashed, as shown in the following three examples.

Example 50 : Credential without Proof

{
    "@context": [
        "https://www.w3.org/ns/credentials/v2",
        "https://www.w3.org/ns/credentials/examples/v2"
    ],
    "id": "urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33",
    "type": ["VerifiableCredential", "AlumniCredential"],
    "name": "Alumni Credential",
    "description": "A minimum viable example of an Alumni Credential.",
    "issuer": "https://vc.example/issuers/5678",
    "validFrom": "2023-01-01T00:00:00Z",
    "credentialSubject": {
        "id": "did:example:abcdefgh",
        "alumniOf": "The School of Examples"
    }
}

Example 51 : Canonical Credential without Proof

{"@context":["https://www.w3.org/ns/credentials/v2","https://www.w3.org/ns/credentials/examples/v2"],"credentialSubject":{"alumniOf":"The
School
of
Examples","id":"did:example:abcdefgh"},"description":"A
minimum
viable
example
of
an
Alumni
Credential.","id":"urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33","issuer":"https://vc.example/issuers/5678","name":"Alumni
Credential","type":["VerifiableCredential","AlumniCredential"],"validFrom":"2023-01-01T00:00:00Z"}

Example 52 : Hash of Canonical Credential without Proof (hex)

59b7cb6251b8991add1ce0bc83107e3db9dbbab5bd2c28f687db1a03abc92f19

The next step is to take the proof options document, convert it to canonical form, and obtain its hash, as shown in the next three examples.

Example 53 : Proof Options Document

{
  "type": "DataIntegrityProof",
  "cryptosuite": "ecdsa-jcs-2019",
  "created": "2023-02-24T23:36:38Z",
  "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
  "proofPurpose": "assertionMethod",
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://www.w3.org/ns/credentials/examples/v2"
  ]
}

Example 54 : Canonical Proof Options Document

{"@context":["https://www.w3.org/ns/credentials/v2","https://www.w3.org/ns/credentials/examples/v2"],"created":"2023-02-24T23:36:38Z","cryptosuite":"ecdsa-jcs-2019","proofPurpose":"assertionMethod","type":"DataIntegrityProof","verificationMethod":"did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP"}

Example 55 : Hash of Canonical Proof Options Document (hex)

fe5799489119c7fe3c528715e72bd39d2ec6b4ab345978df32e9a9312648ec25

Example 56 : Combine hashes of Proof Options and Credential (hex)

fe5799489119c7fe3c528715e72bd39d2ec6b4ab345978df32e9a9312648ec2559b7cb6251b8991add1ce0bc83107e3db9dbbab5bd2c28f687db1a03abc92f19

Example 57 : Signature of Combined Hashes (hex)

f15c3b599eb9b3cad05df9d8e8b39a70a86375833b53743c764ac0a88c4457d60707fd7d073e03d906130631d87803f80a9824dc9939632ba92d418181be9d16

Example 58 : Signature of Combined Hashes base-58-btc

z5ptCet75SaEgzG4v4zJhbJtfNi74Wv7Fq15hhKouJQQjEPQvPZKaYxcMXAMLPQS2FXrkCWokNJkFVkwxNzZfD5oT

Assemble the signed credential with the following three steps:

Add the proofValue field with the previously computed base-58-btc value to the proof options document.
Set the proof options @context field to the value of the unsecuredDocument.@context.
Set the proof field of the credential to the augmented proof option document.

Example 59 : Signed Credential

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://www.w3.org/ns/credentials/examples/v2"
  ],
  "id": "urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33",
  "type": [
    "VerifiableCredential",
    "AlumniCredential"
  ],
  "name": "Alumni Credential",
  "description": "A minimum viable example of an Alumni Credential.",
  "issuer": "https://vc.example/issuers/5678",
  "validFrom": "2023-01-01T00:00:00Z",
  "credentialSubject": {
    "id": "did:example:abcdefgh",
    "alumniOf": "The School of Examples"
  },
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "ecdsa-jcs-2019",
    "created": "2023-02-24T23:36:38Z",
    "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
    "proofPurpose": "assertionMethod",
    "@context": [
      "https://www.w3.org/ns/credentials/v2",
      "https://www.w3.org/ns/credentials/examples/v2"
    ],
    "proofValue": "z5ptCet75SaEgzG4v4zJhbJtfNi74Wv7Fq15hhKouJQQjEPQvPZKaYxcMXAMLPQS2FXrkCWokNJkFVkwxNzZfD5oT"
  }
}

Example 60 : Private and Public keys for Signature

{
  "publicKeyMultibase": "z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ",
  "secretKeyMultibase": "z2fanyY7zgwNpZGxX5fXXibvScNaUWNprHU9dKx7qpVj7mws9J8LLt4mDB5TyH2GLHWkUc"
}

Signing begins with a credential without an attached proof, which is converted to canonical form, which is then hashed, as shown in the following three examples.

Example 61 : Credential without Proof

{
    "@context": [
        "https://www.w3.org/ns/credentials/v2",
        "https://www.w3.org/ns/credentials/examples/v2"
    ],
    "id": "urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33",
    "type": ["VerifiableCredential", "AlumniCredential"],
    "name": "Alumni Credential",
    "description": "A minimum viable example of an Alumni Credential.",
    "issuer": "https://vc.example/issuers/5678",
    "validFrom": "2023-01-01T00:00:00Z",
    "credentialSubject": {
        "id": "did:example:abcdefgh",
        "alumniOf": "The School of Examples"
    }
}

Example 62 : Canonical Credential without Proof

{"@context":["https://www.w3.org/ns/credentials/v2","https://www.w3.org/ns/credentials/examples/v2"],"credentialSubject":{"alumniOf":"The
School
of
Examples","id":"did:example:abcdefgh"},"description":"A
minimum
viable
example
of
an
Alumni
Credential.","id":"urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33","issuer":"https://vc.example/issuers/5678","name":"Alumni
Credential","type":["VerifiableCredential","AlumniCredential"],"validFrom":"2023-01-01T00:00:00Z"}

Example 63 : Hash of Canonical Credential without Proof (hex)

3e0be671cc1881035d463158c80921973dab3534d4f8dfacf4ff2725a4115eb718e49d66de0e90e7365cd6062abf2259

The next step is to take the proof options document, convert it to canonical form, and obtain its hash, as shown in the next three examples.

Example 64 : Proof Options Document

{
  "type": "DataIntegrityProof",
  "cryptosuite": "ecdsa-jcs-2019",
  "created": "2023-02-24T23:36:38Z",
  "verificationMethod": "did:key:z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ#z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ",
  "proofPurpose": "assertionMethod",
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://www.w3.org/ns/credentials/examples/v2"
  ]
}

Example 65 : Canonical Proof Options Document

{"@context":["https://www.w3.org/ns/credentials/v2","https://www.w3.org/ns/credentials/examples/v2"],"created":"2023-02-24T23:36:38Z","cryptosuite":"ecdsa-jcs-2019","proofPurpose":"assertionMethod","type":"DataIntegrityProof","verificationMethod":"did:key:z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ#z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ"}

Example 66 : Hash of Canonical Proof Options Document (hex)

83e5057817abb0c6872eafeaba1a9e53893c58eeb7414fb6d8aa3fa8c7917f7ad4792890b257c598baa17f4fbe6d183c

Example 67 : Combine hashes of Proof Options and Credential (hex)

83e5057817abb0c6872eafeaba1a9e53893c58eeb7414fb6d8aa3fa8c7917f7ad4792890b257c598baa17f4fbe6d183c3e0be671cc1881035d463158c80921973dab3534d4f8dfacf4ff2725a4115eb718e49d66de0e90e7365cd6062abf2259

Example 68 : Signature of Combined Hashes (hex)

8b7462ce62db0c8ff19878c4b3561c49eb71b4a743086b6d5b0eda70ecf0afc5a03fd88eb207d66b262ed87fd200a4e8e62716e0b329c032b67726b4b0fc737a44c1cefdba2fdccb3ece74cc5845aaa93374455a726f6ee4f5f30da9427f608a

Example 69 : Signature of Combined Hashes base-58-btc

zq3EuTeLiGurmB2JR5oL8oWEsT7u2tba4HT1oZbiMYWc5qzsoW2kLYcBcF4HM5vCpJyTkceULKrVXuJQkXeN5seL4uXrFNFRMm53GWy1Yrto8rTWxZi9DkNeWP7yUPs7ELAm

Assemble the signed credential with the following three steps:

Add the proofValue field with the previously computed base-58-btc value to the proof options document.
Set the proof options @context field to the value of the unsecuredDocument.@context.
Set the proof field of the credential to the augmented proof option document.

Example 70 : Signed Credential

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://www.w3.org/ns/credentials/examples/v2"
  ],
  "id": "urn:uuid:58172aac-d8ba-11ed-83dd-0b3aef56cc33",
  "type": [
    "VerifiableCredential",
    "AlumniCredential"
  ],
  "name": "Alumni Credential",
  "description": "A minimum viable example of an Alumni Credential.",
  "issuer": "https://vc.example/issuers/5678",
  "validFrom": "2023-01-01T00:00:00Z",
  "credentialSubject": {
    "id": "did:example:abcdefgh",
    "alumniOf": "The School of Examples"
  },
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "ecdsa-jcs-2019",
    "created": "2023-02-24T23:36:38Z",
    "verificationMethod": "did:key:z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ#z82LkuBieyGShVBhvtE2zoiD6Kma4tJGFtkAhxR5pfkp5QPw4LutoYWhvQCnGjdVn14kujQ",
    "proofPurpose": "assertionMethod",
    "@context": [
      "https://www.w3.org/ns/credentials/v2",
      "https://www.w3.org/ns/credentials/examples/v2"
    ],
    "proofValue": "zq3EuTeLiGurmB2JR5oL8oWEsT7u2tba4HT1oZbiMYWc5qzsoW2kLYcBcF4HM5vCpJyTkceULKrVXuJQkXeN5seL4uXrFNFRMm53GWy1Yrto8rTWxZi9DkNeWP7yUPs7ELAm"
  }
}

To demonstrate selective disclosure features we break the test vectors into two groups based on those that would be generated by the issuer (base proof) and those that would be generated by the holder (derived proof).

In order to add a selective disclosure base proof to a document the issuer needs the following cryptographic key material:

The issuers private/public key pair, i.e., the key pair corresponding to the verification method that will be part of the proof.
A per proof private/public key pair created by the issuer just for this proof. This is an ephemeral, single use key pair where the private key is not kept after the proof has been generated.
An HMAC key. This used to randomize the order of the blank node ids to avoid potential information leakage from the blank node id ordering. This is used only once and is shared between issuer and holder. The HMAC in this case is functioning as a pseudorandom function (PRF).

The key material used for generating the add base proof test vectors is shown below. Multibase representation is use for the P-256 key pairs and the HMAC key is given as a hexadecimal string.

Example 71 : Private and Public keys for Signature

{
  "baseKeyPair": {
    "publicKeyMultibase": "zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
    "secretKeyMultibase": "z42twTcNeSYcnqg1FLuSFs2bsGH3ZqbRHFmvS9XMsYhjxvHN"
  },
  "proofKeyPair": {
    "publicKeyMultibase": "zDnaeTHfhmSaQKBc7CmdL3K7oYg3D6SC7yowe2eBeVd2DH32r",
    "secretKeyMultibase": "z42tqvNGyzyXRzotAYn43UhcFtzDUVdxJ7461fwrfhBPLmfY"
  },
  "hmacKeyString": "00112233445566778899AABBCCDDEEFF00112233445566778899AABBCCDDEEFF"
}

In our scenario a person will be issued an employment authorization document as shown below.

Example 72 : Credential without Proof

{
    "@context": [
      "https://www.w3.org/ns/credentials/v2",
      "https://w3id.org/citizenship/v4rc1"
    ],
    "type": [
      "VerifiableCredential",
      "EmploymentAuthorizationDocumentCredential"
    ],
    "issuer": {
      "id": "did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76",
      "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg=="
    },
    "credentialSubject": {
      "type": [
        "Person",
        "EmployablePerson"
      ],
      "givenName": "JOHN",
      "additionalName": "JACOB",
      "familyName": "SMITH",
      "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2Ng+M/wHwAEAQH/7yMK/gAAAABJRU5ErkJggg==",
      "gender": "Male",
      "residentSince": "2015-01-01",
      "birthCountry": "Bahamas",
      "birthDate": "1999-07-17",
      "employmentAuthorizationDocument": {
        "type": "EmploymentAuthorizationDocument",
        "identifier": "83627465",
        "lprCategory": "C09",
        "lprNumber": "999-999-999"
      }
    },
    "name": "Employment Authorization Document",
    "description": "Example Employment Authorization Document.",
    "validFrom": "2019-12-03T00:00:00Z",
    "validUntil": "2029-12-03T00:00:00Z"
}

The mandatory information as specified by the issuer is specified via an array of JSON pointers as shown below.

Example 73 : Mandatory Pointers

["/issuer"]

The result of applying the above JSON pointers to the employment authorization document is shown below.

Example 74 : JSON Pointers and Values

[
  {
    "pointer": "/issuer",
    "value": {
      "id": "did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76",
      "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg=="
    }
  }
]

Transformation of the unsigned document begins with canonicalizing the document as shown below.

Example 75 : Canonical Document

[
  "<did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76> <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg==> .\n",
  "_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmploymentAuthorizationDocumentCredential> .\n",
  "_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/2018/credentials#VerifiableCredential> .\n",
  "_:c14n0 <https://schema.org/description> \"Example Employment Authorization Document.\" .\n",
  "_:c14n0 <https://schema.org/name> \"Employment Authorization Document\" .\n",
  "_:c14n0 <https://www.w3.org/2018/credentials#credentialSubject> _:c14n1 .\n",
  "_:c14n0 <https://www.w3.org/2018/credentials#issuer> <did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76> .\n",
  "_:c14n0 <https://www.w3.org/2018/credentials#validFrom> \"2019-12-03T00:00:00Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:c14n0 <https://www.w3.org/2018/credentials#validUntil> \"2029-12-03T00:00:00Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:c14n1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://schema.org/Person> .\n",
  "_:c14n1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmployablePerson> .\n",
  "_:c14n1 <https://schema.org/additionalName> \"JACOB\" .\n",
  "_:c14n1 <https://schema.org/birthDate> \"1999-07-17\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:c14n1 <https://schema.org/familyName> \"SMITH\" .\n",
  "_:c14n1 <https://schema.org/gender> \"Male\" .\n",
  "_:c14n1 <https://schema.org/givenName> \"JOHN\" .\n",
  "_:c14n1 <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2Ng+M/wHwAEAQH/7yMK/gAAAABJRU5ErkJggg==> .\n",
  "_:c14n1 <https://w3id.org/citizenship#birthCountry> \"Bahamas\" .\n",
  "_:c14n1 <https://w3id.org/citizenship#employmentAuthorizationDocument> _:c14n2 .\n",
  "_:c14n1 <https://w3id.org/citizenship#residentSince> \"2015-01-01\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:c14n2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmploymentAuthorizationDocument> .\n",
  "_:c14n2 <https://schema.org/identifier> \"83627465\" .\n",
  "_:c14n2 <https://w3id.org/citizenship#lprCategory> \"C09\" .\n",
  "_:c14n2 <https://w3id.org/citizenship#lprNumber> \"999-999-999\" .\n"
]

To prevent possible information leakage from the ordering of the blank node ids these are processed through a PRF, i.e., the HMAC to give the canonized HMAC document shown below. This represents an ordered list of statements that will be subject to mandatory and selective disclosure, i.e., it is from this list that statements are grouped.

Example 76 : Canonical HMAC Document

[
  "<did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76> <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg==> .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://schema.org/Person> .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmployablePerson> .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/additionalName> \"JACOB\" .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/birthDate> \"1999-07-17\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/familyName> \"SMITH\" .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/gender> \"Male\" .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/givenName> \"JOHN\" .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2Ng+M/wHwAEAQH/7yMK/gAAAABJRU5ErkJggg==> .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#birthCountry> \"Bahamas\" .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#employmentAuthorizationDocument> _:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#residentSince> \"2015-01-01\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmploymentAuthorizationDocumentCredential> .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/2018/credentials#VerifiableCredential> .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://schema.org/description> \"Example Employment Authorization Document.\" .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://schema.org/name> \"Employment Authorization Document\" .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://www.w3.org/2018/credentials#credentialSubject> _:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://www.w3.org/2018/credentials#issuer> <did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76> .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://www.w3.org/2018/credentials#validFrom> \"2019-12-03T00:00:00Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://www.w3.org/2018/credentials#validUntil> \"2029-12-03T00:00:00Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmploymentAuthorizationDocument> .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://schema.org/identifier> \"83627465\" .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://w3id.org/citizenship#lprCategory> \"C09\" .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://w3id.org/citizenship#lprNumber> \"999-999-999\" .\n"
]

The above canonical document gets grouped in to mandatory and non-mandatory statements. The final output of the selective disclosure transformation process is shown below. Each statement is now grouped as mandatory and non-mandatory and its index in the previous list of statements is remembered.

Example 77 : Add Base Transformation

{
  "mandatoryPointers": [
    "/issuer"
  ],
  "mandatory": {
    "dataType": "Map",
    "value": [
      [
        0,
        "<did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76> <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg==> .\n"
      ],
      [
        12,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmploymentAuthorizationDocumentCredential> .\n"
      ],
      [
        13,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/2018/credentials#VerifiableCredential> .\n"
      ],
      [
        17,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://www.w3.org/2018/credentials#issuer> <did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76> .\n"
      ]
    ]
  },
  "nonMandatory": {
    "dataType": "Map",
    "value": [
      [
        1,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://schema.org/Person> .\n"
      ],
      [
        2,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmployablePerson> .\n"
      ],
      [
        3,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/additionalName> \"JACOB\" .\n"
      ],
      [
        4,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/birthDate> \"1999-07-17\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n"
      ],
      [
        5,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/familyName> \"SMITH\" .\n"
      ],
      [
        6,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/gender> \"Male\" .\n"
      ],
      [
        7,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/givenName> \"JOHN\" .\n"
      ],
      [
        8,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2Ng+M/wHwAEAQH/7yMK/gAAAABJRU5ErkJggg==> .\n"
      ],
      [
        9,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#birthCountry> \"Bahamas\" .\n"
      ],
      [
        10,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#employmentAuthorizationDocument> _:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw .\n"
      ],
      [
        11,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#residentSince> \"2015-01-01\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n"
      ],
      [
        14,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://schema.org/description> \"Example Employment Authorization Document.\" .\n"
      ],
      [
        15,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://schema.org/name> \"Employment Authorization Document\" .\n"
      ],
      [
        16,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://www.w3.org/2018/credentials#credentialSubject> _:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg .\n"
      ],
      [
        18,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://www.w3.org/2018/credentials#validFrom> \"2019-12-03T00:00:00Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n"
      ],
      [
        19,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://www.w3.org/2018/credentials#validUntil> \"2029-12-03T00:00:00Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n"
      ],
      [
        20,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#EmploymentAuthorizationDocument> .\n"
      ],
      [
        21,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://schema.org/identifier> \"83627465\" .\n"
      ],
      [
        22,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://w3id.org/citizenship#lprCategory> \"C09\" .\n"
      ],
      [
        23,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://w3id.org/citizenship#lprNumber> \"999-999-999\" .\n"
      ]
    ]
  },
  "hmacKeyString": "00112233445566778899AABBCCDDEEFF00112233445566778899AABBCCDDEEFF"
}

The next step is to create the base proof configuration and canonicalize it. This is shown in the following two examples.

Example 78 : Base Proof Configuration

{
  "type": "DataIntegrityProof",
  "cryptosuite": "ecdsa-sd-2023",
  "created": "2023-08-15T23:36:38Z",
  "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
  "proofPurpose": "assertionMethod",
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ]
}

Example 79 : Canonical Base Proof Configuration

_:c14n0 <http://purl.org/dc/terms/created> "2023-08-15T23:36:38Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/security#DataIntegrityProof> .
_:c14n0 <https://w3id.org/security#cryptosuite> "ecdsa-sd-2023"^^<https://w3id.org/security#cryptosuiteString> .
_:c14n0 <https://w3id.org/security#proofPurpose> <https://w3id.org/security#assertionMethod> .
_:c14n0
<https://w3id.org/security#verificationMethod>
<did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP>
.

In the hashing step we compute the SHA-256 hash of the canonicalized proof options to produce the proofHash and we compute the SHA-256 hash of the join of all the mandatory nquads to produce the mandatoryHash. These are shown below in hexadecimal format.

Example 80 : Add Base Hashes

{
  "proofHash": "9c5c9b189f06cfa9d9f21a838ccb9b04316f07ad1a517bfd4955ee28c6a8229c",
  "mandatoryHash": "a042dc047c236816f49fbe5282a79c5e77abe111e47f4c20203b5064c7f0f059"
}

We compute the baseSignature over the concatenation of the proofHash, proofPublicKey, and mandatoryHash using the issuers long term privateKey. We compute the signatures array by signing each non-mandatory nquad using the per proofPrivateKey. These signatures, the proofPublicKey, and mandatoryPointers which are fed to the final serialization step are shown below.

Example 81 : Add Base Signing

{
  "baseSignature": "b8dc55afeb6427a990e9d60c0d363b654306d92703e5036210ca29619d8ed204194ba3d86e31cdbc99f4ee9d5f25f0cc1c1f44f5fa39abec9a50cdf519b457e0",
  "publicKey": "zDnaeTHfhmSaQKBc7CmdL3K7oYg3D6SC7yowe2eBeVd2DH32r",
  "signatures": [
    "fd91ec48b3524965f7a1453e9ffa067054eca6f7d6338a84525eb3288bb0caf7a9651f02fee14d6d33ee1679aa8828348ccc574e194d7f57fca8be354c1b30f7",
    "c92e6ea5f65343c704ac9450da4d55f87342829b9bad7aface8300a0879bc9972ec4879eebbaaffd9ad9e3f91d291971c8ffe5d768497d62fa27256a7e03bf99",
    "5d98f7d800ae2aa62927a65e0345a5ae02df041c9cd26de1525a63431b9360c24216737d2374d0789d4e40acdd0bf75b077c06534a6d258084ad8beb149980d6",
    "c8d70ede67864b3219dcb3c3831401ca069ac5f8db9e2714d5f57f367c76320d1e0a9fa4917551add811a415e19bcc32c017ef5ba02e81fed672c72711230b10",
    "3a6263590ab7fbc4e5ef7bc6c3f6b9cdd8a96c7c4d9a1f120612213ca39a50f39d7b56d6365ead6054bdbe4b971b2769d61841a3f7236a7434e5f1b0f6e2e8fc",
    "f5f1fe2990af59361ccd4863359405164ce6a0807dfedd2d1972826e6b79ee051df16f5dfc43d57ed0d57743b94c4f57dd5784fbb04a9bf2b6b7258f5c595524",
    "44b68330d1b12ceec6c07ed560587b6bfd49c831fa90c1a8725a41a3e3247f2950bcfe51a0b26bf422e94f811001dc17b1b93b3f82423457acc5c19f214da5e1",
    "c29744b9bfb68a250eb17aaf49416a8a77a5eed01be18c3278a3784db8f6731bda3da956855bc27f3bc91e3f8331371e100722fc223becb47072a45b7653be08",
    "2b66d296f2d09ff280d4cdec1d02b6c38065ed36c99b6db40a9a800f4faea46187c7b42c6cb232b5103bc88445f5e1f32c89692071546f316a836cd31a979f8d",
    "016fdf24189adefa773c26ad2e0482aebf74a7bb8d5a142723d43d18adc049c408faafdcef8bb11cdc9c728d8f746ae32e03197767bb1aa91fd61a8fc4993abe",
    "e7ee420aa027ba4671b926c29e2c574f94461660a0b3d6c828cce50314d9e1e4c346ed119352adf6141c66e2fce4a2cb7486c3f81cc42e388a5f921285677d94",
    "ff516e1c599ef23779cdd5a6ae34a7db1a1d244514d32308a809752e6c2d112e5a7b473360c0b8caf27949aa161d10876d19c77b50e76160736f1ea4cfdefaa2",
    "c85373002c77fb25e7880c1b2df2e2fa6c25decf563b0a88332e4654773b08b9286b65effe00f8689df03df6e2dfcd4575eff23a08c92bd360e285c22bfa2b5d",
    "09e91f89dfd0a252f79a970caec55814cd570a8e41ec2ac25c33bd8afe479a70b8e744d363bc7daa313625d0cb4c1ea8c64c87577835e9b7416b4615bb82def9",
    "b181986ef2cfb77b71f27cfb4365b8860799d9e84c3df62b3863319250d57a91d429cb15127122c36fd34a92ea0745b4a641454c561c55c37741ee247a866264",
    "13d02a9caf0d96b9fbec397d4faad90e78c56d0cbd933224d58b5c81623e3571b22aa15bc4ad201c364e3566793c9dda9c983e9965f47c7ce5ff6e1b42484dd4",
    "91cc9524b4aa346fc6e409e94b28b8a9891491ae627e47e60f0cd36d90034eb97a8595fcb35a07d3faa5fc213e759b0bea03cb82c58a3711c9de299b7e77904b",
    "22d951c202cd2dbf92a5fd20483f618177f16c08aa798fd6e8a0631fba6d059e304c1ed96a3785aa1be2539eb1fac22caace1f450b5a3a48602c7fb4c68f2d7b",
    "d0fbcf518ec15c3f10d8d2b275963807030ad7e4b03e6c7a6ca0e6b73d61f15a94d76097fc91e1a828c7d9272b178b8ced6422db36e9a1a85ce2a18e39115542",
    "be6366acec557376a71a450f862979f60e642b8edafc104eaf4691784bb48245f3d79f093cd1f631d55217ae2f9f30f17d9ba1b98aae45e02461e1db9bde121f"
  ],
  "mandatoryPointers": [
    "/issuer"
  ]
}

Finally, the values above are run through the algorithm of Section 3.5.2 serializeBaseProofValue to produce the proofValue which is used in the signed based document shown below.

Example 82 : Signed Base Document

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ],
  "type": [
    "VerifiableCredential",
    "EmploymentAuthorizationDocumentCredential"
  ],
  "issuer": {
    "id": "did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg=="
  },
  "credentialSubject": {
    "type": [
      "Person",
      "EmployablePerson"
    ],
    "givenName": "JOHN",
    "additionalName": "JACOB",
    "familyName": "SMITH",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2Ng+M/wHwAEAQH/7yMK/gAAAABJRU5ErkJggg==",
    "gender": "Male",
    "residentSince": "2015-01-01",
    "birthCountry": "Bahamas",
    "birthDate": "1999-07-17",
    "employmentAuthorizationDocument": {
      "type": "EmploymentAuthorizationDocument",
      "identifier": "83627465",
      "lprCategory": "C09",
      "lprNumber": "999-999-999"
    }
  },
  "name": "Employment Authorization Document",
  "description": "Example Employment Authorization Document.",
  "validFrom": "2019-12-03T00:00:00Z",
  "validUntil": "2029-12-03T00:00:00Z",
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "ecdsa-sd-2023",
    "created": "2023-08-15T23:36:38Z",
    "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
    "proofPurpose": "assertionMethod",
    "proofValue": "u2V0AhVhAuNxVr-tkJ6mQ6dYMDTY7ZUMG2ScD5QNiEMopYZ2O0gQZS6PYbjHNvJn07p1fJfDMHB9E9fo5q-yaUM31GbRX4FgjgCQCKnLOGbY_FuM-ASpSkkOxsIR2E8n7Ml2q1UQ6tEwzi5NYIAARIjNEVWZ3iJmqu8zd7v8AESIzRFVmd4iZqrvM3e7_lFhA_ZHsSLNSSWX3oUU-n_oGcFTspvfWM4qEUl6zKIuwyvepZR8C_uFNbTPuFnmqiCg0jMxXThlNf1f8qL41TBsw91hAyS5upfZTQ8cErJRQ2k1V-HNCgpubrXr6zoMAoIebyZcuxIee67qv_ZrZ4_kdKRlxyP_l12hJfWL6JyVqfgO_mVhAXZj32ACuKqYpJ6ZeA0WlrgLfBByc0m3hUlpjQxuTYMJCFnN9I3TQeJ1OQKzdC_dbB3wGU0ptJYCErYvrFJmA1lhAyNcO3meGSzIZ3LPDgxQBygaaxfjbnicU1fV_Nnx2Mg0eCp-kkXVRrdgRpBXhm8wywBfvW6Augf7WcscnESMLEFhAOmJjWQq3-8Tl73vGw_a5zdipbHxNmh8SBhIhPKOaUPOde1bWNl6tYFS9vkuXGydp1hhBo_cjanQ05fGw9uLo_FhA9fH-KZCvWTYczUhjNZQFFkzmoIB9_t0tGXKCbmt57gUd8W9d_EPVftDVd0O5TE9X3VeE-7BKm_K2tyWPXFlVJFhARLaDMNGxLO7GwH7VYFh7a_1JyDH6kMGoclpBo-MkfylQvP5RoLJr9CLpT4EQAdwXsbk7P4JCNFesxcGfIU2l4VhAwpdEub-2iiUOsXqvSUFqinel7tAb4YwyeKN4Tbj2cxvaPalWhVvCfzvJHj-DMTceEAci_CI77LRwcqRbdlO-CFhAK2bSlvLQn_KA1M3sHQK2w4Bl7TbJm220CpqAD0-upGGHx7QsbLIytRA7yIRF9eHzLIlpIHFUbzFqg2zTGpefjVhAAW_fJBia3vp3PCatLgSCrr90p7uNWhQnI9Q9GK3AScQI-q_c74uxHNycco2PdGrjLgMZd2e7Gqkf1hqPxJk6vlhA5-5CCqAnukZxuSbCnixXT5RGFmCgs9bIKMzlAxTZ4eTDRu0Rk1Kt9hQcZuL85KLLdIbD-BzELjiKX5IShWd9lFhA_1FuHFme8jd5zdWmrjSn2xodJEUU0yMIqAl1LmwtES5ae0czYMC4yvJ5SaoWHRCHbRnHe1DnYWBzbx6kz976olhAyFNzACx3-yXniAwbLfLi-mwl3s9WOwqIMy5GVHc7CLkoa2Xv_gD4aJ3wPfbi381Fde_yOgjJK9Ng4oXCK_orXVhACekfid_QolL3mpcMrsVYFM1XCo5B7CrCXDO9iv5HmnC450TTY7x9qjE2JdDLTB6oxkyHV3g16bdBa0YVu4Le-VhAsYGYbvLPt3tx8nz7Q2W4hgeZ2ehMPfYrOGMxklDVepHUKcsVEnEiw2_TSpLqB0W0pkFFTFYcVcN3Qe4keoZiZFhAE9AqnK8Nlrn77Dl9T6rZDnjFbQy9kzIk1YtcgWI-NXGyKqFbxK0gHDZONWZ5PJ3anJg-mWX0fHzl_24bQkhN1FhAkcyVJLSqNG_G5AnpSyi4qYkUka5ifkfmDwzTbZADTrl6hZX8s1oH0_ql_CE-dZsL6gPLgsWKNxHJ3imbfneQS1hAItlRwgLNLb-Spf0gSD9hgXfxbAiqeY_W6KBjH7ptBZ4wTB7ZajeFqhviU56x-sIsqs4fRQtaOkhgLH-0xo8te1hA0PvPUY7BXD8Q2NKydZY4BwMK1-SwPmx6bKDmtz1h8VqU12CX_JHhqCjH2ScrF4uM7WQi2zbpoahc4qGOORFVQlhAvmNmrOxVc3anGkUPhil59g5kK47a_BBOr0aReEu0gkXz158JPNH2MdVSF64vnzDxfZuhuYquReAkYeHbm94SH4FnL2lzc3Vlcg"
  }
}

In order to create a derived proof a holder starts with a signed document containing a base proof. The base document we will use for these test vectors is the final example from Section A.7.1 Base Proof above. The first step is to run the algorithm of Section 3.5.3 parseBaseProofValue to recover baseSignature, publicKey, hmacKey, signatures, and mandatoryPointers as shown below.

Example 83 : Recovered Base Signature Data

{
  "baseSignature": "b8dc55afeb6427a990e9d60c0d363b654306d92703e5036210ca29619d8ed204194ba3d86e31cdbc99f4ee9d5f25f0cc1c1f44f5fa39abec9a50cdf519b457e0",
  "proofPublicKey": "zDnaeTHfhmSaQKBc7CmdL3K7oYg3D6SC7yowe2eBeVd2DH32r",
  "hmacKey": "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
  "signatures": [
    "fd91ec48b3524965f7a1453e9ffa067054eca6f7d6338a84525eb3288bb0caf7a9651f02fee14d6d33ee1679aa8828348ccc574e194d7f57fca8be354c1b30f7",
    "c92e6ea5f65343c704ac9450da4d55f87342829b9bad7aface8300a0879bc9972ec4879eebbaaffd9ad9e3f91d291971c8ffe5d768497d62fa27256a7e03bf99",
    "5d98f7d800ae2aa62927a65e0345a5ae02df041c9cd26de1525a63431b9360c24216737d2374d0789d4e40acdd0bf75b077c06534a6d258084ad8beb149980d6",
    "c8d70ede67864b3219dcb3c3831401ca069ac5f8db9e2714d5f57f367c76320d1e0a9fa4917551add811a415e19bcc32c017ef5ba02e81fed672c72711230b10",
    "3a6263590ab7fbc4e5ef7bc6c3f6b9cdd8a96c7c4d9a1f120612213ca39a50f39d7b56d6365ead6054bdbe4b971b2769d61841a3f7236a7434e5f1b0f6e2e8fc",
    "f5f1fe2990af59361ccd4863359405164ce6a0807dfedd2d1972826e6b79ee051df16f5dfc43d57ed0d57743b94c4f57dd5784fbb04a9bf2b6b7258f5c595524",
    "44b68330d1b12ceec6c07ed560587b6bfd49c831fa90c1a8725a41a3e3247f2950bcfe51a0b26bf422e94f811001dc17b1b93b3f82423457acc5c19f214da5e1",
    "c29744b9bfb68a250eb17aaf49416a8a77a5eed01be18c3278a3784db8f6731bda3da956855bc27f3bc91e3f8331371e100722fc223becb47072a45b7653be08",
    "2b66d296f2d09ff280d4cdec1d02b6c38065ed36c99b6db40a9a800f4faea46187c7b42c6cb232b5103bc88445f5e1f32c89692071546f316a836cd31a979f8d",
    "016fdf24189adefa773c26ad2e0482aebf74a7bb8d5a142723d43d18adc049c408faafdcef8bb11cdc9c728d8f746ae32e03197767bb1aa91fd61a8fc4993abe",
    "e7ee420aa027ba4671b926c29e2c574f94461660a0b3d6c828cce50314d9e1e4c346ed119352adf6141c66e2fce4a2cb7486c3f81cc42e388a5f921285677d94",
    "ff516e1c599ef23779cdd5a6ae34a7db1a1d244514d32308a809752e6c2d112e5a7b473360c0b8caf27949aa161d10876d19c77b50e76160736f1ea4cfdefaa2",
    "c85373002c77fb25e7880c1b2df2e2fa6c25decf563b0a88332e4654773b08b9286b65effe00f8689df03df6e2dfcd4575eff23a08c92bd360e285c22bfa2b5d",
    "09e91f89dfd0a252f79a970caec55814cd570a8e41ec2ac25c33bd8afe479a70b8e744d363bc7daa313625d0cb4c1ea8c64c87577835e9b7416b4615bb82def9",
    "b181986ef2cfb77b71f27cfb4365b8860799d9e84c3df62b3863319250d57a91d429cb15127122c36fd34a92ea0745b4a641454c561c55c37741ee247a866264",
    "13d02a9caf0d96b9fbec397d4faad90e78c56d0cbd933224d58b5c81623e3571b22aa15bc4ad201c364e3566793c9dda9c983e9965f47c7ce5ff6e1b42484dd4",
    "91cc9524b4aa346fc6e409e94b28b8a9891491ae627e47e60f0cd36d90034eb97a8595fcb35a07d3faa5fc213e759b0bea03cb82c58a3711c9de299b7e77904b",
    "22d951c202cd2dbf92a5fd20483f618177f16c08aa798fd6e8a0631fba6d059e304c1ed96a3785aa1be2539eb1fac22caace1f450b5a3a48602c7fb4c68f2d7b",
    "d0fbcf518ec15c3f10d8d2b275963807030ad7e4b03e6c7a6ca0e6b73d61f15a94d76097fc91e1a828c7d9272b178b8ced6422db36e9a1a85ce2a18e39115542",
    "be6366acec557376a71a450f862979f60e642b8edafc104eaf4691784bb48245f3d79f093cd1f631d55217ae2f9f30f17d9ba1b98aae45e02461e1db9bde121f"
  ],
  "mandatoryPointers": [
    "/issuer"
  ]
}

Next, the holder needs to indicate what, if anything else, they wish to reveal to the verifiers by specifying JSON pointers for selective disclosure.

Example 84 : Selective Disclosure Pointers

["/validFrom",
"/validUntil",
"/credentialSubject/birthCountry"]

To produce the revealDocument, i.e., the unsigned document that will eventually be signed and sent to the verifier, we append the selective pointers to the mandatory pointers and input these combined pointers along with the document without proof to the algorithm of Section 3.4.13 selectJsonLd to give the result shown below.

Example 85 : Unsigned Reveal Document

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ],
  "type": [
    "VerifiableCredential",
    "EmploymentAuthorizationDocumentCredential"
  ],
  "issuer": {
    "id": "did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg=="
  },
  "validFrom": "2019-12-03T00:00:00Z",
  "validUntil": "2029-12-03T00:00:00Z",
  "credentialSubject": {
    "type": [
      "Person",
      "EmployablePerson"
    ],
    "birthCountry": "Bahamas"
  }
}

Now that we know what the revealed document looks like, we need to furnish appropriately updated information to the verifier on which statements are mandatory, the signatures for the selected non-mandatory statements, and the mapping between canonical blank node ids for the reveal document and a subset of the HMAC blank node ids. Running step 6 of the 3.5.4 createDisclosureData yields an abundance of information about various statement groups relative to the original document. Below we show a portion of the indexes for those groups.

Example 86 : Derived Group Indexes

{
    "combinedIndexes":[0,1,2,9,12,13,16,17,18,19],
    "mandatoryIndexes":[0,12,13,17],
    "nonMandatoryIndexes":[1,2,3,4,5,6,7,8,9,10,11,14,15,16,18,19,20,21,22,23],
    "selectiveIndexes":[1,2,9,12,13,16,18,19]
}

The verifier needs to be able to aggregate and hash the mandatory statements. To enable this we furnish them with a list of indexes of the mandatory statements adjusted to their positions in the reveal document. In the previous example the combinedIndexes show the indexes of all the original nquads (statements) that make up the reveal document, in order. To come up with the adjusted mandatory indexes shown below we obtain the index of each of original mandatory indexes relative to the combinedIndexes as shown below.

Example 87 : Adjusted Mandatory Indexes

{
    "adjMandatoryIndexes":[0,4,5,7]
}

We have to furnish the verifier with a list of signatures for those selective statements (nquads) that are not mandatory. The original list of signatures corresponds to every non-mandatory statement and the indexes of these in the original document are given above. We now compute a list of adjusted signature indexes by computing the index of each selective index in the non-mandatory index list, ignoring any selective index not present in the list. We then use the adjusted signature indexes to obtain the filtered signature list. These lists are shown below.

Example 88 : Filtered Signatures

{
    "adjSignatureIndexes":[0,1,8,13,14,15],
    "filteredSignatures":[
        "fd91ec48b3524965f7a1453e9ffa067054eca6f7d6338a84525eb3288bb0caf7a9651f02fee14d6d33ee1679aa8828348ccc574e194d7f57fca8be354c1b30f7",
        "c92e6ea5f65343c704ac9450da4d55f87342829b9bad7aface8300a0879bc9972ec4879eebbaaffd9ad9e3f91d291971c8ffe5d768497d62fa27256a7e03bf99",
        "2b66d296f2d09ff280d4cdec1d02b6c38065ed36c99b6db40a9a800f4faea46187c7b42c6cb232b5103bc88445f5e1f32c89692071546f316a836cd31a979f8d",
        "09e91f89dfd0a252f79a970caec55814cd570a8e41ec2ac25c33bd8afe479a70b8e744d363bc7daa313625d0cb4c1ea8c64c87577835e9b7416b4615bb82def9",
        "b181986ef2cfb77b71f27cfb4365b8860799d9e84c3df62b3863319250d57a91d429cb15127122c36fd34a92ea0745b4a641454c561c55c37741ee247a866264",
        "13d02a9caf0d96b9fbec397d4faad90e78c56d0cbd933224d58b5c81623e3571b22aa15bc4ad201c364e3566793c9dda9c983e9965f47c7ce5ff6e1b42484dd4"
    ]
}

The last important piece of disclosure data is a mapping of canonical blank node ids to HMAC based ids, the labelMap, computed according to Section 3.5.4 createDisclosureData steps 12-14. This is shown below along with the rest of the disclosure data minus the reveal document.

Example 89 : Disclosure Data

{
  "baseSignature": "b8dc55afeb6427a990e9d60c0d363b654306d92703e5036210ca29619d8ed204194ba3d86e31cdbc99f4ee9d5f25f0cc1c1f44f5fa39abec9a50cdf519b457e0",
  "publicKey": "zDnaeTHfhmSaQKBc7CmdL3K7oYg3D6SC7yowe2eBeVd2DH32r",
  "signatures": [
    "fd91ec48b3524965f7a1453e9ffa067054eca6f7d6338a84525eb3288bb0caf7a9651f02fee14d6d33ee1679aa8828348ccc574e194d7f57fca8be354c1b30f7",
    "c92e6ea5f65343c704ac9450da4d55f87342829b9bad7aface8300a0879bc9972ec4879eebbaaffd9ad9e3f91d291971c8ffe5d768497d62fa27256a7e03bf99",
    "2b66d296f2d09ff280d4cdec1d02b6c38065ed36c99b6db40a9a800f4faea46187c7b42c6cb232b5103bc88445f5e1f32c89692071546f316a836cd31a979f8d",
    "09e91f89dfd0a252f79a970caec55814cd570a8e41ec2ac25c33bd8afe479a70b8e744d363bc7daa313625d0cb4c1ea8c64c87577835e9b7416b4615bb82def9",
    "b181986ef2cfb77b71f27cfb4365b8860799d9e84c3df62b3863319250d57a91d429cb15127122c36fd34a92ea0745b4a641454c561c55c37741ee247a866264",
    "13d02a9caf0d96b9fbec397d4faad90e78c56d0cbd933224d58b5c81623e3571b22aa15bc4ad201c364e3566793c9dda9c983e9965f47c7ce5ff6e1b42484dd4"
  ],
  "labelMap": {
    "dataType": "Map",
    "value": [
      [
        "c14n0",
        "u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg"
      ],
      [
        "c14n1",
        "u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38"
      ]
    ]
  },
  "mandatoryIndexes": [
    0,
    4,
    5,
    7
  ]
}

Finally using the disclosure data above with the algorithm of Section 3.5.7 serializeDerivedProofValue we obtain the signed derived (reveal) document shown below.

Example 90 : Signed Derived Document

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ],
  "type": [
    "VerifiableCredential",
    "EmploymentAuthorizationDocumentCredential"
  ],
  "issuer": {
    "id": "did:key:zDnaegE6RR3atJtHKwTRTWHsJ3kNHqFwv7n9YjTgmU7TyfU76",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgUPr/HwADaAIhG61j/AAAAABJRU5ErkJggg=="
  },
  "validFrom": "2019-12-03T00:00:00Z",
  "validUntil": "2029-12-03T00:00:00Z",
  "credentialSubject": {
    "type": [
      "Person",
      "EmployablePerson"
    ],
    "birthCountry": "Bahamas"
  },
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "ecdsa-sd-2023",
    "created": "2023-08-15T23:36:38Z",
    "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
    "proofPurpose": "assertionMethod",
    "proofValue": "u2V0BhVhAuNxVr-tkJ6mQ6dYMDTY7ZUMG2ScD5QNiEMopYZ2O0gQZS6PYbjHNvJn07p1fJfDMHB9E9fo5q-yaUM31GbRX4FgjgCQCKnLOGbY_FuM-ASpSkkOxsIR2E8n7Ml2q1UQ6tEwzi5OGWED9kexIs1JJZfehRT6f-gZwVOym99YzioRSXrMoi7DK96llHwL-4U1tM-4WeaqIKDSMzFdOGU1_V_yovjVMGzD3WEDJLm6l9lNDxwSslFDaTVX4c0KCm5utevrOgwCgh5vJly7Eh57ruq_9mtnj-R0pGXHI_-XXaEl9YvonJWp-A7-ZWEArZtKW8tCf8oDUzewdArbDgGXtNsmbbbQKmoAPT66kYYfHtCxssjK1EDvIhEX14fMsiWkgcVRvMWqDbNMal5-NWEAJ6R-J39CiUvealwyuxVgUzVcKjkHsKsJcM72K_keacLjnRNNjvH2qMTYl0MtMHqjGTIdXeDXpt0FrRhW7gt75WECxgZhu8s-3e3HyfPtDZbiGB5nZ6Ew99is4YzGSUNV6kdQpyxUScSLDb9NKkuoHRbSmQUVMVhxVw3dB7iR6hmJkWEAT0Cqcrw2WufvsOX1PqtkOeMVtDL2TMiTVi1yBYj41cbIqoVvErSAcNk41Znk8ndqcmD6ZZfR8fOX_bhtCSE3UogBYINy79kKRYKPmAHoHNXEECliRVtrBI0BehX7mdFRKDCh4AVgg4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC3-EAAQFBw"
  }
}

Here we provide an additional example of basic ecdsa-sd-2023 processing. To demonstrate selective disclosure features we break the test vectors into two groups based on those that would be generated by the issuer (base proof) and those that would be generated by the holder (derived proof).

In order to add a selective disclosure base proof to a document the issuer needs the following cryptographic key material:

The issuers private/public key pair, i.e., the key pair corresponding to the verification method that will be part of the proof.
A per proof private/public key pair created by the issuer just for this proof. This is an ephemeral, single use key pair where the private key is not kept after the proof has been generated.
An HMAC key. This used to randomize the order of the blank node ids to avoid potential information leakage from the blank node id ordering. This is used only once and is shared between issuer and holder. The HMAC in this case is functioning as a pseudorandom function (PRF).

The key material used for generating the add base proof test vectors is shown below. Multibase representation is use for the P-256 key pairs and the HMAC key is given as a hexadecimal string.

Example 91 : Private and Public keys for Signature

{
  "baseKeyPair": {
    "publicKeyMultibase": "zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
    "secretKeyMultibase": "z42twTcNeSYcnqg1FLuSFs2bsGH3ZqbRHFmvS9XMsYhjxvHN"
  },
  "proofKeyPair": {
    "publicKeyMultibase": "zDnaeTHfhmSaQKBc7CmdL3K7oYg3D6SC7yowe2eBeVd2DH32r",
    "secretKeyMultibase": "z42tqvNGyzyXRzotAYn43UhcFtzDUVdxJ7461fwrfhBPLmfY"
  },
  "hmacKeyString": "00112233445566778899AABBCCDDEEFF00112233445566778899AABBCCDDEEFF"
}

In our scenario a person will be issued an permanent resident credential as shown below.

Example 92 : Credential without Proof

{
    "@context": [
      "https://www.w3.org/ns/credentials/v2",
      "https://w3id.org/citizenship/v4rc1"
    ],
    "type": [
      "VerifiableCredential",
      "PermanentResidentCardCredential"
    ],
    "issuer": {
      "id": "did:key:zDnaeTHxNEBZoKaEo6PdA83fq98ebiFvo3X273Ydu4YmV96rg",
      "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4z/DiPwAG0ALnwgz64QAAAABJRU5ErkJggg=="
       },
    "name": "Permanent Resident Card",
    "description": "Government of Utopia Permanent Resident Card.",
    "credentialSubject": {
      "type": [
        "PermanentResident",
        "Person"
      ],
      "givenName": "JANE",
      "familyName": "SMITH",
      "gender": "Female",
      "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4v43hPwAHIgK1v4tX6wAAAABJRU5ErkJggg==",
      "residentSince": "2015-01-01",
      "commuterClassification": "C1",
      "birthCountry": "Arcadia",
      "birthDate": "1978-07-17",
      "permanentResidentCard": {
        "type": [
          "PermanentResidentCard"
        ],
        "identifier": "83627465",
        "lprCategory": "C09",
        "lprNumber": "999-999-999"
      }
    },
    "validFrom": "2024-12-16T00:00:00Z",
    "validUntil": "2025-12-16T23:59:59Z"
}

The mandatory information as specified by the issuer is specified via an array of JSON pointers as shown below.

Example 93 : Mandatory Pointers

["/issuer"]

The result of applying the above JSON pointers to the permanent resident credential is shown below.

Example 94 : JSON Pointers and Values

[
  {
    "pointer": "/issuer",
    "value": {
      "id": "did:key:zDnaeTHxNEBZoKaEo6PdA83fq98ebiFvo3X273Ydu4YmV96rg",
      "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4z/DiPwAG0ALnwgz64QAAAABJRU5ErkJggg=="
    }
  }
]

Transformation of the unsigned document begins with canonicalizing the document as shown below.

Example 95 : Canonical Document

[
  "<did:key:zDnaeTHxNEBZoKaEo6PdA83fq98ebiFvo3X273Ydu4YmV96rg> <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4z/DiPwAG0ALnwgz64QAAAABJRU5ErkJggg==> .\n",
  "_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#PermanentResidentCard> .\n",
  "_:c14n0 <https://schema.org/identifier> \"83627465\" .\n",
  "_:c14n0 <https://w3id.org/citizenship#lprCategory> \"C09\" .\n",
  "_:c14n0 <https://w3id.org/citizenship#lprNumber> \"999-999-999\" .\n",
  "_:c14n1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://schema.org/Person> .\n",
  "_:c14n1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#PermanentResident> .\n",
  "_:c14n1 <https://schema.org/birthDate> \"1978-07-17\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:c14n1 <https://schema.org/familyName> \"SMITH\" .\n",
  "_:c14n1 <https://schema.org/gender> \"Female\" .\n",
  "_:c14n1 <https://schema.org/givenName> \"JANE\" .\n",
  "_:c14n1 <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4v43hPwAHIgK1v4tX6wAAAABJRU5ErkJggg==> .\n",
  "_:c14n1 <https://w3id.org/citizenship#birthCountry> \"Arcadia\" .\n",
  "_:c14n1 <https://w3id.org/citizenship#commuterClassification> \"C1\" .\n",
  "_:c14n1 <https://w3id.org/citizenship#permanentResidentCard> _:c14n0 .\n",
  "_:c14n1 <https://w3id.org/citizenship#residentSince> \"2015-01-01\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:c14n2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#PermanentResidentCardCredential> .\n",
  "_:c14n2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/2018/credentials#VerifiableCredential> .\n",
  "_:c14n2 <https://schema.org/description> \"Permanent Resident Card from Government of Utopia.\" .\n",
  "_:c14n2 <https://schema.org/name> \"Permanent Resident Card\" .\n",
  "_:c14n2 <https://www.w3.org/2018/credentials#credentialSubject> _:c14n1 .\n",
  "_:c14n2 <https://www.w3.org/2018/credentials#issuer> <did:key:zDnaeTHxNEBZoKaEo6PdA83fq98ebiFvo3X273Ydu4YmV96rg> .\n",
  "_:c14n2 <https://www.w3.org/2018/credentials#validFrom> \"2024-12-16T00:00:00Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:c14n2 <https://www.w3.org/2018/credentials#validUntil> \"2025-12-16T23:59:59Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n"
]

Example 96 : Canonical HMAC Document

[
  "<did:key:zDnaeTHxNEBZoKaEo6PdA83fq98ebiFvo3X273Ydu4YmV96rg> <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4z/DiPwAG0ALnwgz64QAAAABJRU5ErkJggg==> .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://schema.org/Person> .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#PermanentResident> .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/birthDate> \"1978-07-17\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/familyName> \"SMITH\" .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/gender> \"Female\" .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/givenName> \"JANE\" .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4v43hPwAHIgK1v4tX6wAAAABJRU5ErkJggg==> .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#birthCountry> \"Arcadia\" .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#commuterClassification> \"C1\" .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#permanentResidentCard> _:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 .\n",
  "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#residentSince> \"2015-01-01\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#PermanentResidentCard> .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://schema.org/identifier> \"83627465\" .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://w3id.org/citizenship#lprCategory> \"C09\" .\n",
  "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://w3id.org/citizenship#lprNumber> \"999-999-999\" .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#PermanentResidentCardCredential> .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/2018/credentials#VerifiableCredential> .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://schema.org/description> \"Permanent Resident Card from Government of Utopia.\" .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://schema.org/name> \"Permanent Resident Card\" .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://www.w3.org/2018/credentials#credentialSubject> _:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://www.w3.org/2018/credentials#issuer> <did:key:zDnaeTHxNEBZoKaEo6PdA83fq98ebiFvo3X273Ydu4YmV96rg> .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://www.w3.org/2018/credentials#validFrom> \"2024-12-16T00:00:00Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n",
  "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://www.w3.org/2018/credentials#validUntil> \"2025-12-16T23:59:59Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n"
]

Example 97 : Add Base Transformation

{
  "mandatoryPointers": [
    "/issuer"
  ],
  "mandatory": {
    "dataType": "Map",
    "value": [
      [
        0,
        "<did:key:zDnaeTHxNEBZoKaEo6PdA83fq98ebiFvo3X273Ydu4YmV96rg> <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4z/DiPwAG0ALnwgz64QAAAABJRU5ErkJggg==> .\n"
      ],
      [
        16,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#PermanentResidentCardCredential> .\n"
      ],
      [
        17,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/2018/credentials#VerifiableCredential> .\n"
      ],
      [
        21,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://www.w3.org/2018/credentials#issuer> <did:key:zDnaeTHxNEBZoKaEo6PdA83fq98ebiFvo3X273Ydu4YmV96rg> .\n"
      ]
    ]
  },
  "nonMandatory": {
    "dataType": "Map",
    "value": [
      [
        1,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://schema.org/Person> .\n"
      ],
      [
        2,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#PermanentResident> .\n"
      ],
      [
        3,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/birthDate> \"1978-07-17\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n"
      ],
      [
        4,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/familyName> \"SMITH\" .\n"
      ],
      [
        5,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/gender> \"Female\" .\n"
      ],
      [
        6,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/givenName> \"JANE\" .\n"
      ],
      [
        7,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://schema.org/image> <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4v43hPwAHIgK1v4tX6wAAAABJRU5ErkJggg==> .\n"
      ],
      [
        8,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#birthCountry> \"Arcadia\" .\n"
      ],
      [
        9,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#commuterClassification> \"C1\" .\n"
      ],
      [
        10,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#permanentResidentCard> _:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 .\n"
      ],
      [
        11,
        "_:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg <https://w3id.org/citizenship#residentSince> \"2015-01-01\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n"
      ],
      [
        12,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/citizenship#PermanentResidentCard> .\n"
      ],
      [
        13,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://schema.org/identifier> \"83627465\" .\n"
      ],
      [
        14,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://w3id.org/citizenship#lprCategory> \"C09\" .\n"
      ],
      [
        15,
        "_:u4YIOZn1MHES1Z4Ij2hWZG3R4dEYBqg5fHTyDEvYhC38 <https://w3id.org/citizenship#lprNumber> \"999-999-999\" .\n"
      ],
      [
        18,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://schema.org/description> \"Permanent Resident Card from Government of Utopia.\" .\n"
      ],
      [
        19,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://schema.org/name> \"Permanent Resident Card\" .\n"
      ],
      [
        20,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://www.w3.org/2018/credentials#credentialSubject> _:u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg .\n"
      ],
      [
        22,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://www.w3.org/2018/credentials#validFrom> \"2024-12-16T00:00:00Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n"
      ],
      [
        23,
        "_:uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw <https://www.w3.org/2018/credentials#validUntil> \"2025-12-16T23:59:59Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime> .\n"
      ]
    ]
  },
  "hmacKeyString": "00112233445566778899AABBCCDDEEFF00112233445566778899AABBCCDDEEFF"
}

The next step is to create the base proof configuration and canonicalize it. This is shown in the following two examples.

Example 98 : Base Proof Configuration

{
  "type": "DataIntegrityProof",
  "cryptosuite": "ecdsa-sd-2023",
  "created": "2023-08-15T23:36:38Z",
  "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
  "proofPurpose": "assertionMethod",
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ]
}

Example 99 : Canonical Base Proof Configuration

_:c14n0 <http://purl.org/dc/terms/created> "2023-08-15T23:36:38Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
_:c14n0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://w3id.org/security#DataIntegrityProof> .
_:c14n0 <https://w3id.org/security#cryptosuite> "ecdsa-sd-2023"^^<https://w3id.org/security#cryptosuiteString> .
_:c14n0 <https://w3id.org/security#proofPurpose> <https://w3id.org/security#assertionMethod> .
_:c14n0
<https://w3id.org/security#verificationMethod>
<did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP>
.

Example 100 : Add Base Hashes

{
  "proofHash": "9c5c9b189f06cfa9d9f21a838ccb9b04316f07ad1a517bfd4955ee28c6a8229c",
  "mandatoryHash": "b76d8d5bf67d27f51597519d19d95809c75e35212cc65291bd71bbe36007f979"
}

Example 101 : Add Base Signing

{
  "baseSignature": "1c00d200b76a4c87ed57aae0f09a6a05eb4e254898842a758d3b0069517ea8977f9a118b4dcc17bec33e9f9ef41b83dcde0957dc08643f546c8ca2360d1b1f2f",
  "publicKey": "zDnaeTHfhmSaQKBc7CmdL3K7oYg3D6SC7yowe2eBeVd2DH32r",
  "signatures": [
    "fd91ec48b3524965f7a1453e9ffa067054eca6f7d6338a84525eb3288bb0caf7a9651f02fee14d6d33ee1679aa8828348ccc574e194d7f57fca8be354c1b30f7",
    "3568e1402af672cb1a4c360ed7030ca8b1a744eed3c4572774e96d23e3a890db148de8dbd06594244a283f46247a540e78d14789e0e0c64ee96b6e53863707bc",
    "008fb2b467d7b2a46f16727532ae32e4027fc7746d478815c332d0a5c46021031bf72b20b0835166e21d0d3b50a6d15d75f30df14eb9b1ca10af521644564837",
    "3a6263590ab7fbc4e5ef7bc6c3f6b9cdd8a96c7c4d9a1f120612213ca39a50f39d7b56d6365ead6054bdbe4b971b2769d61841a3f7236a7434e5f1b0f6e2e8fc",
    "1b922ea997916494648491373084bc71df1fe0918665021f530829b4a387eccb48630f76015da36a079b3882f6ff70a3f87acbce78608e66867e5b2fc31df82f",
    "270f83139fe21ea6cb2176e6855580f7dc3f6694f0ab3efb723edc7844c376d2e3566b5ee1674834a8e69d197aae793e13a8a355423431a38daa442b6b440ada",
    "0106894e5850a53d4306eb237f52b11579e25916aaa97ae4f91fd258bd3806a6e24443609d469792598b17bd54da1595b8266efa20aaaee271ce1aeab7c74042",
    "ddc8430a1bf8cdbbb6e8c1e2dcb434dc0db59ab0c5501bd7dacee9e2c0234e2399ed95765d62ef4cabf0fe8117ee32f24b8f8c64d1955ddd4362269d9493035e",
    "a16b9b2761a89b79428a1c8bbf19216e4d07271022bf9867d11a0055a8f19aa9583196d01234ad63a390b2971eebde0ae748258593500277a90f0d74fd2164f1",
    "c6b8ab5a139770eef2fdabcc24ae63fbdf93a250238df7f29e2c905591e660e8fc87f74ac53eba18fe0487c6effeebbf8c9e4d075d5ae91b2ed7842c67e0b429",
    "e7ee420aa027ba4671b926c29e2c574f94461660a0b3d6c828cce50314d9e1e4c346ed119352adf6141c66e2fce4a2cb7486c3f81cc42e388a5f921285677d94",
    "8cc617955838bc95f849c8a782955374baf151727e8d12e5b4d0a200b406dcd839dbe5d5f760cc3b02bd65081d915138cbf14846b06e898916d8e30c725aaa5f",
    "e10f849d052c6de7aa2459d93552ac5ea2ebf52d2e4ec6257b10654734066553a09e418bef1154f4af9f942c4b5cc0ad5a36ea3758c858d60cad68971398ed7f",
    "acc0b0b8913da9043fdf1b5b19ac08a31dc809e128128bf9fde0558d3a05ca9198c49c152a3a55e6c3a6ab0bd59736cbe1e0c5b43af83c1a7a753a452a0241b5",
    "2aadfc3bf665674c59537988413cc3fd945536501aa6fa541bb02bc398f50d12522b52775d39921a1ed3b8c17b4c9c7f418973b9b08f6fee1d60e9e48904e1c2",
    "e41fcb03a010398c1a0a89103dbaa61f606e81548e7237a26b208ac40d5787664bd76ec4a68b6bc97aad0e771a5e884493501c5aa52aadd74fe1181bed6d4d6e",
    "b9638d13bc4c1aecb987e0f713ef5e0a9290cf69cb182f48c2761530a5d6095db9f4196e706835bf35492d23215b9b50632256ac605f74df01c55144863bf202",
    "d54d0056b279a17c591bd8580014f89c8cdabe20c80d84f7c137c4a36f97850dd0803fd6f1d70814a0b58dce9d50f30192c980d5bc451dea9a6569f90eb5d8b8",
    "a678ac62c5416d0e93b9dbd3efa9add4c1e1a79e6707ba3d831ffc119f6837c184a7652340cb8a62004f459c905067b9cc03f43b3c677a022eeab1d7d7243c05",
    "63730c42010acac32391d72d4f755b08588e1c289ab93e2a2c2d9a5d85a6d3d06fdeb39939f614efb4b3191966bae6f500ee44267ae44990f30b44e6c92943b4"
  ],
  "mandatoryPointers": [
    "/issuer"
  ]
}

Finally, the values above are run through the algorithm of Section 3.5.2 serializeBaseProofValue to produce the proofValue which is used in the signed based document shown below.

Example 102 : Signed Base Document

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ],
  "type": [
    "VerifiableCredential",
    "PermanentResidentCardCredential"
  ],
  "issuer": {
    "id": "did:key:zDnaeTHxNEBZoKaEo6PdA83fq98ebiFvo3X273Ydu4YmV96rg",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4z/DiPwAG0ALnwgz64QAAAABJRU5ErkJggg=="
  },
  "name": "Permanent Resident Card",
  "description": "Permanent Resident Card from Government of Utopia.",
  "credentialSubject": {
    "type": [
      "PermanentResident",
      "Person"
    ],
    "givenName": "JANE",
    "familyName": "SMITH",
    "gender": "Female",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4v43hPwAHIgK1v4tX6wAAAABJRU5ErkJggg==",
    "residentSince": "2015-01-01",
    "commuterClassification": "C1",
    "birthCountry": "Arcadia",
    "birthDate": "1978-07-17",
    "permanentResidentCard": {
      "type": [
        "PermanentResidentCard"
      ],
      "identifier": "83627465",
      "lprCategory": "C09",
      "lprNumber": "999-999-999"
    }
  },
  "validFrom": "2024-12-16T00:00:00Z",
  "validUntil": "2025-12-16T23:59:59Z",
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "ecdsa-sd-2023",
    "created": "2023-08-15T23:36:38Z",
    "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
    "proofPurpose": "assertionMethod",
    "proofValue": "u2V0AhVhAHADSALdqTIftV6rg8JpqBetOJUiYhCp1jTsAaVF-qJd_mhGLTcwXvsM-n570G4Pc3glX3AhkP1RsjKI2DRsfL1gjgCQCKnLOGbY_FuM-ASpSkkOxsIR2E8n7Ml2q1UQ6tEwzi5NYIAARIjNEVWZ3iJmqu8zd7v8AESIzRFVmd4iZqrvM3e7_lFhA_ZHsSLNSSWX3oUU-n_oGcFTspvfWM4qEUl6zKIuwyvepZR8C_uFNbTPuFnmqiCg0jMxXThlNf1f8qL41TBsw91hANWjhQCr2cssaTDYO1wMMqLGnRO7TxFcndOltI-OokNsUjejb0GWUJEooP0YkelQOeNFHieDgxk7pa25ThjcHvFhAAI-ytGfXsqRvFnJ1Mq4y5AJ_x3RtR4gVwzLQpcRgIQMb9ysgsINRZuIdDTtQptFddfMN8U65scoQr1IWRFZIN1hAOmJjWQq3-8Tl73vGw_a5zdipbHxNmh8SBhIhPKOaUPOde1bWNl6tYFS9vkuXGydp1hhBo_cjanQ05fGw9uLo_FhAG5IuqZeRZJRkhJE3MIS8cd8f4JGGZQIfUwgptKOH7MtIYw92AV2jagebOIL2_3Cj-HrLznhgjmaGflsvwx34L1hAJw-DE5_iHqbLIXbmhVWA99w_ZpTwqz77cj7ceETDdtLjVmte4WdINKjmnRl6rnk-E6ijVUI0MaONqkQra0QK2lhAAQaJTlhQpT1DBusjf1KxFXniWRaqqXrk-R_SWL04BqbiRENgnUaXklmLF71U2hWVuCZu-iCqruJxzhrqt8dAQlhA3chDChv4zbu26MHi3LQ03A21mrDFUBvX2s7p4sAjTiOZ7ZV2XWLvTKvw_oEX7jLyS4-MZNGVXd1DYiadlJMDXlhAoWubJ2Gom3lCihyLvxkhbk0HJxAiv5hn0RoAVajxmqlYMZbQEjStY6OQspce694K50glhZNQAnepDw10_SFk8VhAxrirWhOXcO7y_avMJK5j-9-TolAjjffyniyQVZHmYOj8h_dKxT66GP4Eh8bv_uu_jJ5NB11a6Rsu14QsZ-C0KVhA5-5CCqAnukZxuSbCnixXT5RGFmCgs9bIKMzlAxTZ4eTDRu0Rk1Kt9hQcZuL85KLLdIbD-BzELjiKX5IShWd9lFhAjMYXlVg4vJX4ScingpVTdLrxUXJ-jRLltNCiALQG3Ng52-XV92DMOwK9ZQgdkVE4y_FIRrBuiYkW2OMMclqqX1hA4Q-EnQUsbeeqJFnZNVKsXqLr9S0uTsYlexBlRzQGZVOgnkGL7xFU9K-flCxLXMCtWjbqN1jIWNYMrWiXE5jtf1hArMCwuJE9qQQ_3xtbGawIox3ICeEoEov5_eBVjToFypGYxJwVKjpV5sOmqwvVlzbL4eDFtDr4PBp6dTpFKgJBtVhAKq38O_ZlZ0xZU3mIQTzD_ZRVNlAapvpUG7Arw5j1DRJSK1J3XTmSGh7TuMF7TJx_QYlzubCPb-4dYOnkiQThwlhA5B_LA6AQOYwaCokQPbqmH2BugVSOcjeiayCKxA1Xh2ZL127EpotryXqtDncaXohEk1AcWqUqrddP4Rgb7W1NblhAuWONE7xMGuy5h-D3E-9eCpKQz2nLGC9IwnYVMKXWCV259BlucGg1vzVJLSMhW5tQYyJWrGBfdN8BxVFEhjvyAlhA1U0AVrJ5oXxZG9hYABT4nIzaviDIDYT3wTfEo2-XhQ3QgD_W8dcIFKC1jc6dUPMBksmA1bxFHeqaZWn5DrXYuFhApnisYsVBbQ6TudvT76mt1MHhp55nB7o9gx_8EZ9oN8GEp2UjQMuKYgBPRZyQUGe5zAP0OzxnegIu6rHX1yQ8BVhAY3MMQgEKysMjkdctT3VbCFiOHCiauT4qLC2aXYWm09Bv3rOZOfYU77SzGRlmuub1AO5EJnrkSZDzC0TmySlDtIFnL2lzc3Vlcg"
  }
}

Example 103 : Recovered Base Signature Data

{
  "baseSignature": "1c00d200b76a4c87ed57aae0f09a6a05eb4e254898842a758d3b0069517ea8977f9a118b4dcc17bec33e9f9ef41b83dcde0957dc08643f546c8ca2360d1b1f2f",
  "proofPublicKey": "zDnaeTHfhmSaQKBc7CmdL3K7oYg3D6SC7yowe2eBeVd2DH32r",
  "hmacKey": "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
  "signatures": [
    "fd91ec48b3524965f7a1453e9ffa067054eca6f7d6338a84525eb3288bb0caf7a9651f02fee14d6d33ee1679aa8828348ccc574e194d7f57fca8be354c1b30f7",
    "3568e1402af672cb1a4c360ed7030ca8b1a744eed3c4572774e96d23e3a890db148de8dbd06594244a283f46247a540e78d14789e0e0c64ee96b6e53863707bc",
    "008fb2b467d7b2a46f16727532ae32e4027fc7746d478815c332d0a5c46021031bf72b20b0835166e21d0d3b50a6d15d75f30df14eb9b1ca10af521644564837",
    "3a6263590ab7fbc4e5ef7bc6c3f6b9cdd8a96c7c4d9a1f120612213ca39a50f39d7b56d6365ead6054bdbe4b971b2769d61841a3f7236a7434e5f1b0f6e2e8fc",
    "1b922ea997916494648491373084bc71df1fe0918665021f530829b4a387eccb48630f76015da36a079b3882f6ff70a3f87acbce78608e66867e5b2fc31df82f",
    "270f83139fe21ea6cb2176e6855580f7dc3f6694f0ab3efb723edc7844c376d2e3566b5ee1674834a8e69d197aae793e13a8a355423431a38daa442b6b440ada",
    "0106894e5850a53d4306eb237f52b11579e25916aaa97ae4f91fd258bd3806a6e24443609d469792598b17bd54da1595b8266efa20aaaee271ce1aeab7c74042",
    "ddc8430a1bf8cdbbb6e8c1e2dcb434dc0db59ab0c5501bd7dacee9e2c0234e2399ed95765d62ef4cabf0fe8117ee32f24b8f8c64d1955ddd4362269d9493035e",
    "a16b9b2761a89b79428a1c8bbf19216e4d07271022bf9867d11a0055a8f19aa9583196d01234ad63a390b2971eebde0ae748258593500277a90f0d74fd2164f1",
    "c6b8ab5a139770eef2fdabcc24ae63fbdf93a250238df7f29e2c905591e660e8fc87f74ac53eba18fe0487c6effeebbf8c9e4d075d5ae91b2ed7842c67e0b429",
    "e7ee420aa027ba4671b926c29e2c574f94461660a0b3d6c828cce50314d9e1e4c346ed119352adf6141c66e2fce4a2cb7486c3f81cc42e388a5f921285677d94",
    "8cc617955838bc95f849c8a782955374baf151727e8d12e5b4d0a200b406dcd839dbe5d5f760cc3b02bd65081d915138cbf14846b06e898916d8e30c725aaa5f",
    "e10f849d052c6de7aa2459d93552ac5ea2ebf52d2e4ec6257b10654734066553a09e418bef1154f4af9f942c4b5cc0ad5a36ea3758c858d60cad68971398ed7f",
    "acc0b0b8913da9043fdf1b5b19ac08a31dc809e128128bf9fde0558d3a05ca9198c49c152a3a55e6c3a6ab0bd59736cbe1e0c5b43af83c1a7a753a452a0241b5",
    "2aadfc3bf665674c59537988413cc3fd945536501aa6fa541bb02bc398f50d12522b52775d39921a1ed3b8c17b4c9c7f418973b9b08f6fee1d60e9e48904e1c2",
    "e41fcb03a010398c1a0a89103dbaa61f606e81548e7237a26b208ac40d5787664bd76ec4a68b6bc97aad0e771a5e884493501c5aa52aadd74fe1181bed6d4d6e",
    "b9638d13bc4c1aecb987e0f713ef5e0a9290cf69cb182f48c2761530a5d6095db9f4196e706835bf35492d23215b9b50632256ac605f74df01c55144863bf202",
    "d54d0056b279a17c591bd8580014f89c8cdabe20c80d84f7c137c4a36f97850dd0803fd6f1d70814a0b58dce9d50f30192c980d5bc451dea9a6569f90eb5d8b8",
    "a678ac62c5416d0e93b9dbd3efa9add4c1e1a79e6707ba3d831ffc119f6837c184a7652340cb8a62004f459c905067b9cc03f43b3c677a022eeab1d7d7243c05",
    "63730c42010acac32391d72d4f755b08588e1c289ab93e2a2c2d9a5d85a6d3d06fdeb39939f614efb4b3191966bae6f500ee44267ae44990f30b44e6c92943b4"
  ],
  "mandatoryPointers": [
    "/issuer"
  ]
}

Next, the holder needs to indicate what, if anything else, they wish to reveal to the verifiers by specifying JSON pointers for selective disclosure.

Example 104 : Selective Disclosure Pointers

["/validFrom",
"/validUntil",
"/credentialSubject/birthCountry"]

Example 105 : Unsigned Reveal Document

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ],
  "type": [
    "VerifiableCredential",
    "PermanentResidentCardCredential"
  ],
  "issuer": {
    "id": "did:key:zDnaeTHxNEBZoKaEo6PdA83fq98ebiFvo3X273Ydu4YmV96rg",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4z/DiPwAG0ALnwgz64QAAAABJRU5ErkJggg=="
  },
  "validFrom": "2024-12-16T00:00:00Z",
  "validUntil": "2025-12-16T23:59:59Z",
  "credentialSubject": {
    "type": [
      "PermanentResident",
      "Person"
    ],
    "birthCountry": "Arcadia"
  }
}

Example 106 : Derived Group Indexes

{
    "combinedIndexes":[0,1,2,8,16,17,20,21,22,23],
    "mandatoryIndexes":[0,16,17,21],
    "nonMandatoryIndexes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,18,19,20,22,23],
    "selectiveIndexes":[1,2,8,16,17,20,22,23]
}

Example 107 : Adjusted Mandatory Indexes

{
  "adjMandatoryIndexes":[0,4,5,7]
}

Example 108 : Filtered Signatures

{
    "adjSignatureIndexes":[0,1,7,17,18,19],
    "filteredSignatures":[
        "fd91ec48b3524965f7a1453e9ffa067054eca6f7d6338a84525eb3288bb0caf7a9651f02fee14d6d33ee1679aa8828348ccc574e194d7f57fca8be354c1b30f7",
        "3568e1402af672cb1a4c360ed7030ca8b1a744eed3c4572774e96d23e3a890db148de8dbd06594244a283f46247a540e78d14789e0e0c64ee96b6e53863707bc",
        "ddc8430a1bf8cdbbb6e8c1e2dcb434dc0db59ab0c5501bd7dacee9e2c0234e2399ed95765d62ef4cabf0fe8117ee32f24b8f8c64d1955ddd4362269d9493035e",
        "d54d0056b279a17c591bd8580014f89c8cdabe20c80d84f7c137c4a36f97850dd0803fd6f1d70814a0b58dce9d50f30192c980d5bc451dea9a6569f90eb5d8b8",
        "a678ac62c5416d0e93b9dbd3efa9add4c1e1a79e6707ba3d831ffc119f6837c184a7652340cb8a62004f459c905067b9cc03f43b3c677a022eeab1d7d7243c05",
        "63730c42010acac32391d72d4f755b08588e1c289ab93e2a2c2d9a5d85a6d3d06fdeb39939f614efb4b3191966bae6f500ee44267ae44990f30b44e6c92943b4"
        ]
}

Example 109 : Disclosure Data

{
  "baseSignature": "1c00d200b76a4c87ed57aae0f09a6a05eb4e254898842a758d3b0069517ea8977f9a118b4dcc17bec33e9f9ef41b83dcde0957dc08643f546c8ca2360d1b1f2f",
  "publicKey": "zDnaeTHfhmSaQKBc7CmdL3K7oYg3D6SC7yowe2eBeVd2DH32r",
  "signatures": [
    "fd91ec48b3524965f7a1453e9ffa067054eca6f7d6338a84525eb3288bb0caf7a9651f02fee14d6d33ee1679aa8828348ccc574e194d7f57fca8be354c1b30f7",
    "3568e1402af672cb1a4c360ed7030ca8b1a744eed3c4572774e96d23e3a890db148de8dbd06594244a283f46247a540e78d14789e0e0c64ee96b6e53863707bc",
    "ddc8430a1bf8cdbbb6e8c1e2dcb434dc0db59ab0c5501bd7dacee9e2c0234e2399ed95765d62ef4cabf0fe8117ee32f24b8f8c64d1955ddd4362269d9493035e",
    "d54d0056b279a17c591bd8580014f89c8cdabe20c80d84f7c137c4a36f97850dd0803fd6f1d70814a0b58dce9d50f30192c980d5bc451dea9a6569f90eb5d8b8",
    "a678ac62c5416d0e93b9dbd3efa9add4c1e1a79e6707ba3d831ffc119f6837c184a7652340cb8a62004f459c905067b9cc03f43b3c677a022eeab1d7d7243c05",
    "63730c42010acac32391d72d4f755b08588e1c289ab93e2a2c2d9a5d85a6d3d06fdeb39939f614efb4b3191966bae6f500ee44267ae44990f30b44e6c92943b4"
  ],
  "labelMap": {
    "dataType": "Map",
    "value": [
      [
        "c14n0",
        "u3Lv2QpFgo-YAegc1cQQKWJFW2sEjQF6FfuZ0VEoMKHg"
      ],
      [
        "c14n1",
        "uVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKw"
      ]
    ]
  },
  "mandatoryIndexes": [
    0,
    4,
    5,
    7
  ]
}

Finally using the disclosure data above with the algorithm of Section 3.5.7 serializeDerivedProofValue we obtain the signed derived (reveal) document shown below.

Example 110 : Signed Derived Document

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://w3id.org/citizenship/v4rc1"
  ],
  "type": [
    "VerifiableCredential",
    "PermanentResidentCardCredential"
  ],
  "issuer": {
    "id": "did:key:zDnaeTHxNEBZoKaEo6PdA83fq98ebiFvo3X273Ydu4YmV96rg",
    "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P4z/DiPwAG0ALnwgz64QAAAABJRU5ErkJggg=="
  },
  "validFrom": "2024-12-16T00:00:00Z",
  "validUntil": "2025-12-16T23:59:59Z",
  "credentialSubject": {
    "type": [
      "PermanentResident",
      "Person"
    ],
    "birthCountry": "Arcadia"
  },
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "ecdsa-sd-2023",
    "created": "2023-08-15T23:36:38Z",
    "verificationMethod": "did:key:zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP#zDnaepBuvsQ8cpsWrVKw8fbpGpvPeNSjVPTWoq6cRqaYzBKVP",
    "proofPurpose": "assertionMethod",
    "proofValue": "u2V0BhVhAHADSALdqTIftV6rg8JpqBetOJUiYhCp1jTsAaVF-qJd_mhGLTcwXvsM-n570G4Pc3glX3AhkP1RsjKI2DRsfL1gjgCQCKnLOGbY_FuM-ASpSkkOxsIR2E8n7Ml2q1UQ6tEwzi5OGWED9kexIs1JJZfehRT6f-gZwVOym99YzioRSXrMoi7DK96llHwL-4U1tM-4WeaqIKDSMzFdOGU1_V_yovjVMGzD3WEA1aOFAKvZyyxpMNg7XAwyosadE7tPEVyd06W0j46iQ2xSN6NvQZZQkSig_RiR6VA540UeJ4ODGTulrblOGNwe8WEDdyEMKG_jNu7boweLctDTcDbWasMVQG9fazuniwCNOI5ntlXZdYu9Mq_D-gRfuMvJLj4xk0ZVd3UNiJp2UkwNeWEDVTQBWsnmhfFkb2FgAFPicjNq-IMgNhPfBN8Sjb5eFDdCAP9bx1wgUoLWNzp1Q8wGSyYDVvEUd6pplafkOtdi4WECmeKxixUFtDpO529Pvqa3UweGnnmcHuj2DH_wRn2g3wYSnZSNAy4piAE9FnJBQZ7nMA_Q7PGd6Ai7qsdfXJDwFWEBjcwxCAQrKwyOR1y1PdVsIWI4cKJq5PiosLZpdhabT0G_es5k59hTvtLMZGWa65vUA7kQmeuRJkPMLRObJKUO0ogBYINy79kKRYKPmAHoHNXEECliRVtrBI0BehX7mdFRKDCh4AVggVkUuBrlOaELGVQWJD4M_qW5bcKEHWGNbOrPA_qAOKKyEAAQFBw"
  }
}

Data Integrity ECDSA Cryptosuites v1.0

Achieving Data Integrity using ECDSA with NIST-compliant curves

Abstract

Status of This Document

1. Introduction

1.1 Terminology

1.2 Conformance

2. Data Model

2.1 Verification Methods

2.1.1 Multikey

2.2 Proof Representations

2.2.1 DataIntegrityProof

3. Algorithms

3.1 Instantiate Cryptosuite

3.2 ecdsa-rdfc-2019

3.2.1 Create Proof (ecdsa-rdfc-2019)

3.2.2 Verify Proof (ecdsa-rdfc-2019)

3.2.3 Transformation (ecdsa-rdfc-2019)

3.2.4 Hashing (ecdsa-rdfc-2019)

3.2.5 Proof Configuration (ecdsa-rdfc-2019)

3.2.6 Proof Serialization (ecdsa-rdfc-2019)

3.2.7 Proof Verification (ecdsa-rdfc-2019)

3.3 ecdsa-jcs-2019

3.3.1 Create Proof (ecdsa-jcs-2019)

3.3.2 Verify Proof (ecdsa-jcs-2019)

3.3.3 Transformation (ecdsa-jcs-2019)

3.3.4 Hashing (ecdsa-jcs-2019)

3.3.5 Proof Configuration (ecdsa-jcs-2019)

3.3.6 Proof Serialization (ecdsa-jcs-2019)

3.3.7 Proof Verification (ecdsa-jcs-2019)

3.4 Selective Disclosure Functions

3.4.1 labelReplacementCanonicalizeNQuads

3.4.2 labelReplacementCanonicalizeJsonLd

3.4.3 createLabelMapFunction

3.4.4 createHmacIdLabelMapFunction

3.4.5 skolemizeNQuads

3.4.6 deskolemizeNQuads

3.4.7 skolemizeExpandedJsonLd

3.4.8 skolemizeCompactJsonLd

3.4.9 toDeskolemizedNQuads

3.4.10 jsonPointerToPaths

3.4.11 createInitialSelection

3.4.12 selectPaths

3.4.13 selectJsonLd

3.4.14 relabelBlankNodes

3.4.15 selectCanonicalNQuads

3.4.16 canonicalizeAndGroup

3.4.17 hashMandatoryNQuads

3.5 ecdsa-sd-2023 Functions

3.5.1 serializeSignData

3.5.2 serializeBaseProofValue

3.5.3 parseBaseProofValue

3.5.4 createDisclosureData

3.5.5 compressLabelMap

3.5.6 decompressLabelMap

3.5.7 serializeDerivedProofValue

3.5.8 parseDerivedProofValue

3.5.9 createVerifyData

3.6 ecdsa-sd-2023

3.6.1 Create Base Proof (ecdsa-sd-2023)

3.6.2 Base Proof Transformation (ecdsa-sd-2023)

3.6.3 Base Proof Hashing (ecdsa-sd-2023)

3.6.4 Base Proof Configuration (ecdsa-sd-2023)

3.6.5 Base Proof Serialization (ecdsa-sd-2023)

3.6.6 Add Derived Proof (ecdsa-sd-2023)

3.6.7 Verify Derived Proof (ecdsa-sd-2023)

4. Security Considerations

4.1 Choice of ECDSA and Parameters

4.2 Implementation Considerations for ECDSA Algorithms

4.3 Key Management

5. Privacy Considerations

5.1 Unlinkable Disclosure

A. Test Vectors

A.1 Representation: ecdsa-rdfc-2019, with curve P-256

A.2 Enhanced Example for Representation: ecdsa-rdfc-2019, with curve P-256

A.3 Representation: ecdsa-rdfc-2019, with curve P-384

A.4 Enhanced Example for Representation: ecdsa-rdfc-2019, with curve P-384

A.5 Representation: ecdsa-jcs-2019 with curve P-256

A.6 Representation: ecdsa-jcs-2019 with curve P-384

A.7 Representation: ecdsa-sd-2023