diff --git a/.github/banner_identity.png b/.github/banner_identity.png new file mode 100644 index 0000000000..64b13841d1 Binary files /dev/null and b/.github/banner_identity.png differ diff --git a/.github/banner_identity.svg b/.github/banner_identity.svg deleted file mode 100644 index 61ffbf9bcc..0000000000 --- a/.github/banner_identity.svg +++ /dev/null @@ -1,83 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml index c28cc91f1b..64c6b93546 100644 --- a/.github/workflows/build-and-test.yml +++ b/.github/workflows/build-and-test.yml @@ -100,6 +100,11 @@ jobs: }} steps: + + + - name: git configure long path + if: matrix.os == 'windows-latest' + run: git config --global core.longpaths true - uses: actions/checkout@v3 - name: Ensure, OpenSSL is available in Windows diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml index 018b46147e..e4724abc8d 100644 --- a/.github/workflows/clippy.yml +++ b/.github/workflows/clippy.yml @@ -35,7 +35,7 @@ jobs: - name: Install wasm-bindgen-cli uses: jetli/wasm-bindgen-action@24ba6f9fff570246106ac3f80f35185600c3f6c9 with: - version: '0.2.100' + version: '0.2.102' - name: core clippy check uses: actions-rs-plus/clippy-check@b09a9c37c9df7db8b1a5d52e8fe8e0b6e3d574c4 diff --git a/.github/workflows/shared-build-wasm.yml b/.github/workflows/shared-build-wasm.yml index 45673fb886..01660fcb75 100644 --- a/.github/workflows/shared-build-wasm.yml +++ b/.github/workflows/shared-build-wasm.yml @@ -57,7 +57,7 @@ jobs: - name: Install wasm-bindgen-cli uses: jetli/wasm-bindgen-action@24ba6f9fff570246106ac3f80f35185600c3f6c9 with: - version: '0.2.100' + version: '0.2.102' - name: Setup sccache uses: './.github/actions/rust/sccache/setup-sccache' diff --git a/Cargo.toml b/Cargo.toml index 95e7483905..5baad04cb9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,6 +22,7 @@ members = [ "identity_jose", "identity_ecdsa_verifier", "identity_eddsa_verifier", + "identity_pqc_verifier", "examples", ] @@ -29,14 +30,15 @@ exclude = ["bindings/wasm/identity_wasm", "bindings/grpc"] [workspace.dependencies] bls12_381_plus = { version = "0.8.17" } -iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction" } -iota_interaction_ts = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction_ts" } -product_common = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "product_common" } +iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction" } +iota_interaction_ts = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction_ts" } +product_common = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "product_common" } serde = { version = "1.0", default-features = false, features = ["alloc", "derive"] } serde_json = { version = "1.0", default-features = false } +oqs = { version = "0.10", default-features = false, features = ["sigs", "std", "vendored"] } strum = { version = "0.25", default-features = false, features = ["std", "derive"] } thiserror = { version = "1.0", default-features = false } -json-proof-token = { version = "0.3.5" } +json-proof-token = { version = "0.4" } zkryptium = { version = "0.2.2", default-features = false, features = ["bbsplus"] } [workspace.lints.clippy] diff --git a/README.md b/README.md index 30cf08f6c5..51b8425e76 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -![banner](https://github.com/iotaledger/identity/raw/HEAD/.github/banner_identity.svg) +![banner](https://github.com/iotaledger/identity/raw/HEAD/.github/banner_identity.png)

StackExchange diff --git a/bindings/grpc/Cargo.toml b/bindings/grpc/Cargo.toml index 9145fdd455..ab0312aa05 100644 --- a/bindings/grpc/Cargo.toml +++ b/bindings/grpc/Cargo.toml @@ -24,7 +24,7 @@ identity_iota = { path = "../../identity_iota", features = ["resolver", "sd-jwt" identity_jose = { path = "../../identity_jose" } identity_storage = { path = "../../identity_storage", features = ["memstore"] } identity_stronghold = { path = "../../identity_stronghold", features = ["send-sync-storage"] } -iota-sdk = { git = "https://github.com/iotaledger/iota.git", package = "iota-sdk", tag = "v1.4.1" } +iota-sdk = { git = "https://github.com/iotaledger/iota.git", package = "iota-sdk", tag = "v1.7.0" } iota-sdk-legacy = { package = "iota-sdk", version = "1.1.2", features = ["stronghold"] } prost = "0.13" rand = "0.8.5" diff --git a/bindings/wasm/identity_wasm/Cargo.toml b/bindings/wasm/identity_wasm/Cargo.toml index a386774ec3..02b68ae779 100644 --- a/bindings/wasm/identity_wasm/Cargo.toml +++ b/bindings/wasm/identity_wasm/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "identity_wasm" -version = "1.6.0-beta.7" +version = "1.6.0-beta.10" authors = ["IOTA Stiftung"] edition = "2021" homepage = "https://www.iota.org" @@ -23,14 +23,15 @@ console_error_panic_hook = { version = "0.1" } fastcrypto = { git = "https://github.com/MystenLabs/fastcrypto", rev = "69d496c71fb37e3d22fe85e5bbfd4256d61422b9", package = "fastcrypto" } identity_ecdsa_verifier = { path = "../../../identity_ecdsa_verifier", default-features = false, features = ["es256", "es256k"] } identity_eddsa_verifier = { path = "../../../identity_eddsa_verifier", default-features = false, features = ["ed25519"] } +iota-caip = { git = "https://github.com/iotaledger/iota-caip.git", features = ["serde"] } # Remove iota-sdk dependency while working on issue #1445 iota-sdk = { version = "1.1.5", default-features = false, features = ["serde", "std"] } -iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction", default-features = false } -iota_interaction_ts = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction_ts" } +iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction", default-features = false } +iota_interaction_ts = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction_ts" } js-sys = { version = "0.3.61" } -json-proof-token = "0.3.4" +json-proof-token = "0.4" proc_typescript = { version = "0.1.0", path = "./proc_typescript" } -product_common = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "product_common", features = ["core-client", "transaction", "bindings", "gas-station", "default-http-client"] } +product_common = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "product_common", features = ["core-client", "transaction", "bindings", "gas-station", "default-http-client"] } secret-storage = { git = "https://github.com/iotaledger/secret-storage.git", default-features = false, tag = "v0.3.0" } serde = { version = "1.0", features = ["derive"] } serde-wasm-bindgen = "0.6.5" @@ -39,7 +40,7 @@ serde_repr = { version = "0.1", default-features = false } # Want to use the nice API of tokio::sync::RwLock for now even though we can't use threads. tokio = { version = "1.46.1", default-features = false, features = ["sync"] } tsify = "0.4.5" -wasm-bindgen = { version = "0.2.100", features = ["serde-serialize"] } +wasm-bindgen = { version = "=0.2.102", features = ["serde-serialize"] } wasm-bindgen-futures = { version = "0.4", default-features = false } [dependencies.identity_iota] @@ -54,8 +55,11 @@ features = [ "sd-jwt-vc", "status-list-2021", "jpt-bbs-plus", + "pqc", + "hybrid", "gas-station", "default-http-client", + "irl", ] [target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies] diff --git a/bindings/wasm/identity_wasm/examples/README.md b/bindings/wasm/identity_wasm/examples/README.md index a55d044d2b..81af67422c 100644 --- a/bindings/wasm/identity_wasm/examples/README.md +++ b/bindings/wasm/identity_wasm/examples/README.md @@ -1,4 +1,4 @@ -![banner](https://github.com/iotaledger/identity/raw/HEAD/.github/banner_identity.svg) +![banner](https://github.com/iotaledger/identity/raw/HEAD/.github/banner_identity.png) ## IOTA Identity Examples diff --git a/bindings/wasm/identity_wasm/examples/src/1_advanced/13_linked_verifiable_presentation.ts b/bindings/wasm/identity_wasm/examples/src/1_advanced/13_linked_verifiable_presentation.ts new file mode 100644 index 0000000000..3cf7da5d79 --- /dev/null +++ b/bindings/wasm/identity_wasm/examples/src/1_advanced/13_linked_verifiable_presentation.ts @@ -0,0 +1,151 @@ +// Copyright 2020-2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + CoreDID, + Credential, + EdDSAJwsVerifier, + IdentityClientReadOnly, + IotaDocument, + IrlResolver, + JwsSignatureOptions, + Jwt, + JwtPresentationOptions, + JwtPresentationValidationOptions, + JwtPresentationValidator, + LinkedVerifiablePresentationService, + Presentation, + Resolver, + Storage, +} from "@iota/identity-wasm/node"; +import { IotaClient } from "@iota/iota-sdk/client"; +import { OnChainNotarization } from "@iota/notarization/node"; +import { + createDocumentForNetwork, + getFundedClient, + getMemstorage, + getNotarizationClient, + IOTA_IDENTITY_PKG_ID, + NETWORK_URL, + TEST_GAS_BUDGET, +} from "../util"; + +/** + * This example shows how to create a Verifiable Presentation and validate it. + * A Verifiable Presentation is the format in which a (collection of) Verifiable Credential(s) gets shared. + * It is signed by the subject, to prove control over the Verifiable Credential with a nonce or timestamp. + */ +export async function linkedVp() { + // =========================================================================== + // Create identities and clients. + // =========================================================================== + + // Create new client to connect to IOTA network + const iotaClient = new IotaClient({ url: NETWORK_URL }); + const network = await iotaClient.getChainIdentifier(); + + // Create issuer account, create identity, and publish DID document for it + const storage = getMemstorage(); + const identityClient = await getFundedClient(storage); + const [unpublishedDidDocument, fragment] = await createDocumentForNetwork(storage, network); + const notarizationClient = await getNotarizationClient(identityClient.signer()); + const publishedDidDocument = await identityClient + .publishDidDocument(unpublishedDidDocument, identityClient.senderAddress()) + .buildAndExecute(identityClient) + .then(res => res.output); + + // =========================================================================== + // Create a Verifiable Presentation and host it on-chain. + // =========================================================================== + + const jwtVp = await makeVpJwt(publishedDidDocument, storage, fragment); + const notarizedVp: OnChainNotarization = await notarizationClient + .createLocked() + .withStringState(jwtVp.toString(), "My Linked VP") + .finish() + .buildAndExecute(notarizationClient) + .then(res => res.output); + + // =========================================================================== + // Create Linked Verifiable Presentation service. + // =========================================================================== + + const serviceUrl = publishedDidDocument.id().join("#linked-vp"); + const linkedVpService = new LinkedVerifiablePresentationService({ + id: serviceUrl, + linkedVp: notarizedVp.iotaResourceLocatorBuilder(notarizationClient.network()).data(), + }); + publishedDidDocument.insertService(linkedVpService.toService()); + + await identityClient.publishDidDocumentUpdate(publishedDidDocument, TEST_GAS_BUDGET); + + // =========================================================================== + // Verification. + // =========================================================================== + + const resolver = new Resolver({ + client: await IdentityClientReadOnly.createWithPkgId(iotaClient, IOTA_IDENTITY_PKG_ID), + }); + // Resolve the presentation holder. + const presentationHolderDID: CoreDID = JwtPresentationValidator.extractHolder(jwtVp); + const resolvedHolder = await resolver.resolve( + presentationHolderDID.toString(), + ); + + // Get the Linked Verifiable Presentation Services from the DID Document. + const linkedVpServices = resolvedHolder.service().filter(service => + service.type().includes("LinkedVerifiablePresentation") + ); + console.assert(linkedVpServices.length == 1, "expected exactly one Linked Verifiable Presentation service"); + + // Get the VPs included the service. + const vpUrl = LinkedVerifiablePresentationService.fromService(linkedVpServices[0]).verifiablePresentationUrls()[0]; + console.log(`Fetching VP at \`${vpUrl}\``); + + const irlResolver = new IrlResolver({ customNetworks: [{ chainId: network, endpoint: NETWORK_URL }] }); + const resolvedJwtVp = await irlResolver.resolve(vpUrl).then(value => new Jwt(value as string)); + + // Validate presentation. Note that this doesn't validate the included credentials. + const _decodedPresentation = new JwtPresentationValidator(new EdDSAJwsVerifier()).validate( + resolvedJwtVp, + resolvedHolder, + new JwtPresentationValidationOptions(), + ); + + console.log("Successfully validated the fetched presentation"); +} + +async function makeVpJwt(didDocument: IotaDocument, storage: Storage, fragment: string): Promise { + const credential = new Credential({ + id: "https://example.edu/credentials/3732", + type: "UniversityDegreeCredential", + issuer: didDocument.id(), + credentialSubject: { + id: didDocument.id(), + name: "Alice", + degreeName: "Bachelor of Science and Arts", + degreeType: "BachelorDegree", + GPA: "4.0", + }, + }); + const jwtCredential = await didDocument.createCredentialJwt( + storage, + fragment, + credential, + new JwsSignatureOptions(), + ); + + const presentation = new Presentation({ + holder: didDocument.id(), + verifiableCredential: [jwtCredential], + }); + const jwtVp = await didDocument.createPresentationJwt( + storage, + fragment, + presentation, + new JwsSignatureOptions(), + new JwtPresentationOptions(), + ); + + return jwtVp; +} diff --git a/bindings/wasm/identity_wasm/examples/src/1_advanced/8_zkp.ts b/bindings/wasm/identity_wasm/examples/src/1_advanced/8_zkp.ts index a1bb5bbc67..51904fa7ad 100644 --- a/bindings/wasm/identity_wasm/examples/src/1_advanced/8_zkp.ts +++ b/bindings/wasm/identity_wasm/examples/src/1_advanced/8_zkp.ts @@ -19,6 +19,53 @@ import { import { IotaClient } from "@iota/iota-sdk/client"; import { getFundedClient, getMemstorage, IOTA_IDENTITY_PKG_ID, NETWORK_URL } from "../util"; +/** Creates a DID Document and publishes it in a new Alias Output. + +Its functionality is equivalent to the "create DID" example +and exists for convenient calling from the other examples. */ +export async function createDid(client: Client, secretManager: SecretManagerType, storage: Storage): Promise<{ + address: Address; + document: IotaDocument; + fragment: string; +}> { + const didClient = new IotaIdentityClient(client); + const networkHrp: string = await didClient.getNetworkHrp(); + + const secretManagerInstance = new SecretManager(secretManager); + const walletAddressBech32 = (await secretManagerInstance.generateEd25519Addresses({ + accountIndex: 0, + range: { + start: 0, + end: 1, + }, + bech32Hrp: networkHrp, + }))[0]; + + console.log("Wallet address Bech32:", walletAddressBech32); + + await ensureAddressHasFunds(client, walletAddressBech32); + + const address: Address = Utils.parseBech32Address(walletAddressBech32); + + // Create a new DID document with a placeholder DID. + // The DID will be derived from the Alias Id of the Alias Output after publishing. + const document = new IotaDocument(networkHrp); + + const fragment = await document.generateMethodJwp( + storage, + ProofAlgorithm.BBS, + undefined, + MethodScope.VerificationMethod(), + ); + // Construct an Alias Output containing the DID document, with the wallet address + // set as both the state controller and governor. + const aliasOutput: AliasOutput = await didClient.newDidOutput(address, document); + + // Publish the Alias Output and get the published DID document. + const published = await didClient.publishDidOutput(secretManager, aliasOutput); + + return { address, document: published, fragment }; +} export async function zkp() { // =========================================================================== // Step 1: Create identity for the issuer. diff --git a/bindings/wasm/identity_wasm/examples/src/1_advanced/hybrid.ts b/bindings/wasm/identity_wasm/examples/src/1_advanced/hybrid.ts new file mode 100644 index 0000000000..f0d262e08d --- /dev/null +++ b/bindings/wasm/identity_wasm/examples/src/1_advanced/hybrid.ts @@ -0,0 +1,231 @@ +// Copyright 2024 Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +import { + CompositeAlgId, + CoreDID, + Credential, + Duration, + EdDSAJwsVerifier, + FailFast, + IotaDocument, + JwkPqMemStore, + JwsSignatureOptions, + JwsVerificationOptions, + Jwt, + JwtCredentialValidationOptions, + JwtCredentialValidator, + JwtCredentialValidatorHybrid, + JwtPresentationOptions, + JwtPresentationValidationOptions, + JwtPresentationValidator, + JwtPresentationValidatorHybrid, + KeyIdMemStore, + MethodScope, + PQJwsVerifier, + Presentation, + Resolver, + Storage, + SubjectHolderRelationship, + Timestamp, +} from "@iota/identity-wasm/node"; +import { IotaClient } from "@iota/iota-sdk/client"; +import { getFundedClient, NETWORK_URL } from "../util"; + +/** + * This example shows how to create an hybrid Verifiable Presentation and validate it + */ +export async function hybrid() { + // =========================================================================== + // Step 1: Create identities for the issuer and the holder. + // =========================================================================== + + const issuerStorage = new Storage(new JwkPqMemStore(), new KeyIdMemStore()); + const issuerClient = await getFundedClient(issuerStorage); + const issuerDocument = new IotaDocument(issuerClient.network()); + // Create a new method with PQ/T algorithm. + const issuerFragment = await issuerDocument.generateMethodHybrid( + issuerStorage, + CompositeAlgId.IdMldsa44Ed25519, + "#0", + MethodScope.VerificationMethod(), + ); + const issuerIdentity = await issuerClient + .createIdentity(issuerDocument) + .finish() + .buildAndExecute(issuerClient) + .then(res => res.output); + + const aliceStorage = new Storage(new JwkPqMemStore(), new KeyIdMemStore()); + const aliceClient = await getFundedClient(aliceStorage); + const aliceDocument = new IotaDocument(aliceClient.network()); + // Create a new method with PQ/T algorithm. + const aliceFragment = await aliceDocument.generateMethodHybrid( + aliceStorage, + CompositeAlgId.IdMldsa44Ed25519, + "#0", + MethodScope.VerificationMethod(), + ); + const aliceIdentity = await aliceClient + .createIdentity(aliceDocument) + .finish() + .buildAndExecute(aliceClient) + .then(res => res.output); + + // =========================================================================== + // Step 2: Issuer creates and signs a Verifiable Credential. + // =========================================================================== + + const subject = { + id: aliceDocument.id(), + name: "Alice", + degreeName: "Bachelor of Science and Arts", + degreeType: "BachelorDegree", + GPA: "4.0", + }; + + // Create an unsigned `UniversityDegree` credential for Alice + const unsignedVc = new Credential({ + id: "https://example.edu/credentials/3732", + type: "UniversityDegreeCredential", + issuer: issuerDocument.id(), + credentialSubject: subject, + }); + + // Create a Credential JWT with the issuer's hybrid verification method. + const credentialJwt = await issuerDocument.createCredentialJwtHybrid( + issuerStorage, + issuerFragment, + unsignedVc, + new JwsSignatureOptions(), + ); + + const res = new JwtCredentialValidatorHybrid(new EdDSAJwsVerifier(), new PQJwsVerifier()).validate( + credentialJwt, + issuerDocument, + new JwtCredentialValidationOptions(), + FailFast.FirstError, + ); + console.log("credentialjwt validation", res.intoCredential()); + + // =========================================================================== + // Step 3: Issuer sends the Verifiable Credential to the holder. + // =========================================================================== + + // The credential is then serialized to JSON and transmitted to the holder in a secure manner. + // Note that the credential is NOT published to the IOTA Tangle. It is sent and stored off-chain. + console.log(`Sending credential (as JWT) to the holder`, unsignedVc.toJSON()); + + // =========================================================================== + // Step 4: Verifier sends the holder a challenge and requests a signed Verifiable Presentation. + // =========================================================================== + + // A unique random challenge generated by the requester per presentation can mitigate replay attacks. + const nonce = "475a7984-1bb5-4c4c-a56f-822bccd46440"; + + // The verifier and holder also agree that the signature should have an expiry date + // 10 minutes from now. + const expires = Timestamp.nowUTC().checkedAdd(Duration.minutes(10)); + + // =========================================================================== + // Step 5: Holder creates a verifiable presentation from the issued credential for the verifier to validate. + // =========================================================================== + + // Create a Verifiable Presentation from the Credential + const unsignedVp = new Presentation({ + holder: aliceDocument.id(), + verifiableCredential: [credentialJwt], + }); + + // Create a Hybrid JWT verifiable presentation using the holder's verification method + // and include the requested challenge and expiry timestamp. + const presentationJwt = await aliceDocument.createPresentationJwtHybrid( + aliceStorage, + aliceFragment, + unsignedVp, + new JwsSignatureOptions({ nonce }), + new JwtPresentationOptions({ expirationDate: expires }), + ); + + // =========================================================================== + // Step 6: Holder sends a verifiable presentation to the verifier. + // =========================================================================== + console.log( + `Sending presentation (as JWT) to the verifier`, + unsignedVp.toJSON(), + ); + + // =========================================================================== + // Step 7: Verifier receives the Verifiable Presentation and verifies it. + // =========================================================================== + + // The verifier wants the following requirements to be satisfied: + // - JWT verification of the presentation (including checking the requested challenge to mitigate replay attacks) + // - JWT verification of the credentials. + // - The presentation holder must always be the subject, regardless of the presence of the nonTransferable property + // - The issuance date must not be in the future. + + const jwtPresentationValidationOptions = new JwtPresentationValidationOptions( + { + presentationVerifierOptions: new JwsVerificationOptions({ nonce }), + }, + ); + + const resolver = new Resolver({ + client: aliceClient, + }); + // Resolve the presentation holder. + const presentationHolderDID: CoreDID = JwtPresentationValidator.extractHolder(presentationJwt); + const resolvedHolder = await resolver.resolve( + presentationHolderDID.toString(), + ); + + // Validate presentation. Note that this doesn't validate the included credentials. + let decodedPresentation = new JwtPresentationValidatorHybrid(new EdDSAJwsVerifier(), new PQJwsVerifier()).validate( + presentationJwt, + resolvedHolder, + jwtPresentationValidationOptions, + ); + + // Validate the hybrid credentials in the presentation. + let credentialValidator = new JwtCredentialValidatorHybrid(new EdDSAJwsVerifier(), new PQJwsVerifier()); + let validationOptions = new JwtCredentialValidationOptions({ + subjectHolderRelationship: [ + presentationHolderDID.toString(), + SubjectHolderRelationship.AlwaysSubject, + ], + }); + + let jwtCredentials: Jwt[] = decodedPresentation + .presentation() + .verifiableCredential() + .map((credential) => { + const jwt = credential.tryIntoJwt(); + if (!jwt) { + throw new Error("expected a JWT credential"); + } else { + return jwt; + } + }); + + // Concurrently resolve the issuers' documents. + let issuers: string[] = []; + for (let jwtCredential of jwtCredentials) { + let issuer = JwtCredentialValidator.extractIssuerFromJwt(jwtCredential); + issuers.push(issuer.toString()); + } + let resolvedIssuers = await resolver.resolveMultiple(issuers); + + // Validate the credentials in the presentation. + for (let i = 0; i < jwtCredentials.length; i++) { + credentialValidator.validate( + jwtCredentials[i], + resolvedIssuers[i], + validationOptions, + FailFast.FirstError, + ); + } + + // Since no errors were thrown we know that the validation was successful. + console.log(`VP successfully validated`); +} diff --git a/bindings/wasm/identity_wasm/examples/src/1_advanced/pq.ts b/bindings/wasm/identity_wasm/examples/src/1_advanced/pq.ts new file mode 100644 index 0000000000..ffd0bf4c69 --- /dev/null +++ b/bindings/wasm/identity_wasm/examples/src/1_advanced/pq.ts @@ -0,0 +1,230 @@ +// Copyright 2024 Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +import { + CompositeAlgId, + CoreDID, + Credential, + Duration, + FailFast, + IotaDocument, + JwkPqMemStore, + JwsAlgorithm, + JwsSignatureOptions, + JwsVerificationOptions, + Jwt, + JwtCredentialValidationOptions, + JwtCredentialValidator, + JwtPresentationOptions, + JwtPresentationValidationOptions, + JwtPresentationValidator, + KeyIdMemStore, + MethodScope, + PQJwsVerifier, + Presentation, + Resolver, + Storage, + SubjectHolderRelationship, + Timestamp, +} from "@iota/identity-wasm/node"; +import { getFundedClient } from "../util"; + +/** + * This example shows how to create a PQ Verifiable Presentation and validate it + */ +export async function pq() { + // =========================================================================== + // Step 1: Create identities for the issuer and the holder. + // =========================================================================== + + const issuerStorage = new Storage(new JwkPqMemStore(), new KeyIdMemStore()); + const issuerClient = await getFundedClient(issuerStorage); + const issuerDocument = new IotaDocument(issuerClient.network()); + // Create a new method with PQ/T algorithm. + const issuerFragment = await issuerDocument.generateMethodPQC( + issuerStorage, + JwkPqMemStore.mldsaKeyType(), + JwsAlgorithm.MLDSA44, + "#0", + MethodScope.VerificationMethod(), + ); + const issuerIdentity = await issuerClient + .createIdentity(issuerDocument) + .finish() + .buildAndExecute(issuerClient) + .then(res => res.output); + + const aliceStorage = new Storage(new JwkPqMemStore(), new KeyIdMemStore()); + const aliceClient = await getFundedClient(aliceStorage); + const aliceDocument = new IotaDocument(aliceClient.network()); + // Create a new method with PQ/T algorithm. + const aliceFragment = await aliceDocument.generateMethodPQC( + aliceStorage, + JwkPqMemStore.mldsaKeyType(), + JwsAlgorithm.MLDSA44, + "#0", + MethodScope.VerificationMethod(), + ); + const aliceIdentity = await aliceClient + .createIdentity(aliceDocument) + .finish() + .buildAndExecute(aliceClient) + .then(res => res.output); + + // =========================================================================== + // Step 2: Issuer creates and signs a Verifiable Credential. + // =========================================================================== + + const subject = { + id: aliceDocument.id(), + name: "Alice", + degreeName: "Bachelor of Science and Arts", + degreeType: "BachelorDegree", + GPA: "4.0", + }; + + // Create an unsigned `UniversityDegree` credential for Alice + const unsignedVc = new Credential({ + id: "https://example.edu/credentials/3732", + type: "UniversityDegreeCredential", + issuer: issuerDocument.id(), + credentialSubject: subject, + }); + + // Create a Credential JWT with the issuer's PQ verification method. + const credentialJwt = await issuerDocument.createCredentialJwtPqc( + issuerStorage, + issuerFragment, + unsignedVc, + new JwsSignatureOptions(), + ); + + const res = new JwtCredentialValidator(new PQJwsVerifier()).validate( + credentialJwt, + issuerDocument, + new JwtCredentialValidationOptions(), + FailFast.FirstError, + ); + console.log("credentialjwt validation", res.intoCredential()); + + // =========================================================================== + // Step 3: Issuer sends the Verifiable Credential to the holder. + // =========================================================================== + + // The credential is then serialized to JSON and transmitted to the holder in a secure manner. + // Note that the credential is NOT published to the IOTA Tangle. It is sent and stored off-chain. + console.log(`Sending credential (as JWT) to the holder`, unsignedVc.toJSON()); + + // =========================================================================== + // Step 4: Verifier sends the holder a challenge and requests a signed Verifiable Presentation. + // =========================================================================== + + // A unique random challenge generated by the requester per presentation can mitigate replay attacks. + const nonce = "475a7984-1bb5-4c4c-a56f-822bccd46440"; + + // The verifier and holder also agree that the signature should have an expiry date + // 10 minutes from now. + const expires = Timestamp.nowUTC().checkedAdd(Duration.minutes(10)); + + // =========================================================================== + // Step 5: Holder creates a verifiable presentation from the issued credential for the verifier to validate. + // =========================================================================== + + // Create a Verifiable Presentation from the Credential + const unsignedVp = new Presentation({ + holder: aliceDocument.id(), + verifiableCredential: [credentialJwt], + }); + + // Create a PQ JWT verifiable presentation using the holder's verification method + // and include the requested challenge and expiry timestamp. + const presentationJwt = await aliceDocument.createPresentationJwtPqc( + aliceStorage, + aliceFragment, + unsignedVp, + new JwsSignatureOptions({ nonce }), + new JwtPresentationOptions({ expirationDate: expires }), + ); + + // =========================================================================== + // Step 6: Holder sends a verifiable presentation to the verifier. + // =========================================================================== + console.log( + `Sending presentation (as JWT) to the verifier`, + unsignedVp.toJSON(), + ); + + // =========================================================================== + // Step 7: Verifier receives the Verifiable Presentation and verifies it. + // =========================================================================== + + // The verifier wants the following requirements to be satisfied: + // - JWT verification of the presentation (including checking the requested challenge to mitigate replay attacks) + // - JWT verification of the credentials. + // - The presentation holder must always be the subject, regardless of the presence of the nonTransferable property + // - The issuance date must not be in the future. + + const jwtPresentationValidationOptions = new JwtPresentationValidationOptions( + { + presentationVerifierOptions: new JwsVerificationOptions({ nonce }), + }, + ); + + const resolver = new Resolver({ + client: aliceClient, + }); + // Resolve the presentation holder. + const presentationHolderDID: CoreDID = JwtPresentationValidator.extractHolder(presentationJwt); + const resolvedHolder = await resolver.resolve( + presentationHolderDID.toString(), + ); + + // Validate presentation. Note that this doesn't validate the included credentials. + let decodedPresentation = new JwtPresentationValidator(new PQJwsVerifier()).validate( + presentationJwt, + resolvedHolder, + jwtPresentationValidationOptions, + ); + + // Validate the credentials in the presentation. + let credentialValidator = new JwtCredentialValidator(new PQJwsVerifier()); + let validationOptions = new JwtCredentialValidationOptions({ + subjectHolderRelationship: [ + presentationHolderDID.toString(), + SubjectHolderRelationship.AlwaysSubject, + ], + }); + + let jwtCredentials: Jwt[] = decodedPresentation + .presentation() + .verifiableCredential() + .map((credential) => { + const jwt = credential.tryIntoJwt(); + if (!jwt) { + throw new Error("expected a JWT credential"); + } else { + return jwt; + } + }); + + // Concurrently resolve the issuers' documents. + let issuers: string[] = []; + for (let jwtCredential of jwtCredentials) { + let issuer = JwtCredentialValidator.extractIssuerFromJwt(jwtCredential); + issuers.push(issuer.toString()); + } + let resolvedIssuers = await resolver.resolveMultiple(issuers); + + // Validate the credentials in the presentation. + for (let i = 0; i < jwtCredentials.length; i++) { + credentialValidator.validate( + jwtCredentials[i], + resolvedIssuers[i], + validationOptions, + FailFast.FirstError, + ); + } + + // Since no errors were thrown we know that the validation was successful. + console.log(`VP successfully validated`); +} diff --git a/bindings/wasm/identity_wasm/examples/src/main.ts b/bindings/wasm/identity_wasm/examples/src/main.ts index 82ef083d9f..4f236d5eb6 100644 --- a/bindings/wasm/identity_wasm/examples/src/main.ts +++ b/bindings/wasm/identity_wasm/examples/src/main.ts @@ -1,4 +1,4 @@ -// Copyright 2020-2025 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 import { createIdentity } from "./0_basic/0_create_did"; @@ -13,12 +13,15 @@ import { didOwnsDid } from "./1_advanced/0_did_owns_did"; import { sdJwtVc } from "./1_advanced/10_sd_jwt_vc"; import { advancedTransaction } from "./1_advanced/11_advanced_transactions"; import { iotaKeytoolIntegration } from "./1_advanced/12_iota_keytool_integration"; +import { linkedVp } from "./1_advanced/13_linked_verifiable_presentation"; import { customResolution } from "./1_advanced/4_custom_resolution"; import { domainLinkage } from "./1_advanced/5_domain_linkage"; import { sdJwt } from "./1_advanced/6_sd_jwt"; import { statusList2021 } from "./1_advanced/7_status_list_2021"; import { zkp } from "./1_advanced/8_zkp"; import { zkp_revocation } from "./1_advanced/9_zkp_revocation"; +import { hybrid } from "./1_advanced/hybrid"; +import { pq } from "./1_advanced/pq"; export async function main(example?: string) { // Extract example name. @@ -60,10 +63,16 @@ export async function main(example?: string) { return await zkp_revocation(); case "10_sd_jwt_vc": return await sdJwtVc(); + case "pq": + return await pq(); + case "hybrid": + return await hybrid(); case "11_advanced_transactions": return await advancedTransaction(); case "12_iota_keytool_integration": return await iotaKeytoolIntegration(); + case "13_linked_verifiable_presentation": + return await linkedVp(); default: throw "Unknown example name: '" + argument + "'"; } diff --git a/bindings/wasm/identity_wasm/examples/src/util.ts b/bindings/wasm/identity_wasm/examples/src/util.ts index 3cf9dd656a..5bc348cffd 100644 --- a/bindings/wasm/identity_wasm/examples/src/util.ts +++ b/bindings/wasm/identity_wasm/examples/src/util.ts @@ -12,13 +12,17 @@ import { Storage, StorageSigner, Transaction, + TransactionSigner, } from "@iota/identity-wasm/node"; import { CoreClientReadOnly } from "@iota/iota-interaction-ts/node/core_client"; import { IotaClient, TransactionEffects } from "@iota/iota-sdk/client"; import { getFaucetHost, requestIotaFromFaucetV0 } from "@iota/iota-sdk/faucet"; +import { IotaEvent } from "@iota/iota-sdk/src/client/types/generated"; import { Transaction as SdkTransaction } from "@iota/iota-sdk/transactions"; +import { NotarizationClient, NotarizationClientReadOnly } from "@iota/notarization/node"; export const IOTA_IDENTITY_PKG_ID = globalThis?.process?.env?.IOTA_IDENTITY_PKG_ID || ""; +export const IOTA_NOTARIZATION_PKG_ID = globalThis?.process?.env?.IOTA_NOTARIZATION_PKG_ID || ""; export const NETWORK_NAME_FAUCET = globalThis?.process?.env?.NETWORK_NAME_FAUCET || "localnet"; export const NETWORK_URL = globalThis?.process?.env?.NETWORK_URL || "http://127.0.0.1:9000"; @@ -90,6 +94,20 @@ export async function getFundedClient(storage: Storage): Promise return identityClient; } +export async function getNotarizationClient(signer: TransactionSigner): Promise { + if (!IOTA_NOTARIZATION_PKG_ID) { + throw new Error(`IOTA_NOTARIZATION_PKG_ID env variable must be provided to run the notarization examples`); + } + + const iotaClient = new IotaClient({ url: NETWORK_URL }); + const notarizationClientReadOnly = await NotarizationClientReadOnly.createWithPkgId( + iotaClient, + IOTA_NOTARIZATION_PKG_ID, + ); + + return await NotarizationClient.create(notarizationClientReadOnly, signer); +} + export class SendZeroCoinTx implements Transaction { recipient: string; @@ -97,7 +115,7 @@ export class SendZeroCoinTx implements Transaction { this.recipient = recipient; } - async buildProgrammableTransaction(client: CoreClientReadOnly): Promise { + async buildProgrammableTransaction(_client: CoreClientReadOnly): Promise { const ptb = new SdkTransaction(); const recipientAddress = ptb.pure.address(this.recipient); @@ -110,7 +128,15 @@ export class SendZeroCoinTx implements Transaction { return tx_bytes.slice(1); } - async apply(effects: TransactionEffects, client: CoreClientReadOnly): Promise { + async apply(effects: TransactionEffects, _client: CoreClientReadOnly): Promise { return effects.created![0].reference.objectId; } + + async applyWithEvents( + effects: TransactionEffects, + _events: IotaEvent[], + client: CoreClientReadOnly, + ): Promise { + return await this.apply(effects, client); + } } diff --git a/bindings/wasm/identity_wasm/lib/index.ts b/bindings/wasm/identity_wasm/lib/index.ts index b9d8f68cbd..b5b7e7b272 100644 --- a/bindings/wasm/identity_wasm/lib/index.ts +++ b/bindings/wasm/identity_wasm/lib/index.ts @@ -16,3 +16,6 @@ export * from "@iota/iota-interaction-ts/transaction_internal"; // keep this export last to override the original `Resolver` from `identity_wasm` in the exports export { Resolver } from "./resolver"; + +export * from "./jwk_storage_pq.js"; +export * from "./pq_verifier.js"; diff --git a/bindings/wasm/identity_wasm/lib/jose/composite_jwk.ts b/bindings/wasm/identity_wasm/lib/jose/composite_jwk.ts new file mode 100644 index 0000000000..89619eb52f --- /dev/null +++ b/bindings/wasm/identity_wasm/lib/jose/composite_jwk.ts @@ -0,0 +1,14 @@ +// Copyright 2024 Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +export const enum CompositeAlgId { + IdMldsa44Ed25519 = "id-MLDSA44-Ed25519", + + IdMldsa65Ed25519 = "id-MLDSA65-Ed25519", +} + +export const enum CompositeAlgIdDomain { + IdMldsa44Ed25519 = "060B6086480186FA6B5008013E", + + IdMldsa65Ed25519 = "060B6086480186FA6B50080147", +} diff --git a/bindings/wasm/identity_wasm/lib/jose/index.ts b/bindings/wasm/identity_wasm/lib/jose/index.ts index f033c4f110..65d827b07a 100644 --- a/bindings/wasm/identity_wasm/lib/jose/index.ts +++ b/bindings/wasm/identity_wasm/lib/jose/index.ts @@ -1,3 +1,4 @@ +export * from "./composite_jwk"; export * from "./ec_curve"; export * from "./ed_curve"; export * from "./jwk_operation"; diff --git a/bindings/wasm/identity_wasm/lib/jose/jwk_type.ts b/bindings/wasm/identity_wasm/lib/jose/jwk_type.ts index 1707c3295f..820308bd3b 100644 --- a/bindings/wasm/identity_wasm/lib/jose/jwk_type.ts +++ b/bindings/wasm/identity_wasm/lib/jose/jwk_type.ts @@ -10,4 +10,6 @@ export const enum JwkType { Oct = "oct", /** Octet string key pairs. */ Okp = "OKP", + /** Algorithm key pair. */ + Akp = "AKP", } diff --git a/bindings/wasm/identity_wasm/lib/jose/jws_algorithm.ts b/bindings/wasm/identity_wasm/lib/jose/jws_algorithm.ts index 54cd306a27..d18b7f6d46 100644 --- a/bindings/wasm/identity_wasm/lib/jose/jws_algorithm.ts +++ b/bindings/wasm/identity_wasm/lib/jose/jws_algorithm.ts @@ -32,4 +32,14 @@ export const enum JwsAlgorithm { NONE = "none", /** EdDSA signature algorithms */ EdDSA = "EdDSA", + /** ML-DSA-44 */ + MLDSA44 = "ML-DSA-44", + /** ML-DSA-65 */ + MLDSA65 = "ML-DSA-65", + /** ML-DSA-87 */ + MLDSA87 = "ML-DSA-87", + /** ML-DSA-44 in hybrid signature*/ + IdMldsa44Ed25519 = "id-MLDSA44-Ed25519", + /** ML-DSA-65 in hybrid signature*/ + IdMldsa65Ed25519 = "id-MLDSA65-Ed25519", } diff --git a/bindings/wasm/identity_wasm/lib/jwk_storage_pq.ts b/bindings/wasm/identity_wasm/lib/jwk_storage_pq.ts new file mode 100644 index 0000000000..76bf46f797 --- /dev/null +++ b/bindings/wasm/identity_wasm/lib/jwk_storage_pq.ts @@ -0,0 +1,269 @@ +// Copyright 2024 Fondazione Links +// SPDX-License-Identifier: Apache-2.0 +import * as ed from "@noble/ed25519"; +import { ml_dsa44, ml_dsa65, ml_dsa87 } from "@noble/post-quantum/ml-dsa"; +import { decodeB64, encodeB64, Jwk, JwkGenOutput, JwkStorage, JwkStoragePQ } from "~identity_wasm"; +import { EdCurve, JwkType, JwsAlgorithm } from "./jose"; + +type Ed25519PrivateKey = Uint8Array; +type Ed25519PublicKey = Uint8Array; + +// JkwStorage for PQ and PQ/T examples +export class JwkPqMemStore implements JwkStorage, JwkStoragePQ { + /** The map from key identifiers to Jwks. */ + private _keys: Map; + + /** Creates a new, empty `MemStore` instance. */ + constructor() { + this._keys = new Map(); + } + + public static mldsaKeyType(): string { + return "AKP"; + } + + public static ed25519KeyType(): string { + return "Ed25519"; + } + + private _get_key(keyId: string): Jwk | undefined { + return this._keys.get(keyId); + } + + public async generate(keyType: string, algorithm: JwsAlgorithm): Promise { + if (keyType !== JwkPqMemStore.ed25519KeyType()) { + throw new Error(`unsupported key type ${keyType}`); + } + + if (algorithm !== JwsAlgorithm.EdDSA) { + throw new Error(`unsupported algorithm`); + } + + const keyId = randomKeyId(); + const privKey: Ed25519PrivateKey = ed.utils.randomPrivateKey(); + + const publicKey: Ed25519PublicKey = await ed.getPublicKey(privKey); + const jwk = await encodeJwk(privKey, publicKey, algorithm); + + this._keys.set(keyId, jwk); + + const publicJWK = jwk?.toPublic(); + if (!publicJWK) { + throw new Error(`JWK is not a public key`); + } + + return new JwkGenOutput(keyId, publicJWK); + } + + public async generatePQKey(keyType: String, algorithm: JwsAlgorithm): Promise { + if (keyType !== JwkPqMemStore.mldsaKeyType()) { + throw new Error(`unsupported key type ${keyType}`); + } + + const seed = new TextEncoder().encode(randomKeyId()); + let keys; + if (algorithm === JwsAlgorithm.MLDSA44) { + keys = ml_dsa44.keygen(seed); + } else if (algorithm === JwsAlgorithm.MLDSA65) { + keys = ml_dsa65.keygen(seed); + } else if (algorithm === JwsAlgorithm.MLDSA87) { + keys = ml_dsa87.keygen(seed); + } else { + throw new Error(`unsupported algorithm`); + } + + const keyId = randomKeyId(); + + const jwk = await encodeJwk(keys.secretKey, keys.publicKey, algorithm); + + if (jwk == undefined) { + throw new Error("Unexpected error: await encodeJwk(privKey, publicKey, algorithm)"); + } + + this._keys.set(keyId, jwk); + + const publicJWK = jwk?.toPublic(); + if (!publicJWK) { + throw new Error(`JWK is not a public key`); + } + + return new JwkGenOutput(keyId, publicJWK); + } + + public async sign(keyId: string, data: Uint8Array, publicKey: Jwk): Promise { + let alg = publicKey.alg(); + let signature = null; + + if (alg === undefined) { + throw new Error("expected a Jwk with an `alg` parameter"); + } + + if (alg !== JwsAlgorithm.EdDSA) { + throw new Error("unsupported JWS algorithm"); + } else { + if (publicKey.paramsOkp()?.crv !== (EdCurve.Ed25519 as string)) { + throw new Error("unsupported Okp parameter"); + } + } + + const jwk = this._keys.get(keyId); + + if (jwk) { + const [privateKey, _] = decodeJwk(jwk); + signature = await ed.sign(data, privateKey); + } else { + throw new Error(`key with id ${keyId} not found`); + } + return signature; + } + + public async signPQ( + keyId: string, + data: Uint8Array, + publicKey: Jwk, + ctx: Uint8Array | undefined, + ): Promise { + let alg = publicKey.alg(); + let signature = null; + + if (alg === undefined) { + throw new Error("expected a Jwk with an `alg` parameter"); + } + + if (alg !== JwsAlgorithm.MLDSA44 && alg !== JwsAlgorithm.MLDSA65 && alg !== JwsAlgorithm.MLDSA87) { + throw new Error("unsupported JWS algorithm"); + } + + const jwk = this._keys.get(keyId); + + if (jwk) { + const [privateKey, _] = decodeJwk(jwk); + + if (alg == JwsAlgorithm.MLDSA44) { + signature = ml_dsa44.sign(privateKey, data, ctx); + } else if (alg == JwsAlgorithm.MLDSA65) { + signature = ml_dsa65.sign(privateKey, data, ctx); + } else if (alg == JwsAlgorithm.MLDSA87) { + signature = ml_dsa87.sign(privateKey, data, ctx); + } else { + throw new Error("unsupported algorithm"); + } + } else { + throw new Error(`key with id ${keyId} not found`); + } + return signature; + } + + public async insert(jwk: Jwk): Promise { + const keyId = randomKeyId(); + + if (!jwk.isPrivate) { + throw new Error("expected a JWK with all private key components set"); + } + + if (!jwk.alg()) { + throw new Error("expected a Jwk with an `alg` parameter"); + } + + this._keys.set(keyId, jwk); + + return keyId; + } + + public async delete(keyId: string): Promise { + this._keys.delete(keyId); + } + + public async exists(keyId: string): Promise { + return this._keys.has(keyId); + } + + public count(): number { + return this._keys.size; + } +} + +// Encodes a Ed25519 keypair into a Jwk. +async function encodeJwk(privateKey: Uint8Array, publicKey: Uint8Array, alg: JwsAlgorithm): Promise { + let pub = encodeB64(publicKey); + let priv = encodeB64(privateKey); + + if (alg === JwsAlgorithm.EdDSA) { + return new Jwk({ + "kty": JwkType.Okp, + crv: "Ed25519", + d: priv, + x: pub, + alg, + }); + } else { + return new Jwk({ + "kty": JwkType.Akp, + pub: pub, + priv: priv, + alg, + }); + } +} + +function decodeJwk(jwk: Jwk): [Uint8Array, Uint8Array] { + if ( + jwk.alg()! !== JwsAlgorithm.MLDSA44 + && jwk.alg()! !== JwsAlgorithm.MLDSA65 + && jwk.alg()! !== JwsAlgorithm.MLDSA87 + && jwk.alg()! !== JwsAlgorithm.EdDSA + ) { + throw new Error("unsupported `alg`"); + } + if (jwk.alg()! === JwsAlgorithm.EdDSA) { + const paramsOkp = jwk.paramsOkp(); + if (paramsOkp) { + const d = paramsOkp.d; + + if (d) { + const textEncoder = new TextEncoder(); + const privateKey = decodeB64(textEncoder.encode(d)); + const publicKey = decodeB64(textEncoder.encode(paramsOkp.x)); + return [privateKey, publicKey]; + } else { + throw new Error("missing private key component"); + } + } else { + throw new Error("expected Okp params"); + } + } else { + const paramsPQ = jwk.paramsAkp(); + + if (paramsPQ) { + const priv = paramsPQ.priv; + + if (priv) { + let textEncoder = new TextEncoder(); + const privateKey = decodeB64(textEncoder.encode(priv)); + const publicKey = decodeB64(textEncoder.encode(paramsPQ.pub)); + return [privateKey, publicKey]; + } else { + throw new Error("missing private key component"); + } + } else { + throw new Error("expected Okp params"); + } + } +} + +// Returns a random number between `min` and `max` (inclusive). +// SAFETY NOTE: This is not cryptographically secure randomness and thus not suitable for production use. +// It suffices for our testing implementation however and avoids an external dependency. +function getRandomNumber(min: number, max: number): number { + return Math.floor(Math.random() * (max - min + 1)) + min; +} + +// Returns a random key id. +function randomKeyId(): string { + const randomness = new Uint8Array(20); + for (let index = 0; index < randomness.length; index++) { + randomness[index] = getRandomNumber(0, 255); + } + + return encodeB64(randomness); +} diff --git a/bindings/wasm/identity_wasm/lib/pq_verifier.ts b/bindings/wasm/identity_wasm/lib/pq_verifier.ts new file mode 100644 index 0000000000..7df5012d48 --- /dev/null +++ b/bindings/wasm/identity_wasm/lib/pq_verifier.ts @@ -0,0 +1,61 @@ +// Copyright 2024 Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +import { ml_dsa44, ml_dsa65, ml_dsa87 } from "@noble/post-quantum/ml-dsa"; +import { decodeB64, IJwsVerifier, Jwk } from "~identity_wasm"; +import { CompositeAlgIdDomain, JwsAlgorithm } from "./jose"; + +export class PQJwsVerifier implements IJwsVerifier { + public verify(alg: JwsAlgorithm, signingInput: Uint8Array, decodedSignature: Uint8Array, publicKey: Jwk): void { + let res = false; + let ctx = undefined; + + if ( + alg !== JwsAlgorithm.MLDSA44 + && alg !== JwsAlgorithm.MLDSA65 + && alg !== JwsAlgorithm.MLDSA87 + && alg !== JwsAlgorithm.IdMldsa44Ed25519 + && alg !== JwsAlgorithm.IdMldsa65Ed25519 + ) { + throw new Error("unsupported JWS algorithm"); + } + + const pubKey = decodeJwk(publicKey); + + // Domain separator for hybrid signatures + if (alg === JwsAlgorithm.IdMldsa44Ed25519) { + ctx = Uint8Array.from(Buffer.from(CompositeAlgIdDomain.IdMldsa44Ed25519, "hex")); + } else if (alg === JwsAlgorithm.IdMldsa65Ed25519) { + ctx = Uint8Array.from(Buffer.from(CompositeAlgIdDomain.IdMldsa65Ed25519, "hex")); + } + + if (alg === JwsAlgorithm.MLDSA44 || alg === JwsAlgorithm.IdMldsa44Ed25519) { + res = ml_dsa44.verify(pubKey, signingInput, decodedSignature, ctx); + } else if (alg === JwsAlgorithm.MLDSA65 || alg === JwsAlgorithm.IdMldsa65Ed25519) { + res = ml_dsa65.verify(pubKey, signingInput, decodedSignature, ctx); + } else if (alg === JwsAlgorithm.MLDSA87) { + res = ml_dsa87.verify(pubKey, signingInput, decodedSignature); + } + if (!res) { + throw new Error("signature verification failed"); + } + } +} + +function decodeJwk(jwk: Jwk): Uint8Array { + if ( + jwk.alg()! !== JwsAlgorithm.MLDSA44 && jwk.alg()! !== JwsAlgorithm.MLDSA65 + && jwk.alg()! !== JwsAlgorithm.MLDSA87 + ) { + throw new Error("unsupported `alg`"); + } + + const paramsPQ = jwk.paramsAkp(); + + if (paramsPQ) { + let textEncoder = new TextEncoder(); + return decodeB64(textEncoder.encode(paramsPQ.pub)); + } else { + throw new Error("expected Okp params"); + } +} diff --git a/bindings/wasm/identity_wasm/package-lock.json b/bindings/wasm/identity_wasm/package-lock.json index 559ccb0827..8c5ddb73d5 100644 --- a/bindings/wasm/identity_wasm/package-lock.json +++ b/bindings/wasm/identity_wasm/package-lock.json @@ -1,17 +1,19 @@ { "name": "@iota/identity-wasm", - "version": "1.6.0-beta.7", + "version": "1.6.0-beta.10", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "@iota/identity-wasm", - "version": "1.6.0-beta.7", + "version": "1.6.0-beta.10", "license": "Apache-2.0", "dependencies": { "@iota/iota-interaction-ts": "^0.8.0", + "@iota/notarization": "^0.1.6", "@noble/ed25519": "^1.7.3", "@noble/hashes": "^1.4.0", + "@noble/post-quantum": "^0.2", "@types/node-fetch": "^2.6.2", "base64-arraybuffer": "^1.0.2", "jose": "^5.9.6", @@ -43,7 +45,7 @@ "node": ">=20" }, "peerDependencies": { - "@iota/iota-sdk": "^1.2.0" + "@iota/iota-sdk": "^1.6.1" } }, "node_modules/@0no-co/graphql.web": { @@ -241,9 +243,9 @@ } }, "node_modules/@iota/bcs": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/@iota/bcs/-/bcs-1.0.0.tgz", - "integrity": "sha512-oxXgpzlL0d2jbzZH/9XmLcM+jmPbYT1hbbPfkvzMZvGChIDw1zLvp1EFsJtb2hAcLHORIAHIV0xEhzhBpIlSqA==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@iota/bcs/-/bcs-1.2.0.tgz", + "integrity": "sha512-QdRSR0KpJ87tdjVNmM/j0+0DvE0aTxHIa02337iluaOsMqtJ8OdgUCfSyLduC/3qS+8tJE+UB1KOw55tF+sN2w==", "license": "Apache-2.0", "peer": true, "dependencies": { @@ -263,20 +265,21 @@ } }, "node_modules/@iota/iota-sdk": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/@iota/iota-sdk/-/iota-sdk-1.2.0.tgz", - "integrity": "sha512-SzC3NFYuq2P3dNh79X679p9Frb1XylU8O3nfeOQL4NcEnf/44k5HY0ABeNuWHFoYoeuI0Uk+qSIEcIVSaaMoag==", + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/@iota/iota-sdk/-/iota-sdk-1.6.1.tgz", + "integrity": "sha512-V7rx7m9erCn9lr4hNZVMtwmka2NsoTZ9EFSE4ZqEDO44cWdheM61+i/y5HJhvvmYAb/kkDfSmfdmzLaGTbVVYg==", "license": "Apache-2.0", "peer": true, "dependencies": { "@graphql-typed-document-node/core": "^3.2.0", - "@iota/bcs": "1.0.0", + "@iota/bcs": "1.2.0", "@noble/curves": "^1.4.2", "@noble/hashes": "^1.4.0", "@scure/bip32": "^1.4.0", "@scure/bip39": "^1.3.0", "@suchipi/femver": "^1.0.0", "bech32": "^2.0.0", + "bignumber.js": "^9.1.1", "gql.tada": "^1.8.2", "graphql": "^16.9.0", "tweetnacl": "^1.0.3", @@ -293,6 +296,21 @@ "license": "Unlicense", "peer": true }, + "node_modules/@iota/notarization": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/@iota/notarization/-/notarization-0.1.6.tgz", + "integrity": "sha512-EoQIrACsOckXhUZ5y1AJdOO1mPv0lkoqeX5yROH3mjDbSpzqRF0kszAN/hBwOQcopSQPiEvrH6+5E+bD5WSntw==", + "license": "Apache-2.0", + "dependencies": { + "@iota/iota-interaction-ts": "^0.8.0" + }, + "engines": { + "node": ">=20" + }, + "peerDependencies": { + "@iota/iota-sdk": "^1.6.1" + } + }, "node_modules/@isaacs/cliui": { "version": "8.0.2", "dev": true, @@ -494,6 +512,30 @@ "url": "https://paulmillr.com/funding/" } }, + "node_modules/@noble/post-quantum": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/@noble/post-quantum/-/post-quantum-0.2.1.tgz", + "integrity": "sha512-ImgfMp9notXSEocz464o1AefYfFWEkkszKMGO+ZiTn73yIBFeNyEHKQUMS+SheJwSNymldSts6YyVcQDjcnVVg==", + "license": "MIT", + "dependencies": { + "@noble/hashes": "1.6.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@noble/post-quantum/node_modules/@noble/hashes": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.6.0.tgz", + "integrity": "sha512-YUULf0Uk4/mAA89w+k3+yUYh6NrEvxZa5T6SY3wlMvE2chHkxFUUIDI8/XW1QSC357iA5pSnqt7XEhvFOqmDyQ==", + "license": "MIT", + "engines": { + "node": "^14.21.3 || >=16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, "node_modules/@nodelib/fs.scandir": { "version": "2.1.5", "dev": true, @@ -1315,6 +1357,16 @@ "node": "*" } }, + "node_modules/bignumber.js": { + "version": "9.3.1", + "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.1.tgz", + "integrity": "sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==", + "license": "MIT", + "peer": true, + "engines": { + "node": "*" + } + }, "node_modules/binary-extensions": { "version": "2.2.0", "dev": true, diff --git a/bindings/wasm/identity_wasm/package.json b/bindings/wasm/identity_wasm/package.json index 60204c18ba..58a8251c38 100644 --- a/bindings/wasm/identity_wasm/package.json +++ b/bindings/wasm/identity_wasm/package.json @@ -1,6 +1,6 @@ { "name": "@iota/identity-wasm", - "version": "1.6.0-beta.7", + "version": "1.6.0-beta.10", "author": "IOTA Foundation ", "description": "WASM bindings for IOTA Identity - A Self Sovereign Identity Framework implementing the DID and VC standards from W3C. To be used in JavaScript/TypeScript", "homepage": "https://www.iota.org", @@ -75,15 +75,17 @@ }, "dependencies": { "@iota/iota-interaction-ts": "^0.8.0", + "@iota/notarization": "^0.1.6", "@noble/ed25519": "^1.7.3", "@noble/hashes": "^1.4.0", + "@noble/post-quantum": "^0.2", "@types/node-fetch": "^2.6.2", "base64-arraybuffer": "^1.0.2", "jose": "^5.9.6", "node-fetch": "^2.6.7" }, "peerDependencies": { - "@iota/iota-sdk": "^1.2.0" + "@iota/iota-sdk": "^1.6.1" }, "engines": { "node": ">=20" diff --git a/bindings/wasm/identity_wasm/src/credential/jwt_credential_validation/jwt_credential_validator_hybrid.rs b/bindings/wasm/identity_wasm/src/credential/jwt_credential_validation/jwt_credential_validator_hybrid.rs new file mode 100644 index 0000000000..a6e073ee7d --- /dev/null +++ b/bindings/wasm/identity_wasm/src/credential/jwt_credential_validation/jwt_credential_validator_hybrid.rs @@ -0,0 +1,217 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use identity_iota::core::Object; +use identity_iota::core::Url; +use identity_iota::credential::JwtCredentialValidatorHybrid; +use identity_iota::credential::JwtCredentialValidatorUtils; +use identity_iota::credential::StatusCheck; +use identity_iota::did::CoreDID; + +use super::options::WasmJwtCredentialValidationOptions; +use crate::common::ImportedDocumentLock; +use crate::common::ImportedDocumentReadGuard; +use crate::common::WasmTimestamp; +use crate::credential::options::WasmStatusCheck; +use crate::credential::revocation::status_list_2021::WasmStatusList2021Credential; +use crate::credential::WasmCredential; +use crate::credential::WasmDecodedJwtCredential; +use crate::credential::WasmFailFast; +use crate::credential::WasmJwt; +use crate::credential::WasmSubjectHolderRelationship; +use crate::did::ArrayIToCoreDocument; +use crate::did::IToCoreDocument; +use crate::did::WasmCoreDID; +use crate::did::WasmJwsVerificationOptions; +use crate::error::Result; +use crate::error::WasmResult; +use crate::verification::IJwsVerifier; +use crate::verification::WasmJwsVerifier; + +use wasm_bindgen::prelude::*; + +/// A type for decoding and validating PQ/T {@link Credential}. +#[wasm_bindgen(js_name = JwtCredentialValidatorHybrid)] +pub struct WasmJwtCredentialValidatorHybrid(JwtCredentialValidatorHybrid); + +#[wasm_bindgen(js_class = JwtCredentialValidatorHybrid)] +impl WasmJwtCredentialValidatorHybrid { + /// Creates a new {@link JwtCredentialValidatorHybrid}. + #[wasm_bindgen(constructor)] + #[allow(non_snake_case)] + pub fn new( + traditionalSignatureVerifier: Option, + pqSignatureVerifier: Option, + ) -> WasmJwtCredentialValidatorHybrid { + let traditional_signature_verifier = WasmJwsVerifier::new(traditionalSignatureVerifier); + let pq_signature_verifier = WasmJwsVerifier::new(pqSignatureVerifier); + WasmJwtCredentialValidatorHybrid(JwtCredentialValidatorHybrid::with_signature_verifiers( + traditional_signature_verifier, + pq_signature_verifier, + )) + } + + /// Decodes and validates a {@link Credential} issued as a JWS. A {@link DecodedJwtCredential} is returned upon + /// success. + /// + /// The following properties are validated according to `options`: + /// - the issuer's signature on the JWS, + /// - the expiration date, + /// - the issuance date, + /// - the semantic structure. + /// + /// # Warning + /// The lack of an error returned from this method is in of itself not enough to conclude that the credential can be + /// trusted. This section contains more information on additional checks that should be carried out before and after + /// calling this method. + /// + /// ## The state of the issuer's DID Document + /// The caller must ensure that `issuer` represents an up-to-date DID Document. + /// + /// ## Properties that are not validated + /// There are many properties defined in [The Verifiable Credentials Data Model](https://www.w3.org/TR/vc-data-model/) that are **not** validated, such as: + /// `proof`, `credentialStatus`, `type`, `credentialSchema`, `refreshService` **and more**. + /// These should be manually checked after validation, according to your requirements. + /// + /// # Errors + /// An error is returned whenever a validated condition is not satisfied. + #[wasm_bindgen] + pub fn validate( + &self, + credential_jwt: &WasmJwt, + issuer: &IToCoreDocument, + options: &WasmJwtCredentialValidationOptions, + fail_fast: WasmFailFast, + ) -> Result { + let issuer_lock = ImportedDocumentLock::from(issuer); + let issuer_guard = issuer_lock.try_read()?; + + self + .0 + .validate(&credential_jwt.0, &issuer_guard, &options.0, fail_fast.into()) + .wasm_result() + .map(WasmDecodedJwtCredential) + } + + /// Decode and verify the JWS signature of a {@link Credential} issued as a JWT using the DID Document of a trusted + /// issuer. + /// + /// A {@link DecodedJwtCredential} is returned upon success. + /// + /// # Warning + /// The caller must ensure that the DID Documents of the trusted issuers are up-to-date. + /// + /// ## Proofs + /// Only the JWS signature is verified. If the {@link Credential} contains a `proof` property this will not be + /// verified by this method. + /// + /// # Errors + /// This method immediately returns an error if + /// the credential issuer' url cannot be parsed to a DID belonging to one of the trusted issuers. Otherwise an attempt + /// to verify the credential's signature will be made and an error is returned upon failure. + #[wasm_bindgen(js_name = verifySignature)] + #[allow(non_snake_case)] + pub fn verify_signature( + &self, + credential: &WasmJwt, + trustedIssuers: &ArrayIToCoreDocument, + options: &WasmJwsVerificationOptions, + ) -> Result { + let issuer_locks: Vec = trustedIssuers.into(); + let trusted_issuers: Vec> = issuer_locks + .iter() + .map(ImportedDocumentLock::try_read) + .collect::>>>( + )?; + + self + .0 + .verify_signature(&credential.0, &trusted_issuers, &options.0) + .wasm_result() + .map(WasmDecodedJwtCredential) + } + + /// Validate that the credential expires on or after the specified timestamp. + #[wasm_bindgen(js_name = checkExpiresOnOrAfter)] + pub fn check_expires_on_or_after(credential: &WasmCredential, timestamp: &WasmTimestamp) -> Result<()> { + JwtCredentialValidatorUtils::check_expires_on_or_after(&credential.0, timestamp.0).wasm_result() + } + + /// Validate that the credential is issued on or before the specified timestamp. + #[wasm_bindgen(js_name = checkIssuedOnOrBefore)] + pub fn check_issued_on_or_before(credential: &WasmCredential, timestamp: &WasmTimestamp) -> Result<()> { + JwtCredentialValidatorUtils::check_issued_on_or_before(&credential.0, timestamp.0).wasm_result() + } + + /// Validate that the relationship between the `holder` and the credential subjects is in accordance with + /// `relationship`. The `holder` parameter is expected to be the URL of the holder. + #[wasm_bindgen(js_name = checkSubjectHolderRelationship)] + pub fn check_subject_holder_relationship( + credential: &WasmCredential, + holder: &str, + relationship: WasmSubjectHolderRelationship, + ) -> Result<()> { + let holder: Url = Url::parse(holder).wasm_result()?; + JwtCredentialValidatorUtils::check_subject_holder_relationship(&credential.0, &holder, relationship.into()) + .wasm_result() + } + + /// Checks whether the credential status has been revoked. + /// + /// Only supports `RevocationBitmap2022`. + #[wasm_bindgen(js_name = checkStatus)] + #[allow(non_snake_case)] + pub fn check_status( + credential: &WasmCredential, + trustedIssuers: &ArrayIToCoreDocument, + statusCheck: WasmStatusCheck, + ) -> Result<()> { + let issuer_locks: Vec = trustedIssuers.into(); + let trusted_issuers: Vec> = issuer_locks + .iter() + .map(ImportedDocumentLock::try_read) + .collect::>>>( + )?; + let status_check: StatusCheck = statusCheck.into(); + JwtCredentialValidatorUtils::check_status(&credential.0, &trusted_issuers, status_check).wasm_result() + } + + /// Checks wheter the credential status has been revoked using `StatusList2021`. + #[wasm_bindgen(js_name = checkStatusWithStatusList2021)] + pub fn check_status_with_status_list_2021( + credential: &WasmCredential, + status_list: &WasmStatusList2021Credential, + status_check: WasmStatusCheck, + ) -> Result<()> { + JwtCredentialValidatorUtils::check_status_with_status_list_2021( + &credential.0, + &status_list.inner, + status_check.into(), + ) + .wasm_result() + } + + /// Utility for extracting the issuer field of a {@link Credential} as a DID. + /// + /// ### Errors + /// + /// Fails if the issuer field is not a valid DID. + #[wasm_bindgen(js_name = extractIssuer)] + pub fn extract_issuer(credential: &WasmCredential) -> Result { + JwtCredentialValidatorUtils::extract_issuer::(&credential.0) + .map(WasmCoreDID::from) + .wasm_result() + } + + /// Utility for extracting the issuer field of a credential in JWT representation as DID. + /// + /// # Errors + /// + /// If the JWT decoding fails or the issuer field is not a valid DID. + #[wasm_bindgen(js_name = extractIssuerFromJwt)] + pub fn extract_issuer_from_jwt(credential: &WasmJwt) -> Result { + JwtCredentialValidatorUtils::extract_issuer_from_jwt::(&credential.0) + .map(WasmCoreDID::from) + .wasm_result() + } +} diff --git a/bindings/wasm/identity_wasm/src/credential/jwt_credential_validation/mod.rs b/bindings/wasm/identity_wasm/src/credential/jwt_credential_validation/mod.rs index 826d0388d9..959f3fe0de 100644 --- a/bindings/wasm/identity_wasm/src/credential/jwt_credential_validation/mod.rs +++ b/bindings/wasm/identity_wasm/src/credential/jwt_credential_validation/mod.rs @@ -1,8 +1,9 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 mod decoded_jwt_credential; mod jwt_credential_validator; +mod jwt_credential_validator_hybrid; mod kb_validation_options; mod options; mod sd_jwt_validator; @@ -10,6 +11,7 @@ mod unknown_credential; pub use self::decoded_jwt_credential::*; pub use self::jwt_credential_validator::*; +pub use self::jwt_credential_validator_hybrid::*; pub use self::kb_validation_options::*; pub use self::options::*; pub use self::sd_jwt_validator::*; diff --git a/bindings/wasm/identity_wasm/src/credential/jwt_presentation_validation/jwt_presentation_validator_hybrid.rs b/bindings/wasm/identity_wasm/src/credential/jwt_presentation_validation/jwt_presentation_validator_hybrid.rs new file mode 100644 index 0000000000..22e69092f9 --- /dev/null +++ b/bindings/wasm/identity_wasm/src/credential/jwt_presentation_validation/jwt_presentation_validator_hybrid.rs @@ -0,0 +1,101 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use super::decoded_jwt_presentation::WasmDecodedJwtPresentation; +use super::options::WasmJwtPresentationValidationOptions; +use crate::common::ImportedDocumentLock; +use crate::credential::WasmJwt; +use crate::credential::WasmPresentation; +use crate::did::IToCoreDocument; +use crate::did::WasmCoreDID; +use crate::error::Result; +use crate::error::WasmResult; +use crate::verification::IJwsVerifier; +use crate::verification::WasmJwsVerifier; +use identity_iota::credential::JwtPresentationValidatorHybrid; +use identity_iota::credential::JwtPresentationValidatorUtils; +use identity_iota::did::CoreDID; +use wasm_bindgen::prelude::*; + +#[wasm_bindgen(js_name = JwtPresentationValidatorHybrid, inspectable)] +pub struct WasmJwtPresentationValidatorHybrid(JwtPresentationValidatorHybrid); + +#[wasm_bindgen(js_class = JwtPresentationValidatorHybrid)] +impl WasmJwtPresentationValidatorHybrid { + /// Creates a new {@link JwtPresentationValidatorHybrid}. If a `signatureVerifier` is provided it will be used when + /// verifying decoded JWS signatures, otherwise a default verifier capable of handling the `EdDSA`, `ES256`, `ES256K` + /// algorithms will be used. + #[wasm_bindgen(constructor)] + #[allow(non_snake_case)] + pub fn new( + traditionalSignatureVerifier: Option, + pqSignatureVerifier: Option, + ) -> WasmJwtPresentationValidatorHybrid { + let traditional_signature_verifier = WasmJwsVerifier::new(traditionalSignatureVerifier); + let pq_signature_verifier = WasmJwsVerifier::new(pqSignatureVerifier); + WasmJwtPresentationValidatorHybrid(JwtPresentationValidatorHybrid::with_signature_verifiers( + traditional_signature_verifier, + pq_signature_verifier, + )) + } + + /// Validates a {@link Presentation} encoded as a {@link Jwt}. + /// + /// The following properties are validated according to `options`: + /// - the JWT can be decoded into a semantically valid presentation. + /// - the expiration and issuance date contained in the JWT claims. + /// - the holder's signature. + /// + /// Validation is done with respect to the properties set in `options`. + /// + /// # Warning + /// + /// * This method does NOT validate the constituent credentials and therefore also not the relationship between the + /// credentials' subjects and the presentation holder. This can be done with {@link JwtCredentialValidationOptions}. + /// * The lack of an error returned from this method is in of itself not enough to conclude that the presentation can + /// be trusted. This section contains more information on additional checks that should be carried out before and + /// after calling this method. + /// + /// ## The state of the supplied DID Documents. + /// + /// The caller must ensure that the DID Documents in `holder` are up-to-date. + /// + /// # Errors + /// + /// An error is returned whenever a validated condition is not satisfied or when decoding fails. + #[wasm_bindgen] + #[allow(non_snake_case)] + pub fn validate( + &self, + presentationJwt: &WasmJwt, + holder: &IToCoreDocument, + validation_options: &WasmJwtPresentationValidationOptions, + ) -> Result { + let holder_lock = ImportedDocumentLock::from(holder); + let holder_guard = holder_lock.try_read()?; + + self + .0 + .validate(&presentationJwt.0, &holder_guard, &validation_options.0) + .map(WasmDecodedJwtPresentation::from) + .wasm_result() + } + + /// Validates the semantic structure of the {@link Presentation}. + #[wasm_bindgen(js_name = checkStructure)] + pub fn check_structure(presentation: &WasmPresentation) -> Result<()> { + JwtPresentationValidatorUtils::check_structure(&presentation.0).wasm_result()?; + Ok(()) + } + + /// Attempt to extract the holder of the presentation. + /// + /// # Errors: + /// * If deserialization/decoding of the presentation fails. + /// * If the holder can't be parsed as DIDs. + #[wasm_bindgen(js_name = extractHolder)] + pub fn extract_holder(presentation: &WasmJwt) -> Result { + let holder = JwtPresentationValidatorUtils::extract_holder::(&presentation.0).wasm_result()?; + Ok(WasmCoreDID(holder)) + } +} diff --git a/bindings/wasm/identity_wasm/src/credential/jwt_presentation_validation/mod.rs b/bindings/wasm/identity_wasm/src/credential/jwt_presentation_validation/mod.rs index 12c556852e..be4689df0f 100644 --- a/bindings/wasm/identity_wasm/src/credential/jwt_presentation_validation/mod.rs +++ b/bindings/wasm/identity_wasm/src/credential/jwt_presentation_validation/mod.rs @@ -1,10 +1,12 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 mod decoded_jwt_presentation; mod jwt_presentation_validator; +mod jwt_presentation_validator_hybrid; mod options; pub use self::decoded_jwt_presentation::*; pub use self::jwt_presentation_validator::*; +pub use self::jwt_presentation_validator_hybrid::*; pub use self::options::*; diff --git a/bindings/wasm/identity_wasm/src/credential/linked_verifiable_presentation_service.rs b/bindings/wasm/identity_wasm/src/credential/linked_verifiable_presentation_service.rs index ec7d8f3a3d..7849279b0d 100644 --- a/bindings/wasm/identity_wasm/src/credential/linked_verifiable_presentation_service.rs +++ b/bindings/wasm/identity_wasm/src/credential/linked_verifiable_presentation_service.rs @@ -34,7 +34,7 @@ impl WasmLinkedVerifiablePresentationService { .into_serde::() .wasm_result()?; Ok(Self( - LinkedVerifiablePresentationService::new(id, linked_vp, properties).wasm_result()?, + LinkedVerifiablePresentationService::new(id, linked_vp.into_vec(), properties).wasm_result()?, )) } @@ -92,7 +92,7 @@ struct ILinkedVerifiablePresentationServiceHelper { #[typescript(optional = false, type = "DIDUrl")] id: DIDUrl, /// A unique URI that may be used to identify the {@link Credential}. - #[typescript(optional = false, type = "string | string[]")] + #[typescript(name = "linkedVp", optional = false, type = "string | string[]")] linked_vp: OneOrSet, /// Miscellaneous properties. #[serde(flatten)] diff --git a/bindings/wasm/identity_wasm/src/did/did_compositejwk.rs b/bindings/wasm/identity_wasm/src/did/did_compositejwk.rs new file mode 100644 index 0000000000..5db195a609 --- /dev/null +++ b/bindings/wasm/identity_wasm/src/did/did_compositejwk.rs @@ -0,0 +1,105 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use identity_iota::did::DIDCompositeJwk; +use identity_iota::did::DID as _; +use wasm_bindgen::prelude::*; + +use super::wasm_core_did::get_core_did_clone; +use super::IToCoreDID; +use super::WasmCoreDID; +use crate::error::Result; +use crate::error::WasmResult; +use crate::jose::WasmCompositeJwk; + +/// `did:compositejwk` DID. +#[wasm_bindgen(js_name = DIDCompositeJwk)] +pub struct WasmDIDCompositeJwk(pub(crate) DIDCompositeJwk); + +#[wasm_bindgen(js_class = DIDCompositeJwk)] +impl WasmDIDCompositeJwk { + #[wasm_bindgen(constructor)] + /// Creates a new {@link DIDCompositeJwk} from a {@link CoreDID}. + /// + /// ### Errors + /// Throws an error if the given did is not a valid `did:compositejwk` DID. + pub fn new(did: IToCoreDID) -> Result { + let did = get_core_did_clone(&did).0; + DIDCompositeJwk::try_from(did).wasm_result().map(Self) + } + /// Parses a {@link DIDCompositeJwk} from the given `input`. + /// + /// ### Errors + /// + /// Throws an error if the input is not a valid {@link DIDCompositeJwk}. + #[wasm_bindgen] + pub fn parse(input: &str) -> Result { + DIDCompositeJwk::parse(input).wasm_result().map(Self) + } + + /// Returns the JSON WEB KEY (JWK) encoded inside this `did:jwk`. + #[wasm_bindgen(js_name = compositeJwk)] + pub fn composite_jwk(&self) -> WasmCompositeJwk { + self.0.composite_jwk().into() + } + + // =========================================================================== + // DID trait + // =========================================================================== + + /// Returns the {@link CoreDID} scheme. + /// + /// E.g. + /// - `"did:example:12345678" -> "did"` + /// - `"did:iota:smr:12345678" -> "did"` + #[wasm_bindgen] + pub fn scheme(&self) -> String { + self.0.scheme().to_owned() + } + + /// Returns the {@link CoreDID} authority: the method name and method-id. + /// + /// E.g. + /// - `"did:example:12345678" -> "example:12345678"` + /// - `"did:iota:smr:12345678" -> "iota:smr:12345678"` + #[wasm_bindgen] + pub fn authority(&self) -> String { + self.0.authority().to_owned() + } + + /// Returns the {@link CoreDID} method name. + /// + /// E.g. + /// - `"did:example:12345678" -> "example"` + /// - `"did:iota:smr:12345678" -> "iota"` + #[wasm_bindgen] + pub fn method(&self) -> String { + self.0.method().to_owned() + } + + /// Returns the {@link CoreDID} method-specific ID. + /// + /// E.g. + /// - `"did:example:12345678" -> "12345678"` + /// - `"did:iota:smr:12345678" -> "smr:12345678"` + #[wasm_bindgen(js_name = methodId)] + pub fn method_id(&self) -> String { + self.0.method_id().to_owned() + } + + /// Returns the {@link CoreDID} as a string. + #[allow(clippy::inherent_to_string)] + #[wasm_bindgen(js_name = toString)] + pub fn to_string(&self) -> String { + self.0.to_string() + } + + // Only intended to be called internally. + #[wasm_bindgen(js_name = toCoreDid, skip_typescript)] + pub fn to_core_did(&self) -> WasmCoreDID { + WasmCoreDID(self.0.clone().into()) + } +} + +impl_wasm_json!(WasmDIDCompositeJwk, DIDCompositeJwk); +impl_wasm_clone!(WasmDIDCompositeJwk, DIDCompositeJwk); diff --git a/bindings/wasm/identity_wasm/src/did/did_jwk.rs b/bindings/wasm/identity_wasm/src/did/did_jwk.rs index 15ce291eca..fcd7dd7707 100644 --- a/bindings/wasm/identity_wasm/src/did/did_jwk.rs +++ b/bindings/wasm/identity_wasm/src/did/did_jwk.rs @@ -27,6 +27,13 @@ impl WasmDIDJwk { let did = get_core_did_clone(&did).0; DIDJwk::try_from(did).wasm_result().map(Self) } + + /// Creates a new {@link DIDJwk} from the given {@link Jwk}. + #[wasm_bindgen(js_name = fromJwk)] + pub fn from_jwk(jwk: WasmJwk) -> Self { + Self(DIDJwk::new(jwk.0)) + } + /// Parses a {@link DIDJwk} from the given `input`. /// /// ### Errors diff --git a/bindings/wasm/identity_wasm/src/did/mod.rs b/bindings/wasm/identity_wasm/src/did/mod.rs index ae2e89bc0c..427b4be863 100644 --- a/bindings/wasm/identity_wasm/src/did/mod.rs +++ b/bindings/wasm/identity_wasm/src/did/mod.rs @@ -1,13 +1,16 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 +mod did_compositejwk; mod did_jwk; mod jws_verification_options; mod service; mod wasm_core_did; mod wasm_core_document; +mod wasm_did_jwk_document_ext; mod wasm_did_url; +pub use self::jws_verification_options::*; pub use self::service::IService; pub use self::service::UServiceEndpoint; pub use self::service::WasmService; @@ -20,6 +23,5 @@ pub use self::wasm_core_document::PromiseJws; pub use self::wasm_core_document::PromiseJwt; pub use self::wasm_core_document::WasmCoreDocument; pub use self::wasm_did_url::WasmDIDUrl; +pub use did_compositejwk::*; pub use did_jwk::*; - -pub use self::jws_verification_options::*; diff --git a/bindings/wasm/identity_wasm/src/did/wasm_core_document.rs b/bindings/wasm/identity_wasm/src/did/wasm_core_document.rs index fd66c4e7ca..9ca82769b4 100644 --- a/bindings/wasm/identity_wasm/src/did/wasm_core_document.rs +++ b/bindings/wasm/identity_wasm/src/did/wasm_core_document.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use std::rc::Rc; @@ -24,6 +24,7 @@ use crate::credential::WasmJwt; use crate::credential::WasmPresentation; use crate::did::service::WasmService; use crate::did::wasm_did_url::WasmDIDUrl; +use crate::did::WasmDIDCompositeJwk; use crate::did::WasmDIDJwk; use crate::error::Result; use crate::error::WasmResult; @@ -773,6 +774,14 @@ impl WasmCoreDocument { pub fn expand_did_jwk(did: WasmDIDJwk) -> Result { CoreDocument::expand_did_jwk(did.0).wasm_result().map(Self::from) } + + /// Creates a {@link CoreDocument} from the given {@link DIDCompositeJwk}. + #[wasm_bindgen(js_name = expandDIDCompositeJwk)] + pub fn expand_did_compositejwk(did: WasmDIDCompositeJwk) -> Result { + CoreDocument::expand_did_compositejwk(did.0) + .wasm_result() + .map(Self::from) + } } #[wasm_bindgen] diff --git a/bindings/wasm/identity_wasm/src/did/wasm_did_jwk_document_ext.rs b/bindings/wasm/identity_wasm/src/did/wasm_did_jwk_document_ext.rs new file mode 100644 index 0000000000..863ae7b440 --- /dev/null +++ b/bindings/wasm/identity_wasm/src/did/wasm_did_jwk_document_ext.rs @@ -0,0 +1,331 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use super::CoreDocumentLock; +use super::WasmCoreDocument; +use crate::common::RecordStringAny; +use crate::credential::PromiseJpt; +use crate::credential::UnknownCredential; +use crate::credential::WasmCredential; +use crate::credential::WasmJpt; +use crate::credential::WasmJwpPresentationOptions; +use crate::credential::WasmJws; +use crate::credential::WasmJwt; +use crate::credential::WasmPresentation; +use crate::did::PromiseJws; +use crate::did::PromiseJwt; +use crate::error::Result; +use crate::error::WasmResult; +use crate::jose::WasmCompositeAlgId; +use crate::jose::WasmJwsAlgorithm; +use crate::jpt::WasmProofAlgorithm; +use crate::jpt::WasmSelectiveDisclosurePresentation; +use crate::storage::WasmJwsSignatureOptions; +use crate::storage::WasmJwtPresentationOptions; +use crate::storage::WasmStorage; +use crate::storage::WasmStorageInner; +use identity_iota::core::Object; +use identity_iota::credential::Credential; +use identity_iota::credential::JwtPresentationOptions; +use identity_iota::credential::Presentation; +use identity_iota::document::CoreDocument; +use identity_iota::storage::key_storage::KeyType; +use identity_iota::storage::storage::JwkDocumentExtHybrid; +use identity_iota::storage::storage::JwsDocumentExtPQC; +use identity_iota::storage::DidJwkDocumentExt; +use identity_iota::storage::JwpDocumentExt; +use identity_iota::storage::JwsSignatureOptions; +use identity_iota::verification::jwk::CompositeAlgId; +use identity_iota::verification::jws::JwsAlgorithm; +use js_sys::Promise; +use jsonprooftoken::jpa::algs::ProofAlgorithm; +use std::rc::Rc; +use wasm_bindgen::prelude::*; +use wasm_bindgen_futures::future_to_promise; + +#[wasm_bindgen(js_class = CoreDocument)] +impl WasmCoreDocument { + /// Creates a new DID Document with the given `key_type` and `alg` with the JWK did method. + #[wasm_bindgen(js_name = newDidJwk)] + pub async fn _new_did_jwk( + storage: &WasmStorage, + key_type: String, + alg: WasmJwsAlgorithm, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let alg: JwsAlgorithm = alg.into_serde().wasm_result()?; + CoreDocument::new_did_jwk(&storage_clone, KeyType::from(key_type), alg) + .await + .map(|doc| WasmCoreDocument(Rc::new(CoreDocumentLock::new(doc.0)))) + .wasm_result() + } + + /// Creates a new PQ DID Document with the given `key_type` and `alg` with the JWK did method. + #[wasm_bindgen(js_name = newDidJwkPq)] + pub async fn _new_did_jwk_pqc( + storage: &WasmStorage, + key_type: String, + alg: WasmJwsAlgorithm, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let alg: JwsAlgorithm = alg.into_serde().wasm_result()?; + CoreDocument::new_did_jwk_pqc(&storage_clone, KeyType::from(key_type), alg) + .await + .map(|doc| WasmCoreDocument(Rc::new(CoreDocumentLock::new(doc.0)))) + .wasm_result() + } + + /// Creates a new hybrid DID Document with the given `key_type` and `alg`with the compositeJWK did method. + #[wasm_bindgen(js_name = newDidCompositeJwk)] + pub async fn _new_did_compositejwk(storage: &WasmStorage, alg: WasmCompositeAlgId) -> Result { + let storage_clone: Rc = storage.0.clone(); + let alg: CompositeAlgId = alg.into_serde().wasm_result()?; + CoreDocument::new_did_compositejwk(&storage_clone, alg) + .await + .map(|doc| WasmCoreDocument(Rc::new(CoreDocumentLock::new(doc.0)))) + .wasm_result() + } + + /// Creates a new zk DID Document with the given `key_type` and `alg` with the JWK did method. + #[wasm_bindgen(js_name = newDidJwkZk)] + pub async fn _new_did_jwk_zk(storage: &WasmStorage, alg: WasmProofAlgorithm) -> Result { + let storage_clone: Rc = storage.0.clone(); + let alg: ProofAlgorithm = alg.into(); + CoreDocument::new_did_jwk_zk(&storage_clone, KeyType::from_static_str("BLS12381"), alg) + .await + .map(|doc| WasmCoreDocument(Rc::new(CoreDocumentLock::new(doc.0)))) + .wasm_result() + } + + #[wasm_bindgen(js_name = fragmentJwk)] + pub fn _fragment(self) -> String { + "0".to_string() + } + /// Produces a PQ JWS, from a document with a PQ method, where the payload is produced from the given `fragment` and + /// `payload`. + #[wasm_bindgen(js_name = createPqJws)] + pub fn _create_pq_jws( + &self, + storage: &WasmStorage, + fragment: String, + payload: String, + options: &WasmJwsSignatureOptions, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_jws_pqc(&storage_clone, &fragment, payload.as_bytes(), &options_clone) + .await + .wasm_result() + .map(WasmJws::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } + + /// Produces an hybrid JWS, from a document with an hybrid method, where the payload is produced from the given + /// `fragment` and `payload`. + #[wasm_bindgen(js_name = createHybridJws)] + pub fn create_hybrid_jws( + &self, + storage: &WasmStorage, + fragment: String, + payload: String, + options: &WasmJwsSignatureOptions, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_jws(&storage_clone, &fragment, payload.as_bytes(), &options_clone) + .await + .wasm_result() + .map(WasmJws::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } + + /// Produces a PQ JWT, from a document with a PQ method, where the payload is produced from the given `credential` + /// in accordance with [VC Data Model v1.1](https://www.w3.org/TR/vc-data-model/#json-web-token). + /// + /// Unless the `kid` is explicitly set in the options, the `kid` in the protected header is the `id` + /// of the method identified by `fragment` and the JWS signature will be produced by the corresponding + /// private key backed by the `storage` in accordance with the passed `options`. + /// + /// The `custom_claims` can be used to set additional claims on the resulting JWT. + #[wasm_bindgen(js_name = createCredentialJwtPqc)] + pub fn _create_credential_jwt_pqc( + &self, + storage: &WasmStorage, + fragment: String, + credential: &WasmCredential, + options: &WasmJwsSignatureOptions, + custom_claims: Option, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let credential_clone: Credential = credential.0.clone(); + let custom: Option = custom_claims + .map(|claims| claims.into_serde().wasm_result()) + .transpose()?; + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_credential_jwt_pqc(&credential_clone, &storage_clone, &fragment, &options_clone, custom) + .await + .wasm_result() + .map(WasmJwt::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } + + /// Produces an hybrid JWT, from a document with an hybrid method, where the payload is produced from the given + /// `credential` in accordance with [VC Data Model v1.1](https://www.w3.org/TR/vc-data-model/#json-web-token). + /// + /// Unless the `kid` is explicitly set in the options, the `kid` in the protected header is the `id` + /// of the method identified by `fragment` and the JWS signature will be produced by the corresponding + /// private key backed by the `storage` in accordance with the passed `options`. + /// + /// The `custom_claims` can be used to set additional claims on the resulting JWT. + #[wasm_bindgen(js_name = createCredentialJwtHybrid)] + pub fn _create_credential_jwt_hybrid( + &self, + storage: &WasmStorage, + fragment: String, + credential: &WasmCredential, + options: &WasmJwsSignatureOptions, + custom_claims: Option, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let credential_clone: Credential = credential.0.clone(); + let custom: Option = custom_claims + .map(|claims| claims.into_serde().wasm_result()) + .transpose()?; + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_credential_jwt_hybrid(&credential_clone, &storage_clone, &fragment, &options_clone, custom) + .await + .wasm_result() + .map(WasmJwt::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } + + /// Produces a PQ JWT, from a document with a PQ method, where the payload is produced from the given presentation. + /// in accordance with [VC Data Model v1.1](https://www.w3.org/TR/vc-data-model/#json-web-token). + /// + /// Unless the `kid` is explicitly set in the options, the `kid` in the protected header is the `id` + /// of the method identified by `fragment` and the JWS signature will be produced by the corresponding + /// private key backed by the `storage` in accordance with the passed `options`. + #[wasm_bindgen(js_name = createPresentationJwtPqc)] + pub fn _create_presentation_jwt_pqc( + &self, + storage: &WasmStorage, + fragment: String, + presentation: &WasmPresentation, + signature_options: &WasmJwsSignatureOptions, + presentation_options: &WasmJwtPresentationOptions, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = signature_options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let presentation_clone: Presentation = presentation.0.clone(); + let presentation_options_clone: JwtPresentationOptions = presentation_options.0.clone(); + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_presentation_jwt_pqc( + &presentation_clone, + &storage_clone, + &fragment, + &options_clone, + &presentation_options_clone, + ) + .await + .wasm_result() + .map(WasmJwt::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } + + /// Produces an hybrid JWT, from a document with an hybrid method, where the payload is produced from the given + /// presentation. in accordance with [VC Data Model v1.1](https://www.w3.org/TR/vc-data-model/#json-web-token). + /// + /// Unless the `kid` is explicitly set in the options, the `kid` in the protected header is the `id` + /// of the method identified by `fragment` and the JWS signature will be produced by the corresponding + /// private key backed by the `storage` in accordance with the passed `options`. + #[wasm_bindgen(js_name = createPresentationJwtHybrid)] + pub fn _create_presentation_jwt_hybrid( + &self, + storage: &WasmStorage, + fragment: String, + presentation: &WasmPresentation, + signature_options: &WasmJwsSignatureOptions, + presentation_options: &WasmJwtPresentationOptions, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = signature_options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let presentation_clone: Presentation = presentation.0.clone(); + let presentation_options_clone: JwtPresentationOptions = presentation_options.0.clone(); + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_presentation_jwt_hybrid( + &presentation_clone, + &storage_clone, + &fragment, + &options_clone, + &presentation_options_clone, + ) + .await + .wasm_result() + .map(WasmJwt::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } + + #[wasm_bindgen(js_name = createPresentationJpt)] + pub fn create_presentation_jpt( + &self, + presentation: WasmSelectiveDisclosurePresentation, + method_id: String, + options: WasmJwpPresentationOptions, + ) -> Result { + let document_lock_clone: Rc = self.0.clone(); + let options = options.try_into()?; + let promise: Promise = future_to_promise(async move { + let mut presentation = presentation.0; + let jpt = document_lock_clone + .write() + .await + .create_presentation_jpt(&mut presentation, method_id.as_str(), &options) + .await + .map(WasmJpt) + .wasm_result()?; + Ok(JsValue::from(jpt)) + }); + + Ok(promise.unchecked_into()) + } +} diff --git a/bindings/wasm/identity_wasm/src/iota/iota_document_ext.rs b/bindings/wasm/identity_wasm/src/iota/iota_document_ext.rs new file mode 100644 index 0000000000..c52e5730b8 --- /dev/null +++ b/bindings/wasm/identity_wasm/src/iota/iota_document_ext.rs @@ -0,0 +1,317 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use std::rc::Rc; + +use identity_iota::core::Object; + +use crate::common::PromiseString; +use crate::common::RecordStringAny; +use crate::credential::UnknownCredential; +use crate::credential::WasmCredential; +use crate::credential::WasmJws; +use crate::credential::WasmJwt; +use crate::credential::WasmPresentation; +use crate::did::PromiseJws; +use crate::did::PromiseJwt; +use crate::error::Result; +use crate::error::WasmResult; +use crate::iota::IotaDocumentLock; +use crate::iota::WasmIotaDocument; +use crate::jose::WasmCompositeAlgId; +use crate::jose::WasmJwsAlgorithm; +use crate::storage::WasmJwsSignatureOptions; +use crate::storage::WasmJwtPresentationOptions; +use crate::storage::WasmStorage; +use crate::storage::WasmStorageInner; +use crate::verification::WasmMethodScope; +use identity_iota::credential::Credential; +use identity_iota::credential::JwtPresentationOptions; +use identity_iota::credential::Presentation; +use identity_iota::storage::key_storage::KeyType; +use identity_iota::storage::storage::JwsSignatureOptions; +use identity_iota::storage::JwkDocumentExtHybrid; +use identity_iota::storage::JwsDocumentExtPQC; +use identity_iota::verification::jose::jws::JwsAlgorithm; +use identity_iota::verification::jwk::CompositeAlgId; +use identity_iota::verification::MethodScope; +use js_sys::Promise; +use wasm_bindgen::prelude::*; +use wasm_bindgen::JsCast; +use wasm_bindgen_futures::future_to_promise; + +#[wasm_bindgen(js_class = IotaDocument)] +impl WasmIotaDocument { + /// Generate new PQ key material in the given `storage` and insert a new verification method with the corresponding + /// public key material into the DID document. + /// + /// - If no fragment is given the `kid` of the generated JWK is used, if it is set, otherwise an error is returned. + /// - The `keyType` must be compatible with the given `storage`. `Storage`s are expected to export key type constants + /// for that use case. + /// + /// The fragment of the generated method is returned. + #[wasm_bindgen(js_name = generateMethodPQC)] + #[allow(non_snake_case)] + pub fn generate_method_pqc( + &self, + storage: &WasmStorage, + keyType: String, + alg: WasmJwsAlgorithm, + fragment: Option, + scope: WasmMethodScope, + ) -> Result { + let alg: JwsAlgorithm = alg.into_serde().wasm_result()?; + let document_lock_clone: Rc = self.0.clone(); + let storage_clone: Rc = storage.0.clone(); + let scope: MethodScope = scope.0; + + let promise: Promise = future_to_promise(async move { + let method_fragment: String = document_lock_clone + .write() + .await + .generate_method_pqc(&storage_clone, KeyType::from(keyType), alg, fragment.as_deref(), scope) + .await + .wasm_result()?; + Ok(JsValue::from(method_fragment)) + }); + Ok(promise.unchecked_into()) + } + + /// Generate new hybrid key material in the given `storage` and insert a new verification method with the + /// corresponding public key material into the DID document. + /// + /// - If no fragment is given the `kid` of the generated JWK is used, if it is set, otherwise an error is returned. + /// - The `keyType` must be compatible with the given `storage`. `Storage`s are expected to export key type constants + /// for that use case. + /// + /// The fragment of the generated method is returned. + #[wasm_bindgen(js_name = generateMethodHybrid)] + #[allow(non_snake_case)] + pub fn generate_method_hybrid( + &self, + storage: &WasmStorage, + alg: WasmCompositeAlgId, + fragment: Option, + scope: WasmMethodScope, + ) -> Result { + let alg: CompositeAlgId = alg.into_serde().wasm_result()?; + let document_lock_clone: Rc = self.0.clone(); + let storage_clone: Rc = storage.0.clone(); + let scope: MethodScope = scope.0; + + let promise: Promise = future_to_promise(async move { + let method_fragment: String = document_lock_clone + .write() + .await + .generate_method_hybrid(&storage_clone, alg, fragment.as_deref(), scope) + .await + .wasm_result()?; + Ok(JsValue::from(method_fragment)) + }); + Ok(promise.unchecked_into()) + } + + /// Produces a PQ JWS, from a document with a PQ method, where the payload is produced from the given `fragment` and + /// `payload`. + #[wasm_bindgen(js_name = createPqJws)] + pub fn _create_pq_jws( + &self, + storage: &WasmStorage, + fragment: String, + payload: String, + options: &WasmJwsSignatureOptions, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_jws_pqc(&storage_clone, &fragment, payload.as_bytes(), &options_clone) + .await + .wasm_result() + .map(WasmJws::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } + + /// Produces an hybrid JWS, from a document with an hybrid method, where the payload is produced from the given + /// `fragment` and `payload`. + #[wasm_bindgen(js_name = createHybridJws)] + pub fn create_hybrid_jws( + &self, + storage: &WasmStorage, + fragment: String, + payload: String, + options: &WasmJwsSignatureOptions, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_jws(&storage_clone, &fragment, payload.as_bytes(), &options_clone) + .await + .wasm_result() + .map(WasmJws::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } + + /// Produces a PQ JWT, from a document with a PQ method, where the payload is produced from the given `credential` + /// in accordance with [VC Data Model v1.1](https://www.w3.org/TR/vc-data-model/#json-web-token). + /// + /// Unless the `kid` is explicitly set in the options, the `kid` in the protected header is the `id` + /// of the method identified by `fragment` and the JWS signature will be produced by the corresponding + /// private key backed by the `storage` in accordance with the passed `options`. + /// + /// The `custom_claims` can be used to set additional claims on the resulting JWT. + #[wasm_bindgen(js_name = createCredentialJwtPqc)] + pub fn _create_credential_jwt_pqc( + &self, + storage: &WasmStorage, + fragment: String, + credential: &WasmCredential, + options: &WasmJwsSignatureOptions, + custom_claims: Option, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let credential_clone: Credential = credential.0.clone(); + let custom: Option = custom_claims + .map(|claims| claims.into_serde().wasm_result()) + .transpose()?; + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_credential_jwt_pqc(&credential_clone, &storage_clone, &fragment, &options_clone, custom) + .await + .wasm_result() + .map(WasmJwt::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } + + /// Produces an hybrid JWT, from a document with an hybrid method, where the payload is produced from the given + /// `credential` in accordance with [VC Data Model v1.1](https://www.w3.org/TR/vc-data-model/#json-web-token). + /// + /// Unless the `kid` is explicitly set in the options, the `kid` in the protected header is the `id` + /// of the method identified by `fragment` and the JWS signature will be produced by the corresponding + /// private key backed by the `storage` in accordance with the passed `options`. + /// + /// The `custom_claims` can be used to set additional claims on the resulting JWT. + #[wasm_bindgen(js_name = createCredentialJwtHybrid)] + pub fn _create_credential_jwt_hybrid( + &self, + storage: &WasmStorage, + fragment: String, + credential: &WasmCredential, + options: &WasmJwsSignatureOptions, + custom_claims: Option, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let credential_clone: Credential = credential.0.clone(); + let custom: Option = custom_claims + .map(|claims| claims.into_serde().wasm_result()) + .transpose()?; + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_credential_jwt_hybrid(&credential_clone, &storage_clone, &fragment, &options_clone, custom) + .await + .wasm_result() + .map(WasmJwt::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } + + /// Produces a PQ JWT, from a document with a PQ method, where the payload is produced from the given presentation. + /// in accordance with [VC Data Model v1.1](https://www.w3.org/TR/vc-data-model/#json-web-token). + /// + /// Unless the `kid` is explicitly set in the options, the `kid` in the protected header is the `id` + /// of the method identified by `fragment` and the JWS signature will be produced by the corresponding + /// private key backed by the `storage` in accordance with the passed `options`. + #[wasm_bindgen(js_name = createPresentationJwtPqc)] + pub fn _create_presentation_jwt_pqc( + &self, + storage: &WasmStorage, + fragment: String, + presentation: &WasmPresentation, + signature_options: &WasmJwsSignatureOptions, + presentation_options: &WasmJwtPresentationOptions, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = signature_options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let presentation_clone: Presentation = presentation.0.clone(); + let presentation_options_clone: JwtPresentationOptions = presentation_options.0.clone(); + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_presentation_jwt_pqc( + &presentation_clone, + &storage_clone, + &fragment, + &options_clone, + &presentation_options_clone, + ) + .await + .wasm_result() + .map(WasmJwt::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } + + /// Produces an hybrid JWT, from a document with an hybrid method, where the payload is produced from the given + /// presentation. in accordance with [VC Data Model v1.1](https://www.w3.org/TR/vc-data-model/#json-web-token). + /// + /// Unless the `kid` is explicitly set in the options, the `kid` in the protected header is the `id` + /// of the method identified by `fragment` and the JWS signature will be produced by the corresponding + /// private key backed by the `storage` in accordance with the passed `options`. + #[wasm_bindgen(js_name = createPresentationJwtHybrid)] + pub fn _create_presentation_jwt_hybrid( + &self, + storage: &WasmStorage, + fragment: String, + presentation: &WasmPresentation, + signature_options: &WasmJwsSignatureOptions, + presentation_options: &WasmJwtPresentationOptions, + ) -> Result { + let storage_clone: Rc = storage.0.clone(); + let options_clone: JwsSignatureOptions = signature_options.0.clone(); + let document_lock_clone: Rc = self.0.clone(); + let presentation_clone: Presentation = presentation.0.clone(); + let presentation_options_clone: JwtPresentationOptions = presentation_options.0.clone(); + let promise: Promise = future_to_promise(async move { + document_lock_clone + .read() + .await + .create_presentation_jwt_hybrid( + &presentation_clone, + &storage_clone, + &fragment, + &options_clone, + &presentation_options_clone, + ) + .await + .wasm_result() + .map(WasmJwt::new) + .map(JsValue::from) + }); + Ok(promise.unchecked_into()) + } +} diff --git a/bindings/wasm/identity_wasm/src/iota/mod.rs b/bindings/wasm/identity_wasm/src/iota/mod.rs index a8f882a79c..8ee1eb7804 100644 --- a/bindings/wasm/identity_wasm/src/iota/mod.rs +++ b/bindings/wasm/identity_wasm/src/iota/mod.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2022 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 pub use iota_did::WasmIotaDID; @@ -10,5 +10,6 @@ pub use iota_metadata_encoding::WasmStateMetadataEncoding; mod iota_did; mod iota_document; +mod iota_document_ext; mod iota_document_metadata; mod iota_metadata_encoding; diff --git a/bindings/wasm/identity_wasm/src/jose/compositejwk.rs b/bindings/wasm/identity_wasm/src/jose/compositejwk.rs new file mode 100644 index 0000000000..0351c353d4 --- /dev/null +++ b/bindings/wasm/identity_wasm/src/jose/compositejwk.rs @@ -0,0 +1,60 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use identity_iota::verification::jose::jwk::CompositeJwk; + +use crate::error::Result; +use crate::jose::IJwkParams; +use crate::jose::WasmCompositeAlgId; +use crate::jose::WasmJwk; +use wasm_bindgen::prelude::*; + +#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] +#[serde(transparent)] +#[wasm_bindgen(js_name = CompositeJwk)] +pub struct WasmCompositeJwk(pub(crate) CompositeJwk); + +#[wasm_bindgen(js_class = CompositeJwk)] +impl WasmCompositeJwk { + #[wasm_bindgen(constructor)] + pub fn new(jwk: IJwkParams) -> Result { + let jwk = jwk + .into_serde() + .map_err(|e| JsValue::from_str(&format!("Failed to deserialize CompositeJwk: {}", e)))?; + Ok(Self(jwk)) + } + + #[wasm_bindgen] + /// Get the `algId` value. + pub fn alg_id(&self) -> WasmCompositeAlgId { + //let alg: CompositeAlgId = alg.into_serde().wasm_result()?; + //JsValue::from(self.0.alg_id()).unchecked_into() + JsValue::from_serde(&self.0.alg_id()).unwrap().unchecked_into() + } + + /// Get the post-quantum public key in Jwk format. + #[wasm_bindgen] + pub fn pq_public_key(&self) -> WasmJwk { + //JsValue::from(self.0.pq_public_key()).unchecked_into() + todo!() + } + + #[wasm_bindgen] + /// Get the traditional public key in Jwk format. + pub fn traditional_public_key(&self) -> WasmJwk { + //self.0.traditional_public_key().map(JsValue::from) + todo!() + } +} + +impl From for CompositeJwk { + fn from(value: WasmCompositeJwk) -> Self { + value.0 + } +} + +impl From for WasmCompositeJwk { + fn from(value: CompositeJwk) -> Self { + WasmCompositeJwk(value) + } +} diff --git a/bindings/wasm/identity_wasm/src/jose/jwk.rs b/bindings/wasm/identity_wasm/src/jose/jwk.rs index 7c1d256d86..7dd0571931 100644 --- a/bindings/wasm/identity_wasm/src/jose/jwk.rs +++ b/bindings/wasm/identity_wasm/src/jose/jwk.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use identity_iota::verification::jose::jwk::Jwk; @@ -11,6 +11,7 @@ use crate::common::ArrayString; use crate::error::WasmResult; use crate::jose::ArrayJwkOperation; use crate::jose::IJwkParams; +use crate::jose::WasmJwkParamsAkp; use crate::jose::WasmJwkParamsEc; use crate::jose::WasmJwkParamsOct; use crate::jose::WasmJwkParamsOkp; @@ -135,7 +136,9 @@ impl WasmJwk { pub fn params_ec(&self) -> crate::error::Result> { if let JwkParams::Ec(params_ec) = self.0.params() { // WARNING: this does not validate the return type. Check carefully. - Ok(Some(JsValue::from_serde(params_ec).wasm_result()?.unchecked_into())) + Ok(Some( + serde_wasm_bindgen::to_value(params_ec).wasm_result()?.unchecked_into(), + )) } else { Ok(None) } @@ -146,7 +149,9 @@ impl WasmJwk { pub fn params_okp(&self) -> crate::error::Result> { if let JwkParams::Okp(params_okp) = self.0.params() { // WARNING: this does not validate the return type. Check carefully. - Ok(Some(JsValue::from_serde(params_okp).wasm_result()?.unchecked_into())) + Ok(Some( + serde_wasm_bindgen::to_value(params_okp).wasm_result()?.unchecked_into(), + )) } else { Ok(None) } @@ -157,7 +162,9 @@ impl WasmJwk { pub fn params_oct(&self) -> crate::error::Result> { if let JwkParams::Oct(params_oct) = self.0.params() { // WARNING: this does not validate the return type. Check carefully. - Ok(Some(JsValue::from_serde(params_oct).wasm_result()?.unchecked_into())) + Ok(Some( + serde_wasm_bindgen::to_value(params_oct).wasm_result()?.unchecked_into(), + )) } else { Ok(None) } @@ -168,7 +175,22 @@ impl WasmJwk { pub fn params_rsa(&self) -> crate::error::Result> { if let JwkParams::Rsa(params_rsa) = self.0.params() { // WARNING: this does not validate the return type. Check carefully. - Ok(Some(JsValue::from_serde(params_rsa).wasm_result()?.unchecked_into())) + Ok(Some( + serde_wasm_bindgen::to_value(params_rsa).wasm_result()?.unchecked_into(), + )) + } else { + Ok(None) + } + } + + /// If this JWK is of kty AKP, returns those parameters. + #[wasm_bindgen(js_name = paramsAkp)] + pub fn params_akp(&self) -> crate::error::Result> { + if let JwkParams::Akp(params_akp) = self.0.params() { + // WARNING: this does not validate the return type. Check carefully. + Ok(Some( + serde_wasm_bindgen::to_value(params_akp).wasm_result()?.unchecked_into(), + )) } else { Ok(None) } @@ -221,7 +243,7 @@ impl_wasm_clone!(WasmJwk, Jwk); #[wasm_bindgen(typescript_custom_section)] const I_JWK: &'static str = r#" -type IJwkParams = IJwkEc | IJwkRsa | IJwkOkp | IJwkOct +type IJwkParams = IJwkEc | IJwkRsa | IJwkOkp | IJwkOct | IJwkAkp /** A JSON Web Key with EC params. */ export interface IJwkEc extends IJwk, JwkParamsEc { kty: JwkType.Ec @@ -238,6 +260,10 @@ export interface IJwkOkp extends IJwk, JwkParamsOkp { export interface IJwkOct extends IJwk, JwkParamsOct { kty: JwkType.Oct } +/** A JSON Web Key with AKP params. */ +export interface IJwkAkp extends IJwk, JwkParamsAkp { + kty: JwkType.Akp +} "#; #[wasm_bindgen(typescript_custom_section)] @@ -421,3 +447,13 @@ interface JwkParamsOct { * [More Info](https://tools.ietf.org/html/rfc7518#section-6.4.1) */ k: string }"#; + +#[wasm_bindgen(typescript_custom_section)] +const IJWK_PARAMS_AKP: &str = r#" +/** Parameters for Algorithm Key Pair (AKP). + * + * [More Info](https://datatracker.ietf.org/doc/html/draft-ietf-cose-dilithium-06#name-algorithm-key-pair-type) */ +interface JwkParamsAkp { + pub: string, + priv?: string +}"#; diff --git a/bindings/wasm/identity_wasm/src/jose/mod.rs b/bindings/wasm/identity_wasm/src/jose/mod.rs index 9d6075dbb3..d49dbc6fd0 100644 --- a/bindings/wasm/identity_wasm/src/jose/mod.rs +++ b/bindings/wasm/identity_wasm/src/jose/mod.rs @@ -1,12 +1,14 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 +mod compositejwk; mod decoded_jws; mod jwk; mod jws_header; mod jwu; mod types; +pub use compositejwk::*; pub use decoded_jws::*; pub use jwk::*; pub use jws_header::*; diff --git a/bindings/wasm/identity_wasm/src/jose/types.rs b/bindings/wasm/identity_wasm/src/jose/types.rs index b069dd5bb3..95a9e36d35 100644 --- a/bindings/wasm/identity_wasm/src/jose/types.rs +++ b/bindings/wasm/identity_wasm/src/jose/types.rs @@ -1,5 +1,7 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 + +use identity_iota::verification::jwk::CompositeAlgId; use identity_iota::verification::jws::JwsAlgorithm; use js_sys::JsString; use std::str::FromStr; @@ -25,6 +27,10 @@ extern "C" { pub type WasmJwkParamsRsa; #[wasm_bindgen(typescript_type = "JwkParamsOct")] pub type WasmJwkParamsOct; + #[wasm_bindgen(typescript_type = "JwkParamsAkp")] + pub type WasmJwkParamsAkp; + #[wasm_bindgen(typescript_type = "CompositeAlgId")] + pub type WasmCompositeAlgId; } impl TryFrom for JwsAlgorithm { @@ -38,3 +44,15 @@ impl TryFrom for JwsAlgorithm { } } } + +impl TryFrom for CompositeAlgId { + type Error = JsValue; + fn try_from(value: WasmCompositeAlgId) -> Result { + if let Ok(js_string) = value.dyn_into::() { + CompositeAlgId::from_str(String::from(js_string).as_ref()) + .map_err(|err| js_sys::Error::new(&err.to_string()).into()) + } else { + Err(js_sys::Error::new("invalid CompositeAlgId").into()) + } + } +} diff --git a/bindings/wasm/identity_wasm/src/jpt/encoding.rs b/bindings/wasm/identity_wasm/src/jpt/encoding.rs index e36a5307a5..2a58d1cc0e 100644 --- a/bindings/wasm/identity_wasm/src/jpt/encoding.rs +++ b/bindings/wasm/identity_wasm/src/jpt/encoding.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2024 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use jsonprooftoken::encoding::SerializationType; @@ -8,6 +8,7 @@ use wasm_bindgen::prelude::*; pub enum WasmSerializationType { COMPACT = 0, JSON = 1, + CBOR = 2, } impl From for SerializationType { @@ -15,6 +16,7 @@ impl From for SerializationType { match value { WasmSerializationType::COMPACT => SerializationType::COMPACT, WasmSerializationType::JSON => SerializationType::JSON, + WasmSerializationType::CBOR => SerializationType::CBOR, } } } @@ -24,6 +26,7 @@ impl From for WasmSerializationType { match value { SerializationType::COMPACT => WasmSerializationType::COMPACT, SerializationType::JSON => WasmSerializationType::JSON, + SerializationType::CBOR => WasmSerializationType::CBOR, } } } diff --git a/bindings/wasm/identity_wasm/src/jpt/presentation_protected_header.rs b/bindings/wasm/identity_wasm/src/jpt/presentation_protected_header.rs index 398870da4c..0708c9a33a 100644 --- a/bindings/wasm/identity_wasm/src/jpt/presentation_protected_header.rs +++ b/bindings/wasm/identity_wasm/src/jpt/presentation_protected_header.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2024 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use jsonprooftoken::jpa::algs::PresentationProofAlgorithm; @@ -9,9 +9,11 @@ use wasm_bindgen::prelude::*; #[wasm_bindgen(js_name = PresentationProofAlgorithm)] #[allow(non_camel_case_types)] pub enum WasmPresentationProofAlgorithm { - BLS12381_SHA256_PROOF, - BLS12381_SHAKE256_PROOF, + BBS, + BBS_SHAKE256, SU_ES256, + SU_ES384, + SU_ES512, MAC_H256, MAC_H384, MAC_H512, @@ -23,9 +25,11 @@ pub enum WasmPresentationProofAlgorithm { impl From for PresentationProofAlgorithm { fn from(value: WasmPresentationProofAlgorithm) -> Self { match value { - WasmPresentationProofAlgorithm::BLS12381_SHA256_PROOF => PresentationProofAlgorithm::BLS12381_SHA256_PROOF, - WasmPresentationProofAlgorithm::BLS12381_SHAKE256_PROOF => PresentationProofAlgorithm::BLS12381_SHAKE256_PROOF, + WasmPresentationProofAlgorithm::BBS => PresentationProofAlgorithm::BBS, + WasmPresentationProofAlgorithm::BBS_SHAKE256 => PresentationProofAlgorithm::BBS_SHAKE256, WasmPresentationProofAlgorithm::SU_ES256 => PresentationProofAlgorithm::SU_ES256, + WasmPresentationProofAlgorithm::SU_ES384 => PresentationProofAlgorithm::SU_ES384, + WasmPresentationProofAlgorithm::SU_ES512 => PresentationProofAlgorithm::SU_ES512, WasmPresentationProofAlgorithm::MAC_H256 => PresentationProofAlgorithm::MAC_H256, WasmPresentationProofAlgorithm::MAC_H384 => PresentationProofAlgorithm::MAC_H384, WasmPresentationProofAlgorithm::MAC_H512 => PresentationProofAlgorithm::MAC_H512, @@ -39,9 +43,11 @@ impl From for PresentationProofAlgorithm { impl From for WasmPresentationProofAlgorithm { fn from(value: PresentationProofAlgorithm) -> Self { match value { - PresentationProofAlgorithm::BLS12381_SHA256_PROOF => WasmPresentationProofAlgorithm::BLS12381_SHA256_PROOF, - PresentationProofAlgorithm::BLS12381_SHAKE256_PROOF => WasmPresentationProofAlgorithm::BLS12381_SHAKE256_PROOF, + PresentationProofAlgorithm::BBS => WasmPresentationProofAlgorithm::BBS, + PresentationProofAlgorithm::BBS_SHAKE256 => WasmPresentationProofAlgorithm::BBS_SHAKE256, PresentationProofAlgorithm::SU_ES256 => WasmPresentationProofAlgorithm::SU_ES256, + PresentationProofAlgorithm::SU_ES384 => WasmPresentationProofAlgorithm::SU_ES384, + PresentationProofAlgorithm::SU_ES512 => WasmPresentationProofAlgorithm::SU_ES512, PresentationProofAlgorithm::MAC_H256 => WasmPresentationProofAlgorithm::MAC_H256, PresentationProofAlgorithm::MAC_H384 => WasmPresentationProofAlgorithm::MAC_H384, PresentationProofAlgorithm::MAC_H512 => WasmPresentationProofAlgorithm::MAC_H512, diff --git a/bindings/wasm/identity_wasm/src/jpt/proof_algorithm.rs b/bindings/wasm/identity_wasm/src/jpt/proof_algorithm.rs index 0f7f6986f1..3a90d38bef 100644 --- a/bindings/wasm/identity_wasm/src/jpt/proof_algorithm.rs +++ b/bindings/wasm/identity_wasm/src/jpt/proof_algorithm.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2024 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use jsonprooftoken::jpa::algs::ProofAlgorithm; @@ -8,9 +8,11 @@ use wasm_bindgen::prelude::*; #[derive(Clone, Copy, Debug, PartialEq, Eq)] #[wasm_bindgen(js_name = ProofAlgorithm)] pub enum WasmProofAlgorithm { - BLS12381_SHA256, - BLS12381_SHAKE256, + BBS, + BBS_SHAKE256, SU_ES256, + SU_ES384, + SU_ES512, MAC_H256, MAC_H384, MAC_H512, @@ -22,9 +24,11 @@ pub enum WasmProofAlgorithm { impl From for WasmProofAlgorithm { fn from(value: ProofAlgorithm) -> Self { match value { - ProofAlgorithm::BLS12381_SHA256 => WasmProofAlgorithm::BLS12381_SHA256, - ProofAlgorithm::BLS12381_SHAKE256 => WasmProofAlgorithm::BLS12381_SHAKE256, + ProofAlgorithm::BBS => WasmProofAlgorithm::BBS, + ProofAlgorithm::BBS_SHAKE256 => WasmProofAlgorithm::BBS_SHAKE256, ProofAlgorithm::SU_ES256 => WasmProofAlgorithm::SU_ES256, + ProofAlgorithm::SU_ES384 => WasmProofAlgorithm::SU_ES384, + ProofAlgorithm::SU_ES512 => WasmProofAlgorithm::SU_ES512, ProofAlgorithm::MAC_H256 => WasmProofAlgorithm::MAC_H256, ProofAlgorithm::MAC_H384 => WasmProofAlgorithm::MAC_H384, ProofAlgorithm::MAC_H512 => WasmProofAlgorithm::MAC_H512, @@ -38,9 +42,11 @@ impl From for WasmProofAlgorithm { impl From for ProofAlgorithm { fn from(value: WasmProofAlgorithm) -> Self { match value { - WasmProofAlgorithm::BLS12381_SHA256 => ProofAlgorithm::BLS12381_SHA256, - WasmProofAlgorithm::BLS12381_SHAKE256 => ProofAlgorithm::BLS12381_SHAKE256, + WasmProofAlgorithm::BBS => ProofAlgorithm::BBS, + WasmProofAlgorithm::BBS_SHAKE256 => ProofAlgorithm::BBS_SHAKE256, WasmProofAlgorithm::SU_ES256 => ProofAlgorithm::SU_ES256, + WasmProofAlgorithm::SU_ES384 => ProofAlgorithm::SU_ES384, + WasmProofAlgorithm::SU_ES512 => ProofAlgorithm::SU_ES512, WasmProofAlgorithm::MAC_H256 => ProofAlgorithm::MAC_H256, WasmProofAlgorithm::MAC_H384 => ProofAlgorithm::MAC_H384, WasmProofAlgorithm::MAC_H512 => ProofAlgorithm::MAC_H512, diff --git a/bindings/wasm/identity_wasm/src/lib.rs b/bindings/wasm/identity_wasm/src/lib.rs index d20fc32fe5..e7d57b1b5c 100644 --- a/bindings/wasm/identity_wasm/src/lib.rs +++ b/bindings/wasm/identity_wasm/src/lib.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2022 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 #![allow(deprecated)] diff --git a/bindings/wasm/identity_wasm/src/resolver/irl_resolver.rs b/bindings/wasm/identity_wasm/src/resolver/irl_resolver.rs new file mode 100644 index 0000000000..4171c442c9 --- /dev/null +++ b/bindings/wasm/identity_wasm/src/resolver/irl_resolver.rs @@ -0,0 +1,79 @@ +// Copyright 2020-2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +use iota_caip::iota::resolver::Resolver; +use iota_caip::iota::IotaNetwork; +use js_sys::Object; +use wasm_bindgen::prelude::*; + +/// A resolver for IOTA Resource Locators (IRLs). +#[wasm_bindgen(js_name = IrlResolver)] +pub struct WasmIrlResolver(Resolver); + +#[wasm_bindgen(js_class = IrlResolver)] +impl WasmIrlResolver { + // Creates a new {@link IrlResolver} instance. + #[wasm_bindgen(constructor)] + pub fn new(params: Option) -> Result { + let params: IrlResolverParams = serde_wasm_bindgen::from_value(params.unwrap_or_default().into())?; + let custom_networks = params + .custom_networks + .into_iter() + .map(|CustomNetworkParams { chain_id, endpoint }| { + let network = IotaNetwork::from_genesis_digest(&chain_id) + .ok_or_else(|| JsError::new(&format!("Invalid chain ID: {chain_id}")))?; + Ok((network, endpoint)) + }) + .collect::, JsError>>()?; + + Ok(Self(Resolver::new_with_custom_networks(custom_networks))) + } + + /// Resolves an IOTA Resource Locator (IRL) to its corresponding resource. + pub async fn resolve(&self, irl: &str) -> Result { + let res = self + .0 + .resolve(irl) + .await + .map_err(|e| JsError::new(&format!("{:#}", anyhow::Error::from(e))))?; + Ok(serde_wasm_bindgen::to_value(&res).expect("a JSON Value can be turned into a JsValue")) + } +} + +#[derive(serde::Deserialize, Default)] +#[serde(rename_all = "camelCase")] +struct IrlResolverParams { + #[serde(default)] + custom_networks: Vec, +} + +#[derive(serde::Deserialize)] +#[serde(rename_all = "camelCase")] +struct CustomNetworkParams { + chain_id: String, + endpoint: String, +} + +#[wasm_bindgen] +extern "C" { + #[wasm_bindgen(typescript_type = "IrlResolverParams", extends = Object)] + #[derive(Default)] + pub type IIrlResolverParams; +} + +#[wasm_bindgen(typescript_custom_section)] +const IRL_PARAMS: &str = r#" +/** Parameters for creating a new {@link IrlResolver} instance. */ +export interface IrlResolverParams { + /** Custom networks to use for resolving IOTA Resource Locators. */ + customNetworks?: CustomNetworkParams[]; +} + +/** Parameters for defining a custom IOTA network. */ +export interface CustomNetworkParams { + /** An IOTA chain ID. e.g. `mainnet`, `32b2fcb4`.*/ + chainId: string; + /** The node JSON-RPC endpoint to connect to. */ + endpoint: string; +} +"#; diff --git a/bindings/wasm/identity_wasm/src/resolver/mod.rs b/bindings/wasm/identity_wasm/src/resolver/mod.rs index 636bc6b85d..535e059149 100644 --- a/bindings/wasm/identity_wasm/src/resolver/mod.rs +++ b/bindings/wasm/identity_wasm/src/resolver/mod.rs @@ -1,10 +1,12 @@ // Copyright 2020-2023 IOTA Stiftung // SPDX-License-Identifier: Apache-2.0 +mod irl_resolver; mod resolver_config; mod resolver_types; mod wasm_did_resolution_handler; mod wasm_resolver; +pub use irl_resolver::*; pub use resolver_types::*; pub use wasm_did_resolution_handler::WasmDidResolutionHandler; diff --git a/bindings/wasm/identity_wasm/src/storage/jwk_storage_pqc.rs b/bindings/wasm/identity_wasm/src/storage/jwk_storage_pqc.rs new file mode 100644 index 0000000000..a06f0a8181 --- /dev/null +++ b/bindings/wasm/identity_wasm/src/storage/jwk_storage_pqc.rs @@ -0,0 +1,84 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use super::WasmJwkStorage; +use crate::jose::WasmJwk; +use identity_iota::storage::JwkGenOutput; +use identity_iota::storage::JwkStoragePQ; +use identity_iota::storage::KeyId; +use identity_iota::storage::KeyStorageError; +use identity_iota::storage::KeyStorageErrorKind; +use identity_iota::storage::KeyStorageResult; +use identity_iota::storage::KeyType; +use identity_iota::verification::jose::jws::JwsAlgorithm; +use identity_iota::verification::jwk::PostQuantumJwk; +use js_sys::Uint8Array; +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +extern "C" { + + #[wasm_bindgen(method, js_name = generatePQKey)] + pub async fn _generate_pq_key(this: &WasmJwkStorage, key_type: String, alg: String) -> JsValue; + + #[wasm_bindgen(method, js_name = signPQ)] + pub async fn _pq_sign( + this: &WasmJwkStorage, + key_id: String, + data: Vec, + public_key: WasmJwk, + ctx: Option<&[u8]>, + ) -> JsValue; + +} + +#[async_trait::async_trait(?Send)] +impl JwkStoragePQ for WasmJwkStorage { + async fn generate_pq_key(&self, key_type: KeyType, alg: JwsAlgorithm) -> KeyStorageResult { + WasmJwkStorage::_generate_pq_key(self, key_type.into(), alg.name().to_owned()) + .await + .into_serde() + .map_err(|e| KeyStorageError::new(KeyStorageErrorKind::SerializationError).with_source(e)) + } + + async fn pq_sign( + &self, + key_id: &KeyId, + data: &[u8], + public_key: &PostQuantumJwk, + ctx: Option<&[u8]>, + ) -> KeyStorageResult> { + let value = WasmJwkStorage::_pq_sign( + self, + key_id.clone().into(), + data.to_owned(), + WasmJwk(public_key.clone().into()), + ctx, + ) + .await; + + uint8array_to_bytes(value) + } +} + +#[wasm_bindgen(typescript_custom_section)] +const JWK_STORAGE_PQ: &'static str = r#" +/** Secure storage for cryptographic keys represented as JWKs. */ +interface JwkStoragePQ { + /** Generate a new PQ key represented as a JSON Web Key. + * + * It's recommend that the implementer exposes constants for the supported key type string. */ + generatePQKey: (keyType: string, algorithm: JwsAlgorithm) => Promise; + + signPQ: (keyId: string, data: Uint8Array, publicKey: Jwk, ctx: Uint8Array|undefined ) => Promise; +}"#; + +fn uint8array_to_bytes(value: JsValue) -> KeyStorageResult> { + if !JsCast::is_instance_of::(&value) { + return Err( + KeyStorageError::new(KeyStorageErrorKind::SerializationError) + .with_custom_message("expected Uint8Array".to_owned()), + ); + } + Ok(Uint8Array::new(&value).to_vec()) +} diff --git a/bindings/wasm/identity_wasm/src/storage/mod.rs b/bindings/wasm/identity_wasm/src/storage/mod.rs index 8407c09a88..68f492c70c 100644 --- a/bindings/wasm/identity_wasm/src/storage/mod.rs +++ b/bindings/wasm/identity_wasm/src/storage/mod.rs @@ -1,10 +1,11 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 mod jpt_timeframe_revocation_ext; mod jwk_gen_output; mod jwk_storage; mod jwk_storage_bbs_plus_ext; +mod jwk_storage_pqc; mod jwt_presentation_options; mod key_id_storage; #[cfg(feature = "keytool")] diff --git a/examples/1_advanced/10_zkp_revocation.rs b/examples/1_advanced/10_zkp_revocation.rs index a7d04f68a3..6db5a112bd 100644 --- a/examples/1_advanced/10_zkp_revocation.rs +++ b/examples/1_advanced/10_zkp_revocation.rs @@ -139,7 +139,7 @@ async fn main() -> anyhow::Result<()> { &storage_issuer, JwkMemStore::BLS12381G2_KEY_TYPE, None, - Some(ProofAlgorithm::BLS12381_SHA256), + Some(ProofAlgorithm::BBS), ) .await?; @@ -326,7 +326,7 @@ async fn main() -> anyhow::Result<()> { // Step 2b: Waiting for the next validityTimeframe, will result in the Credential timeframe interval NOT valid // =========================================================================== - thread::sleep(SleepDuration::from_secs(61)); + thread::sleep(SleepDuration::from_secs(63)); let timeframe_result = JptPresentationValidatorUtils::check_timeframes_with_validity_timeframe_2024( &decoded_presented_credential.credential, diff --git a/examples/1_advanced/11_linked_verifiable_presentation.rs b/examples/1_advanced/11_linked_verifiable_presentation.rs index 97b50e8bcf..33dbc7ee73 100644 --- a/examples/1_advanced/11_linked_verifiable_presentation.rs +++ b/examples/1_advanced/11_linked_verifiable_presentation.rs @@ -5,14 +5,15 @@ use anyhow::Context; use examples::create_did_document; use examples::get_funded_client; +use examples::get_iota_endpoint; use examples::get_memstorage; +use examples::get_notarization_client; use examples::MemStorage; use examples::TEST_GAS_BUDGET; use identity_eddsa_verifier::EdDSAJwsVerifier; use identity_iota::core::FromJson; use identity_iota::core::Object; -use identity_iota::core::OrderedSet; use identity_iota::core::Url; use identity_iota::credential::CompoundJwtPresentationValidationError; use identity_iota::credential::CredentialBuilder; @@ -34,6 +35,9 @@ use identity_iota::iota::IotaDocument; use identity_iota::resolver::Resolver; use identity_iota::storage::JwkDocumentExt; use identity_iota::storage::JwsSignatureOptions; +use iota_caip::iota::resolver::Resolver as IotaResourceResolver; +use iota_caip::iota::IotaNetwork; +use product_common::core_client::CoreClient as _; #[tokio::main] async fn main() -> anyhow::Result<()> { @@ -42,7 +46,6 @@ async fn main() -> anyhow::Result<()> { // =========================================================================== let storage = get_memstorage()?; - let identity_client = get_funded_client(&storage).await?; // create new DID document and publish it @@ -53,22 +56,40 @@ async fn main() -> anyhow::Result<()> { let did: IotaDID = did_document.id().clone(); // ===================================================== - // Create Linked Verifiable Presentation service + // Create a Verifiable Presentation and host it on-chain // ===================================================== - // The DID should link to the following VPs. - let verifiable_presentation_url_1: Url = Url::parse("https://foo.example.com/verifiable-presentation.jwt")?; - let verifiable_presentation_url_2: Url = Url::parse("https://bar.example.com/verifiable-presentation.jsonld")?; + let jwt_vp = make_vp_jwt(&did_document, &storage, &fragment).await?; + + // In this example the created VP is hosted inside an IOTA Notarization + // but user may host it where ever they choose. - let mut verifiable_presentation_urls: OrderedSet = OrderedSet::new(); - verifiable_presentation_urls.append(verifiable_presentation_url_1.clone()); - verifiable_presentation_urls.append(verifiable_presentation_url_2.clone()); + // We create a notarization client that uses the same address as our identity client. + let notarization_client = get_notarization_client(identity_client.signer().clone()).await?; + // Notarize the VP we previously created. + let notarized_vp = notarization_client + .create_locked_notarization() + .with_string_state(jwt_vp.into(), Some("My Linked VP".to_owned())) + .finish()? + .build_and_execute(¬arization_client) + .await? + .output; + + // ===================================================== + // Create Linked Verifiable Presentation service + // ===================================================== + + // The IOTA Resource Locator that references our notarized JWT-VP. + let vp_url: Url = notarized_vp + .iota_resource_locator_builder(notarization_client.network()) + .data() + .into(); // Create a Linked Verifiable Presentation Service to enable the discovery of the linked VPs through the DID Document. // This is optional since it is not a hard requirement by the specs. let service_url: DIDUrl = did.clone().join("#linked-vp")?; let linked_verifiable_presentation_service = - LinkedVerifiablePresentationService::new(service_url, verifiable_presentation_urls, Object::new())?; + LinkedVerifiablePresentationService::new(service_url, [vp_url], Object::new())?; did_document.insert_service(linked_verifiable_presentation_service.into())?; let updated_did_document: IotaDocument = identity_client @@ -99,14 +120,20 @@ async fn main() -> anyhow::Result<()> { assert_eq!(linked_verifiable_presentation_services.len(), 1); // Get the VPs included in the service. - let _verifiable_presentation_urls: &[Url] = linked_verifiable_presentation_services + let vp_url = linked_verifiable_presentation_services .first() .ok_or_else(|| anyhow::anyhow!("expected verifiable presentation urls"))? - .verifiable_presentation_urls(); + .verifiable_presentation_urls() + .first() + .expect("one linked VP endpoint is present"); - // Fetch the verifiable presentation from the URL (for example using `reqwest`). - // But since the URLs do not point to actual online resource, we will simply create an example JWT. - let presentation_jwt: Jwt = make_vp_jwt(&did_document, &storage, &fragment).await?; + println!("Fetching VP at `{vp_url}`"); + // Fetch the verifiable presentation from the URL. We know it's an IOTA Resource Locator + // therefore we are gonna use the IOTA Resource Locator Resolver. + let custom_network = IotaNetwork::custom(identity_client.network().as_ref()).expect("valid IOTA network"); + let iota_resource_resolver = + IotaResourceResolver::new_with_custom_networks(vec![(custom_network, get_iota_endpoint())]); + let presentation_jwt = serde_json::from_value(iota_resource_resolver.resolve(vp_url).await?)?; // Resolve the holder's document. let holder_did: CoreDID = JwtPresentationValidatorUtils::extract_holder(&presentation_jwt)?; @@ -124,6 +151,7 @@ async fn main() -> anyhow::Result<()> { ); assert!(validation_result.is_ok()); + println!("Linked VP validation succeeded"); Ok(()) } diff --git a/examples/1_advanced/9_zkp.rs b/examples/1_advanced/9_zkp.rs index 9b5eaa5de5..da8fe260b3 100644 --- a/examples/1_advanced/9_zkp.rs +++ b/examples/1_advanced/9_zkp.rs @@ -84,7 +84,7 @@ async fn main() -> anyhow::Result<()> { &identity_client, &storage_issuer, JwkMemStore::BLS12381G2_KEY_TYPE, - ProofAlgorithm::BLS12381_SHA256, + ProofAlgorithm::BBS, ) .await?; diff --git a/examples/1_advanced/hybrid.rs b/examples/1_advanced/hybrid.rs new file mode 100644 index 0000000000..fe0832217d --- /dev/null +++ b/examples/1_advanced/hybrid.rs @@ -0,0 +1,245 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use examples::get_funded_client; +use examples::get_memstorage; +use examples::MemStorage; +use identity_eddsa_verifier::EdDSAJwsVerifier; +use identity_iota::core::Duration; +use identity_iota::core::FromJson; +use identity_iota::core::Object; +use identity_iota::core::Timestamp; +use identity_iota::core::Url; +use identity_iota::credential::Credential; +use identity_iota::credential::CredentialBuilder; +use identity_iota::credential::DecodedJwtCredential; +use identity_iota::credential::DecodedJwtPresentation; +use identity_iota::credential::FailFast; +use identity_iota::credential::Jwt; +use identity_iota::credential::JwtCredentialValidationOptions; +use identity_iota::credential::JwtCredentialValidatorHybrid; +use identity_iota::credential::JwtCredentialValidatorUtils; +use identity_iota::credential::JwtPresentationOptions; +use identity_iota::credential::JwtPresentationValidationOptions; +use identity_iota::credential::JwtPresentationValidatorHybrid; +use identity_iota::credential::JwtPresentationValidatorUtils; +use identity_iota::credential::Presentation; +use identity_iota::credential::PresentationBuilder; +use identity_iota::credential::Subject; +use identity_iota::credential::SubjectHolderRelationship; +use identity_iota::did::CoreDID; +use identity_iota::did::DID; +use identity_iota::document::verifiable::JwsVerificationOptions; +use identity_iota::iota::rebased::client::IdentityClient; +use identity_iota::iota::IotaDocument; +use identity_iota::iota_interaction::IotaKeySignature; +use identity_iota::resolver::Resolver; +use identity_iota::storage::JwkDocumentExtHybrid; +use identity_iota::storage::JwsSignatureOptions; +use identity_iota::verification::jwk::CompositeAlgId; +use identity_iota::verification::MethodScope; +use identity_pqc_verifier::PQCJwsVerifier; +use product_common::core_client::CoreClientReadOnly as _; +use secret_storage::Signer; +use serde_json::json; +use std::collections::HashMap; + +async fn create_did_document( + client: &IdentityClient, + storage: &MemStorage, + alg_id: CompositeAlgId, +) -> anyhow::Result<(IotaDocument, String)> +where + S: Signer + Sync, +{ + let network_name = client.network_name(); + + // Create a new DID document with a placeholder DID. + let mut document = IotaDocument::new(&network_name); + + // New Verification Method containing a PQC key + let fragment = document + .generate_method_hybrid(storage, alg_id, None, MethodScope::VerificationMethod) + .await?; + + let identity = client + .create_identity(document) + .finish() + .build_and_execute(client) + .await? + .output; + let did_document = identity.into(); + println!("Published DID document: {did_document:#}"); + + Ok((did_document, fragment)) +} + +/// Demonstrates how to create a DID Document and publish it in a new Alias Output. +/// +/// In this example we connect to a locally running private network, but it can be adapted +/// to run on any IOTA node by setting the network and faucet endpoints. +/// +/// See the following instructions on running your own private network +/// https://github.com/iotaledger/hornet/tree/develop/private_tangle +#[tokio::main] +async fn main() -> anyhow::Result<()> { + let issuer_storage = get_memstorage()?; + let issuer_client = get_funded_client(&issuer_storage).await?; + + let (issuer_document, issuer_fragment) = + create_did_document(&issuer_client, &issuer_storage, CompositeAlgId::IdMldsa44Ed25519).await?; + + let holder_storage = get_memstorage()?; + let holder_client = get_funded_client(&holder_storage).await?; + let (holder_document, holder_fragment) = + create_did_document(&holder_client, &holder_storage, CompositeAlgId::IdMldsa44Ed25519).await?; + + // Create a credential subject indicating the degree earned by Alice. + let subject: Subject = Subject::from_json_value(json!({ + "id": holder_document.id().as_str(), + "name": "Alice", + "degree": { + "type": "BachelorDegree", + "name": "Bachelor of Science and Arts", + }, + "GPA": "4.0", + }))?; + + // Build credential using subject above and issuer. + let credential: Credential = CredentialBuilder::default() + .id(Url::parse("https://example.edu/credentials/3732")?) + .issuer(Url::parse(issuer_document.id().as_str())?) + .type_("UniversityDegreeCredential") + .subject(subject) + .build()?; + + let credential_jwt: Jwt = issuer_document + .create_credential_jwt_hybrid( + &credential, + &issuer_storage, + &issuer_fragment, + &JwsSignatureOptions::default(), + None, + ) + .await?; + + println!("Credential JWT: {}", credential_jwt.as_str()); + + // Before sending this credential to the holder the issuer wants to validate that some properties + // of the credential satisfy their expectations. + + // Validate the credential's signature using the issuer's DID Document, the credential's semantic structure, + // that the issuance date is not in the future and that the expiration date is not in the past: + let decoded_credential: DecodedJwtCredential = + JwtCredentialValidatorHybrid::with_signature_verifiers(EdDSAJwsVerifier::default(), PQCJwsVerifier::default()) + .validate::<_, Object>( + &credential_jwt, + &issuer_document, + &JwtCredentialValidationOptions::default(), + FailFast::FirstError, + ) + .unwrap(); + + println!("VC successfully validated"); + + println!("Credential JSON > {:#}", decoded_credential.credential); + + // =========================================================================== + // Step 4: Verifier sends the holder a challenge and requests a signed Verifiable Presentation. + // =========================================================================== + + // A unique random challenge generated by the requester per presentation can mitigate replay attacks. + let challenge: &str = "475a7984-1bb5-4c4c-a56f-822bccd46440"; + + // The verifier and holder also agree that the signature should have an expiry date + // 10 minutes from now. + let expires: Timestamp = Timestamp::now_utc().checked_add(Duration::minutes(10)).unwrap(); + + // =========================================================================== + // Step 5: Holder creates and signs a verifiable presentation from the issued credential. + // =========================================================================== + + // Create an unsigned Presentation from the previously issued Verifiable Credential. + let presentation: Presentation = + PresentationBuilder::new(holder_document.id().to_url().into(), Default::default()) + .credential(credential_jwt) + .build()?; + + // Create a JWT verifiable presentation using the holder's verification method + // and include the requested challenge and expiry timestamp. + let presentation_jwt: Jwt = holder_document + .create_presentation_jwt_hybrid( + &presentation, + &holder_storage, + &holder_fragment, + &JwsSignatureOptions::default().nonce(challenge.to_owned()), + &JwtPresentationOptions::default().expiration_date(expires), + ) + .await?; + + // =========================================================================== + // Step 6: Holder sends a verifiable presentation to the verifier. + // =========================================================================== + println!( + "Sending presentation (as JWT) to the verifier: {}", + presentation_jwt.as_str() + ); + + // =========================================================================== + // Step 7: Verifier receives the Verifiable Presentation and verifies it. + // =========================================================================== + + // The verifier wants the following requirements to be satisfied: + // - JWT verification of the presentation (including checking the requested challenge to mitigate replay attacks) + // - JWT verification of the credentials. + // - The presentation holder must always be the subject, regardless of the presence of the nonTransferable property + // - The issuance date must not be in the future. + + let presentation_verifier_options: JwsVerificationOptions = + JwsVerificationOptions::default().nonce(challenge.to_owned()); + + let mut resolver: Resolver = Resolver::new(); + resolver.attach_iota_handler((*issuer_client).clone()); + + // Resolve the holder's document. + let holder_did: CoreDID = JwtPresentationValidatorUtils::extract_holder(&presentation_jwt)?; + let holder: IotaDocument = resolver.resolve(&holder_did).await?; + + // Validate presentation. Note that this doesn't validate the included credentials. + let presentation_validation_options = + JwtPresentationValidationOptions::default().presentation_verifier_options(presentation_verifier_options); + let presentation: DecodedJwtPresentation = + JwtPresentationValidatorHybrid::with_signature_verifiers(EdDSAJwsVerifier::default(), PQCJwsVerifier::default()) + .validate(&presentation_jwt, &holder, &presentation_validation_options)?; + + // Concurrently resolve the issuers' documents. + let jwt_credentials: &Vec = &presentation.presentation.verifiable_credential; + let issuers: Vec = jwt_credentials + .iter() + .map(JwtCredentialValidatorUtils::extract_issuer_from_jwt) + .collect::, _>>()?; + let issuers_documents: HashMap = resolver.resolve_multiple(&issuers).await?; + + // Validate the credentials in the presentation. + let credential_validator = + JwtCredentialValidatorHybrid::with_signature_verifiers(EdDSAJwsVerifier::default(), PQCJwsVerifier::default()); + let validation_options: JwtCredentialValidationOptions = JwtCredentialValidationOptions::default() + .subject_holder_relationship(holder_did.to_url().into(), SubjectHolderRelationship::AlwaysSubject); + + for (index, jwt_vc) in jwt_credentials.iter().enumerate() { + // SAFETY: Indexing should be fine since we extracted the DID from each credential and resolved it. + let issuer_document: &IotaDocument = &issuers_documents[&issuers[index]]; + + let _decoded_credential: DecodedJwtCredential = credential_validator + .validate::<_, Object>(jwt_vc, issuer_document, &validation_options, FailFast::FirstError) + .unwrap(); + } + + // Since no errors were thrown by `verify_presentation` we know that the validation was successful. + println!("VP successfully validated: {:#?}", presentation.presentation); + + // Note that we did not declare a latest allowed issuance date for credentials. This is because we only want to check + // that the credentials do not have an issuance date in the future which is a default check. + + Ok(()) +} diff --git a/examples/1_advanced/pq.rs b/examples/1_advanced/pq.rs new file mode 100644 index 0000000000..c36746768a --- /dev/null +++ b/examples/1_advanced/pq.rs @@ -0,0 +1,258 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use std::collections::HashMap; + +use examples::get_funded_client; +use examples::get_memstorage; +use examples::MemStorage; +use identity_iota::core::Duration; +use identity_iota::core::FromJson; +use identity_iota::core::Object; +use identity_iota::core::Timestamp; +use identity_iota::core::Url; +use identity_iota::credential::Credential; +use identity_iota::credential::CredentialBuilder; +use identity_iota::credential::DecodedJwtCredential; +use identity_iota::credential::DecodedJwtPresentation; +use identity_iota::credential::FailFast; +use identity_iota::credential::Jwt; +use identity_iota::credential::JwtCredentialValidationOptions; +use identity_iota::credential::JwtCredentialValidator; +use identity_iota::credential::JwtCredentialValidatorUtils; +use identity_iota::credential::JwtPresentationOptions; +use identity_iota::credential::JwtPresentationValidationOptions; +use identity_iota::credential::JwtPresentationValidator; +use identity_iota::credential::JwtPresentationValidatorUtils; +use identity_iota::credential::Presentation; +use identity_iota::credential::PresentationBuilder; +use identity_iota::credential::Subject; +use identity_iota::credential::SubjectHolderRelationship; +use identity_iota::did::CoreDID; +use identity_iota::did::DID; +use identity_iota::document::verifiable::JwsVerificationOptions; +use identity_iota::iota::rebased::client::IdentityClient; +use identity_iota::iota::IotaDocument; +use identity_iota::iota_interaction::IotaKeySignature; +use identity_iota::resolver::Resolver; +use identity_iota::storage::JwsDocumentExtPQC; +use identity_iota::storage::JwsSignatureOptions; +use identity_iota::verification::jws::JwsAlgorithm; +use identity_iota::verification::MethodScope; +use identity_pqc_verifier::PQCJwsVerifier; +use identity_storage::JwkMemStore; +use identity_storage::KeyType; +use product_common::core_client::CoreClientReadOnly as _; +use secret_storage::Signer; +use serde_json::json; + +async fn create_did_document( + client: &IdentityClient, + storage: &MemStorage, + key_type: KeyType, + alg: JwsAlgorithm, +) -> anyhow::Result<(IotaDocument, String)> +where + S: Signer + Sync, +{ + // Create a new DID document with a placeholder DID. + let mut document: IotaDocument = IotaDocument::new(client.network_name()); + + // New Verification Method containing a PQC key + let fragment = document + .generate_method_pqc(storage, key_type, alg, None, MethodScope::VerificationMethod) + .await?; + + // Create an Identity wrapping the DID document. + let identity = client + .create_identity(document) + .finish() + .build_and_execute(client) + .await? + .output; + Ok((identity.into(), fragment)) +} + +/// Demonstrates how to create a Post-Quantum Verifiable Credential. +#[tokio::main] +async fn main() -> anyhow::Result<()> { + // =========================================================================== + // Step 1: Create an identity for the issuer. + // =========================================================================== + + // Create a new client to interact with the IOTA ledger. + let issuer_storage = get_memstorage()?; + let issuer_client = get_funded_client(&issuer_storage).await?; + + let (issuer_document, issuer_fragment) = create_did_document( + &issuer_client, + &issuer_storage, + JwkMemStore::PQ_KEY_TYPE, + JwsAlgorithm::ML_DSA_87, + ) + .await?; + + let holder_storage = get_memstorage()?; + let holder_client = get_funded_client(&holder_storage).await?; + let (holder_document, holder_fragment) = create_did_document( + &holder_client, + &holder_storage, + JwkMemStore::PQ_KEY_TYPE, + JwsAlgorithm::ML_DSA_87, + ) + .await?; + + // ====================================================================================== + // Step 2: Issuer creates and signs a Verifiable Credential with a Post-Quantum algorithm. + // ====================================================================================== + + // Create a credential subject indicating the degree earned by Alice. + let subject: Subject = Subject::from_json_value(json!({ + "id": holder_document.id().as_str(), + "name": "Alice", + "degree": { + "type": "BachelorDegree", + "name": "Bachelor of Science and Arts", + }, + "GPA": "4.0", + }))?; + + // Build credential using subject above and issuer. + let credential: Credential = CredentialBuilder::default() + .id(Url::parse("https://example.edu/credentials/3732")?) + .issuer(Url::parse(issuer_document.id().as_str())?) + .type_("UniversityDegreeCredential") + .subject(subject) + .build()?; + + let credential_jwt: Jwt = issuer_document + .create_credential_jwt_pqc( + &credential, + &issuer_storage, + &issuer_fragment, + &JwsSignatureOptions::default(), + None, + ) + .await?; + + // Before sending this credential to the holder the issuer wants to validate that some properties + // of the credential satisfy their expectations. + + JwtCredentialValidator::with_signature_verifier(PQCJwsVerifier::default()) + .validate::<_, Object>( + &credential_jwt, + &issuer_document, + &JwtCredentialValidationOptions::default(), + FailFast::FirstError, + ) + .unwrap(); + + println!("VC successfully validated"); + + // =========================================================================== + // Step 3: Issuer sends the Verifiable Credential to the holder. + // =========================================================================== + println!( + "Sending credential (as JWT) to the holder: {}\n", + credential_jwt.as_str() + ); + + // =========================================================================== + // Step 4: Verifier sends the holder a challenge and requests a signed Verifiable Presentation. + // =========================================================================== + + // A unique random challenge generated by the requester per presentation can mitigate replay attacks. + let challenge: &str = "475a7984-1bb5-4c4c-a56f-822bccd46440"; + + // The verifier and holder also agree that the signature should have an expiry date + // 10 minutes from now. + let expires: Timestamp = Timestamp::now_utc().checked_add(Duration::minutes(10)).unwrap(); + + // =========================================================================== + // Step 5: Holder creates and signs a verifiable presentation from the issued credential. + // =========================================================================== + + // Create an unsigned Presentation from the previously issued Verifiable Credential. + let presentation: Presentation = + PresentationBuilder::new(holder_document.id().to_url().into(), Default::default()) + .credential(credential_jwt) + .build()?; + + // Create a JWT verifiable presentation using the holder's verification method + // and include the requested challenge and expiry timestamp. + let presentation_jwt: Jwt = holder_document + .create_presentation_jwt_pqc( + &presentation, + &holder_storage, + &holder_fragment, + &JwsSignatureOptions::default().nonce(challenge.to_owned()), + &JwtPresentationOptions::default().expiration_date(expires), + ) + .await?; + + // =========================================================================== + // Step 6: Holder sends a verifiable presentation to the verifier. + // =========================================================================== + println!( + "Sending presentation (as JWT) to the verifier: {}\n", + presentation_jwt.as_str() + ); + + // =========================================================================== + // Step 7: Verifier receives the Verifiable Presentation and verifies it. + // =========================================================================== + + // The verifier wants the following requirements to be satisfied: + // - JWT verification of the presentation (including checking the requested challenge to mitigate replay attacks) + // - JWT verification of the credentials. + // - The presentation holder must always be the subject, regardless of the presence of the nonTransferable property + // - The issuance date must not be in the future. + + let presentation_verifier_options: JwsVerificationOptions = + JwsVerificationOptions::default().nonce(challenge.to_owned()); + + let mut resolver: Resolver = Resolver::new(); + resolver.attach_iota_handler((*issuer_client).clone()); + + // Resolve the holder's document. + let holder_did: CoreDID = JwtPresentationValidatorUtils::extract_holder(&presentation_jwt)?; + let holder: IotaDocument = resolver.resolve(&holder_did).await?; + + // Validate presentation. Note that this doesn't validate the included credentials. + let presentation_validation_options = + JwtPresentationValidationOptions::default().presentation_verifier_options(presentation_verifier_options); + let presentation: DecodedJwtPresentation = JwtPresentationValidator::with_signature_verifier( + PQCJwsVerifier::default(), + ) + .validate(&presentation_jwt, &holder, &presentation_validation_options)?; + + // Concurrently resolve the issuers' documents. + let jwt_credentials: &Vec = &presentation.presentation.verifiable_credential; + let issuers: Vec = jwt_credentials + .iter() + .map(JwtCredentialValidatorUtils::extract_issuer_from_jwt) + .collect::, _>>()?; + let issuers_documents: HashMap = resolver.resolve_multiple(&issuers).await?; + + // Validate the credentials in the presentation. + let credential_validator: JwtCredentialValidator = + JwtCredentialValidator::with_signature_verifier(PQCJwsVerifier::default()); + let validation_options: JwtCredentialValidationOptions = JwtCredentialValidationOptions::default() + .subject_holder_relationship(holder_did.to_url().into(), SubjectHolderRelationship::AlwaysSubject); + + println!("--------------------------"); + + for (index, jwt_vc) in jwt_credentials.iter().enumerate() { + // SAFETY: Indexing should be fine since we extracted the DID from each credential and resolved it. + let issuer_document: &IotaDocument = &issuers_documents[&issuers[index]]; + + let _decoded_credential: DecodedJwtCredential = credential_validator + .validate::<_, Object>(jwt_vc, issuer_document, &validation_options, FailFast::FirstError) + .unwrap(); + } + + // Since no errors were thrown by `verify_presentation` we know that the validation was successful. + println!("VP successfully validated: {:#?}", presentation.presentation); + + Ok(()) +} diff --git a/examples/Cargo.toml b/examples/Cargo.toml index 2421af20c0..71183e1b07 100644 --- a/examples/Cargo.toml +++ b/examples/Cargo.toml @@ -8,12 +8,15 @@ publish = false [dependencies] anyhow = "1.0.62" identity_eddsa_verifier = { path = "../identity_eddsa_verifier", default-features = false, features = ["ed25519"] } +identity_pqc_verifier = { path = "../identity_pqc_verifier", default-features = true } identity_storage = { path = "../identity_storage" } identity_stronghold = { path = "../identity_stronghold", default-features = false, features = ["send-sync-storage"] } -iota-sdk = { git = "https://github.com/iotaledger/iota.git", package = "iota-sdk", tag = "v1.4.1" } +iota-caip = { git = "https://github.com/iotaledger/iota-caip.git", features = ["iota", "resolver"] } +iota-sdk = { git = "https://github.com/iotaledger/iota.git", package = "iota-sdk", tag = "v1.7.0" } iota-sdk-legacy = { package = "iota-sdk", version = "1.0", default-features = false, features = ["tls", "client", "stronghold"] } json-proof-token.workspace = true -product_common = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "product_common", features = ["core-client", "transaction"] } +notarization = { git = "https://github.com/iotaledger/notarization.git", tag = "v0.1.7", features = ["irl"] } +product_common = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "product_common", features = ["core-client", "transaction"] } rand = "0.8.5" sd-jwt-payload = { version = "0.2.1", default-features = false, features = ["sha"] } secret-storage = { git = "https://github.com/iotaledger/secret-storage.git", tag = "v0.3.0" } @@ -34,8 +37,10 @@ features = [ "sd-jwt", "status-list-2021", "keytool", + "hybrid-liboqs", "gas-station", "default-http-client", + "irl", ] [lib] @@ -113,6 +118,14 @@ name = "10_zkp_revocation" path = "1_advanced/11_linked_verifiable_presentation.rs" name = "11_linked_verifiable_presentation" +[[example]] +path = "1_advanced/pq.rs" +name = "pq" + +[[example]] +path = "1_advanced/hybrid.rs" +name = "hybrid" + [[example]] path = "1_advanced/12_advanced_transactions.rs" name = "12_advanced_transactions" diff --git a/examples/README.md b/examples/README.md index 5f296de75c..49b5f8dcfe 100644 --- a/examples/README.md +++ b/examples/README.md @@ -1,4 +1,4 @@ -![banner](https://github.com/iotaledger/identity/raw/HEAD/.github/banner_identity.svg) +![banner](https://github.com/iotaledger/identity/raw/HEAD/.github/banner_identity.png) ## IOTA Identity Examples @@ -71,4 +71,6 @@ The following advanced examples are available: | [8_status_list_2021](./1_advanced/8_status_list_2021.rs) | Demonstrates how to revoke a credential using `StatusList2021`. | | [9_zkp](./1_advanced/9_zkp.rs) | Demonstrates how to create an Anonymous Credential with BBS+. | | [10_zkp_revocation](./1_advanced/10_zkp_revocation.rs) | Demonstrates how to revoke a credential. | -| [11_linked_verifiable_presentation](./1_advanced/11_linked_verifiable_presentation.rs) | Demonstrates how to link a public Verifiable Presentation to an identity and how it can be verified. | \ No newline at end of file +| [11_linked_verifiable_presentation](./1_advanced/11_linked_verifiable_presentation.rs) | Demonstrates how to link a public Verifiable Presentation to an identity and how it can be verified. | +| [12_pq](./1_advanced/12_pq.rs) | Demonstrates how to generate, present and verify a VC with pure PQ signature. | +| [13_hybrid](./1_advanced/13_hybrid.rs) | Demonstrates how to generate, present and verify a VC with PQ/T hybrid signature. | diff --git a/examples/utils/utils.rs b/examples/utils/utils.rs index d845fdc1a4..735ef199d7 100644 --- a/examples/utils/utils.rs +++ b/examples/utils/utils.rs @@ -23,10 +23,13 @@ use identity_storage::KeyType; use identity_storage::StorageSigner; use identity_stronghold::StrongholdStorage; use iota_sdk::types::base_types::IotaAddress; +use iota_sdk::IotaClient; use iota_sdk::IotaClientBuilder; use iota_sdk::IOTA_LOCAL_NETWORK_URL; use iota_sdk_legacy::client::secret::stronghold::StrongholdSecretManager; use iota_sdk_legacy::client::Password; +use notarization::NotarizationClient; +use notarization::NotarizationClientReadOnly; use rand::distributions::DistString; use secret_storage::Signer; use serde_json::Value; @@ -75,12 +78,20 @@ pub fn random_stronghold_path() -> PathBuf { file.to_owned() } -pub async fn get_read_only_client() -> anyhow::Result { +pub fn get_iota_endpoint() -> String { + std::env::var("API_ENDPOINT").unwrap_or_else(|_| IOTA_LOCAL_NETWORK_URL.to_string()) +} + +pub async fn get_iota_client() -> anyhow::Result { let api_endpoint = std::env::var("API_ENDPOINT").unwrap_or_else(|_| IOTA_LOCAL_NETWORK_URL.to_string()); - let iota_client = IotaClientBuilder::default() + IotaClientBuilder::default() .build(&api_endpoint) .await - .map_err(|err| anyhow::anyhow!(format!("failed to connect to network; {}", err)))?; + .map_err(|err| anyhow::anyhow!(format!("failed to connect to network; {}", err))) +} + +pub async fn get_read_only_client() -> anyhow::Result { + let iota_client = get_iota_client().await?; let package_id = std::env::var("IOTA_IDENTITY_PKG_ID") .map_err(|e| { anyhow::anyhow!("env variable IOTA_IDENTITY_PKG_ID must be set in order to run the examples").context(e) @@ -116,6 +127,23 @@ where Ok(identity_client) } +pub async fn get_notarization_client( + signer: StorageSigner<'_, K, I>, +) -> anyhow::Result>> +where + K: JwkStorage, + I: KeyIdStorage, +{ + let package_id = std::env::var("IOTA_NOTARIZATION_PKG_ID") + .map_err(|e| { + anyhow::anyhow!("env variable IOTA_NOTARIZATION_PKG_ID must be set in order to run this example").context(e) + }) + .and_then(|pkg_str| pkg_str.parse().context("invalid package id"))?; + let read_only_client = NotarizationClientReadOnly::new_with_pkg_id(get_iota_client().await?, package_id).await?; + let client = NotarizationClient::new(read_only_client, signer).await?; + Ok(client) +} + pub fn get_memstorage() -> Result { Ok(MemStorage::new(JwkMemStore::new(), KeyIdMemstore::new())) } diff --git a/identity_core/Cargo.toml b/identity_core/Cargo.toml index c51514c051..3ce272b8f5 100644 --- a/identity_core/Cargo.toml +++ b/identity_core/Cargo.toml @@ -14,6 +14,7 @@ description = "The core traits and types for the identity-rs library." # pin dependency of `time` and limit range, as `0.4.1` has impl for `usize: PartialOrd<_>` # that conflicts with `iota-sdk`s `core` impl, leading to errors in `iota-sdk` crate deranged = { version = ">=0.4.0, <0.4.1", default-features = false } +iota-caip = { git = "https://github.com/iotaledger/iota-caip.git", optional = true, default-features = false, features = ["iota", "resolver"] } multibase = { version = "0.9", default-features = false, features = ["std"] } product_common.workspace = true serde = { workspace = true, features = ["std"] } @@ -44,6 +45,8 @@ workspace = true default = ["dep:js-sys"] # Enables a macro to provide a custom time (Timestamp::now_utc) implementation, see src/custom_time.rs custom_time = [] +# Enables the integration with IOTA Resource Locators (IRLs). +irl = ["dep:iota-caip"] [[test]] name = "custom_time" diff --git a/identity_core/src/common/url.rs b/identity_core/src/common/url.rs index 57937c80e7..72bb429574 100644 --- a/identity_core/src/common/url.rs +++ b/identity_core/src/common/url.rs @@ -102,3 +102,15 @@ impl AsRef for Url { self.as_str() } } + +#[cfg(feature = "irl")] +mod irl_integraton { + use super::Url; + + use iota_caip::iota::IotaResourceLocator as Irl; + impl From for Url { + fn from(irl: Irl) -> Self { + Url::parse(irl.as_str()).expect("an IOTA Resource Locator is always a valid URL") + } + } +} diff --git a/identity_credential/Cargo.toml b/identity_credential/Cargo.toml index db5a531c1e..79051e10c4 100644 --- a/identity_credential/Cargo.toml +++ b/identity_credential/Cargo.toml @@ -28,7 +28,7 @@ once_cell = { version = "1.18", default-features = false, features = ["std"] } reqwest = { version = "0.11", default-features = false, features = ["default-tls", "json", "stream"], optional = true } roaring = { version = "0.10.2", default-features = false, features = ["serde"], optional = true } sd-jwt-payload = { version = "0.2.1", default-features = false, features = ["sha"], optional = true } -sd-jwt-payload-rework = { package = "sd-jwt-payload", version = "0.3", features = ["sha"], optional = true } +sd-jwt-payload-rework = { package = "sd-jwt-payload", version = "0.4", features = ["sha"], optional = true } serde.workspace = true serde-aux = { version = "4.3.1", default-features = false } serde_json.workspace = true @@ -79,6 +79,6 @@ jpt-bbs-plus = [ "dep:json-proof-token", "dep:futures", ] - +hybrid = ["credential", "validator"] [lints] workspace = true diff --git a/identity_credential/src/credential/linked_verifiable_presentation_service.rs b/identity_credential/src/credential/linked_verifiable_presentation_service.rs index 20e34e0a97..1dedbc8789 100644 --- a/identity_credential/src/credential/linked_verifiable_presentation_service.rs +++ b/identity_credential/src/credential/linked_verifiable_presentation_service.rs @@ -44,10 +44,10 @@ impl LinkedVerifiablePresentationService { /// [Linked Verifiable Presentation Service Endpoint](https://identity.foundation/linked-vp/#linked-verifiable-presentation-service-endpoint). pub fn new( did_url: DIDUrl, - verifiable_presentation_urls: impl Into>, + verifiable_presentation_urls: impl IntoIterator, properties: Object, ) -> Result { - let verifiable_presentation_urls: OrderedSet = verifiable_presentation_urls.into(); + let verifiable_presentation_urls: OrderedSet = verifiable_presentation_urls.into_iter().collect(); let builder: ServiceBuilder = Service::builder(properties) .id(did_url) .type_(Self::linked_verifiable_presentation_service_type()); diff --git a/identity_credential/src/revocation/status_list_2021/status_list.rs b/identity_credential/src/revocation/status_list_2021/status_list.rs index 7ea4a0479b..97b72290c3 100644 --- a/identity_credential/src/revocation/status_list_2021/status_list.rs +++ b/identity_credential/src/revocation/status_list_2021/status_list.rs @@ -46,7 +46,7 @@ impl StatusList2021 { return Err(StatusListError::InvalidListSize); } - let size = num_entries / 8 + (num_entries % 8 != 0) as usize; + let size = num_entries / 8 + (!num_entries.is_multiple_of(8) as usize); let store = vec![0; size]; Ok(StatusList2021(store.into_boxed_slice())) diff --git a/identity_credential/src/sd_jwt_vc/presentation.rs b/identity_credential/src/sd_jwt_vc/presentation.rs index 06a2d2feac..fcaa012efb 100644 --- a/identity_credential/src/sd_jwt_vc/presentation.rs +++ b/identity_credential/src/sd_jwt_vc/presentation.rs @@ -23,9 +23,13 @@ impl SdJwtVcPresentationBuilder { /// Prepare a presentation for a given [`SdJwtVc`]. pub fn new(token: SdJwtVc, hasher: &dyn Hasher) -> Result { let SdJwtVc { - sd_jwt, - parsed_claims: vc_claims, + mut sd_jwt, + parsed_claims: mut vc_claims, } = token; + // Make sure to set the parsed claims back into the SD-JWT Token. + // The reason we do this is to make sure that the underlying SdJwtPresetationBuilder + // that operates on the wrapped SdJwt token can handle the claims. + std::mem::swap(sd_jwt.claims_mut(), &mut vc_claims.sd_jwt_claims); let builder = sd_jwt.into_presentation(hasher).map_err(Error::SdJwt)?; Ok(Self { vc_claims, builder }) @@ -40,6 +44,26 @@ impl SdJwtVcPresentationBuilder { Ok(self) } + /// Removes all disclosures from this SD-JWT, resulting in a token that, + /// when presented, will have *all* selectively-disclosable properties + /// omitted. + pub fn conceal_all(mut self) -> Self { + self.builder = self.builder.conceal_all(); + self + } + + /// Discloses a value that was previously concealed. + /// # Notes + /// - This method may disclose multiple values, if the given path references a disclosable value stored within another + /// disclosable value. That is, [disclose](Self::disclose) will unconceal the selectively disclosable value at + /// `path` together with *all* its parents that are disclosable values themselves. + /// - By default *all* disclosable claims are disclosed, therefore this method can only be used to *undo* any + /// concealment operations previously performed by either [Self::conceal] or [Self::conceal_all]. + pub fn disclose(mut self, path: &str) -> Result { + self.builder = self.builder.disclose(path).map_err(Error::SdJwt)?; + Ok(self) + } + /// Adds a [`KeyBindingJwt`] to this [`SdJwtVc`]'s presentation. pub fn attach_key_binding_jwt(mut self, kb_jwt: KeyBindingJwt) -> Self { self.builder = self.builder.attach_key_binding_jwt(kb_jwt); @@ -47,8 +71,11 @@ impl SdJwtVcPresentationBuilder { } /// Returns the resulting [`SdJwtVc`] together with all removed disclosures. - pub fn finish(self) -> Result<(SdJwtVc, Vec)> { - let (sd_jwt, disclosures) = self.builder.finish()?; + pub fn finish(mut self) -> Result<(SdJwtVc, Vec)> { + let (mut sd_jwt, disclosures) = self.builder.finish()?; + // Move the token's claim back into parsed VC claims. + std::mem::swap(sd_jwt.claims_mut(), &mut self.vc_claims.sd_jwt_claims); + Ok((SdJwtVc::new(sd_jwt, self.vc_claims), disclosures)) } } diff --git a/identity_credential/src/sd_jwt_vc/tests/mod.rs b/identity_credential/src/sd_jwt_vc/tests/mod.rs index f93fe20784..989a2b3651 100644 --- a/identity_credential/src/sd_jwt_vc/tests/mod.rs +++ b/identity_credential/src/sd_jwt_vc/tests/mod.rs @@ -21,6 +21,7 @@ use serde_json::Value; use super::resolver; use super::Resolver; +mod presentation; mod validation; pub(crate) const ISSUER_SECRET: &[u8] = b"0123456789ABCDEF0123456789ABCDEF"; diff --git a/identity_credential/src/sd_jwt_vc/tests/presentation.rs b/identity_credential/src/sd_jwt_vc/tests/presentation.rs new file mode 100644 index 0000000000..5ab98f8732 --- /dev/null +++ b/identity_credential/src/sd_jwt_vc/tests/presentation.rs @@ -0,0 +1,48 @@ +// Copyright 2020-2024 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +use identity_core::common::Timestamp; +use identity_core::common::Url; +use sd_jwt_payload_rework::Sha256Hasher; +use serde_json::json; + +use crate::sd_jwt_vc::tests::TestSigner; +use crate::sd_jwt_vc::SdJwtVcBuilder; + +#[tokio::test] +async fn test_sd_jwt_presentation_builder() -> anyhow::Result<()> { + let credential = SdJwtVcBuilder::new(json!({ + "name": "John Doe", + "address": { + "street_address": "A random street", + "number": "3a" + }, + "degree": [] + }))? + .header(std::iter::once(("kid".to_string(), serde_json::Value::String("key1".to_string()))).collect()) + .vct("https://example.com/education_credential".parse::()?) + .iat(Timestamp::now_utc()) + .iss("https://example.com".parse()?) + .make_concealable("/address/street_address")? + .make_concealable("/address")? + .finish(&TestSigner, "HS256") + .await?; + + let (concealed_address_credential, conceiled_disclosures) = credential + .into_presentation(&Sha256Hasher::new())? + .conceal("/address")? + .finish()?; + + // Object "address" has been omitted from the credential. + assert!(!concealed_address_credential.claims().contains_key("address")); + // Concealable "address" and its sub-property "street_address" have both been concealed. + assert_eq!( + conceiled_disclosures + .iter() + .map(|disclosure| disclosure.claim_name.as_deref().unwrap()) + .collect::>(), + vec!["street_address", "address"] + ); + + Ok(()) +} diff --git a/identity_credential/src/validator/jwt_credential_validation/jwt_credential_validator_hybrid.rs b/identity_credential/src/validator/jwt_credential_validation/jwt_credential_validator_hybrid.rs new file mode 100644 index 0000000000..328a0d3e8c --- /dev/null +++ b/identity_credential/src/validator/jwt_credential_validation/jwt_credential_validator_hybrid.rs @@ -0,0 +1,266 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use identity_core::convert::FromJson; +use identity_did::CoreDID; +use identity_did::DIDUrl; +use identity_document::document::CoreDocument; +use identity_document::verifiable::JwsVerificationOptions; +use identity_verification::jwk::CompositeJwk; +use identity_verification::jwk::PostQuantumJwk; +use identity_verification::jwk::TraditionalJwk; +use identity_verification::jws::DecodedJws; +use identity_verification::jws::JwsValidationItem; +use identity_verification::jws::JwsVerifier; + +use super::CompoundCredentialValidationError; +use super::DecodedJwtCredential; +use super::JwtCredentialValidationOptions; +use super::JwtCredentialValidatorUtils; +use super::JwtValidationError; +use super::SignerContext; +use crate::credential::Credential; +use crate::credential::CredentialJwtClaims; +use crate::credential::Jwt; +use crate::validator::FailFast; +use crate::validator::JwtCredentialValidator; + +/// A type for decoding and validating [`Credential`]s signed with a PQ/T signature. +pub struct JwtCredentialValidatorHybrid(TRV, PQV); + +impl JwtCredentialValidatorHybrid { + /// Create a new [`JwtCredentialValidatorHybrid`] that delegates cryptographic signature verification to the given + /// traditional [`JwsVerifier`] and PQ [`JwsVerifier`]. + pub fn with_signature_verifiers(traditional_signature_verifier: TRV, pq_signature_verifier: PQV) -> Self { + Self(traditional_signature_verifier, pq_signature_verifier) + } + + /// Decodes and validates a [`Credential`] issued as a JWT. A [`DecodedJwtCredential`] is returned upon success. + /// + /// The following properties are validated according to `options`: + /// - the issuer's PQ/T signature on the JWS, + /// - the expiration date, + /// - the issuance date, + /// - the semantic structure. + /// + /// # Warning + /// The lack of an error returned from this method is in of itself not enough to conclude that the credential can be + /// trusted. This section contains more information on additional checks that should be carried out before and after + /// calling this method. + /// + /// ## The state of the issuer's DID Document + /// The caller must ensure that `issuer` represents an up-to-date DID Document. + /// + /// ## Properties that are not validated + /// There are many properties defined in [The Verifiable Credentials Data Model](https://www.w3.org/TR/vc-data-model/) that are **not** validated, such as: + /// `proof`, `credentialStatus`, `type`, `credentialSchema`, `refreshService` **and more**. + /// These should be manually checked after validation, according to your requirements. + /// + /// # Errors + /// An error is returned whenever a validated condition is not satisfied. + pub fn validate( + &self, + credential_jwt: &Jwt, + issuer: &DOC, + options: &JwtCredentialValidationOptions, + fail_fast: FailFast, + ) -> Result, CompoundCredentialValidationError> + where + T: Clone + serde::Serialize + serde::de::DeserializeOwned, + DOC: AsRef, + { + let credential_token = self + .verify_signature( + credential_jwt, + std::slice::from_ref(issuer.as_ref()), + &options.verification_options, + ) + .map_err(|err| CompoundCredentialValidationError { + validation_errors: [err].into(), + })?; + + JwtCredentialValidator::::validate_decoded_credential( + credential_token, + std::slice::from_ref(issuer.as_ref()), + options, + fail_fast, + ) + } + + /// Decode and verify the PQ/T JWS signature of a [`Credential`] issued as a JWT using the DID Document of a trusted + /// issuer. + /// + /// A [`DecodedJwtCredential`] is returned upon success. + /// + /// # Warning + /// The caller must ensure that the DID Documents of the trusted issuers are up-to-date. + /// + /// ## Proofs + /// Only the PQ/T JWS signature is verified. If the [`Credential`] contains a `proof` property this will not be + /// verified by this method. + /// + /// # Errors + /// This method immediately returns an error if + /// the credential issuer' url cannot be parsed to a DID belonging to one of the trusted issuers. Otherwise an attempt + /// to verify the credential's signature will be made and an error is returned upon failure. + pub fn verify_signature( + &self, + credential: &Jwt, + trusted_issuers: &[DOC], + options: &JwsVerificationOptions, + ) -> Result, JwtValidationError> + where + T: Clone + serde::Serialize + serde::de::DeserializeOwned, + DOC: AsRef, + { + Self::verify_signature_with_verifiers(&self.0, &self.1, credential, trusted_issuers, options) + } + + pub(crate) fn parse_composite_pk<'a, 'i, DOC>( + jws: &JwsValidationItem<'a>, + trusted_issuers: &'i [DOC], + options: &JwsVerificationOptions, + ) -> Result<(&'a CompositeJwk, DIDUrl), JwtValidationError> + where + DOC: AsRef, + 'i: 'a, + { + let nonce: Option<&str> = options.nonce.as_deref(); + // Validate the nonce + if jws.nonce() != nonce { + return Err(JwtValidationError::JwsDecodingError( + identity_verification::jose::error::Error::InvalidParam("invalid nonce value"), + )); + } + + // If no method_url is set, parse the `kid` to a DID Url which should be the identifier + // of a verification method in a trusted issuer's DID document. + let method_id: DIDUrl = + match &options.method_id { + Some(method_id) => method_id.clone(), + None => { + let kid: &str = jws.protected_header().and_then(|header| header.kid()).ok_or( + JwtValidationError::MethodDataLookupError { + source: None, + message: "could not extract kid from protected header", + signer_ctx: SignerContext::Issuer, + }, + )?; + + // Convert kid to DIDUrl + DIDUrl::parse(kid).map_err(|err| JwtValidationError::MethodDataLookupError { + source: Some(err.into()), + message: "could not parse kid as a DID Url", + signer_ctx: SignerContext::Issuer, + })? + } + }; + + // locate the corresponding issuer + let issuer: &CoreDocument = trusted_issuers + .iter() + .map(AsRef::as_ref) + .find(|issuer_doc| ::id(issuer_doc) == method_id.did()) + .ok_or(JwtValidationError::DocumentMismatch(SignerContext::Issuer))?; + + // Obtain the public key from the issuer's DID document + issuer + .resolve_method(&method_id, options.method_scope) + .and_then(|method| method.data().composite_public_key()) + .ok_or_else(|| JwtValidationError::MethodDataLookupError { + source: None, + message: "could not extract CompositePublicKey from a method identified by kid", + signer_ctx: SignerContext::Issuer, + }) + .map(move |c: &CompositeJwk| (c, method_id)) + } + + /// Stateless version of [`Self::verify_signature`]. + fn verify_signature_with_verifiers( + traditional_signature_verifier: &TRV, + pq_signature_verifier: &PQV, + credential: &Jwt, + trusted_issuers: &[DOC], + options: &JwsVerificationOptions, + ) -> Result, JwtValidationError> + where + T: Clone + serde::Serialize + serde::de::DeserializeOwned, + DOC: AsRef, + { + // Note the below steps are necessary because `CoreDocument::verify_jws` decodes the JWS and then searches for a + // method with a fragment (or full DID Url) matching `kid` in the given document. We do not want to carry out + // that process for potentially every document in `trusted_issuers`. + + // Start decoding the credential + let decoded: JwsValidationItem<'_> = JwtCredentialValidator::::decode(credential.as_str())?; + + let (composite, method_id) = Self::parse_composite_pk(&decoded, trusted_issuers, options)?; + + let credential_token = Self::verify_decoded_signature( + decoded, + composite.traditional_public_key(), + composite.pq_public_key(), + traditional_signature_verifier, + pq_signature_verifier, + )?; + + // Check that the DID component of the parsed `kid` does indeed correspond to the issuer in the credential before + // returning. + let issuer_id: CoreDID = JwtCredentialValidatorUtils::extract_issuer(&credential_token.credential)?; + if &issuer_id != method_id.did() { + return Err(JwtValidationError::IdentifierMismatch { + signer_ctx: SignerContext::Issuer, + }); + }; + Ok(credential_token) + } + + pub(crate) fn verify_signature_raw<'a>( + decoded: JwsValidationItem<'a>, + traditional_pk: &TraditionalJwk, + pq_pk: &PostQuantumJwk, + traditional_verifier: &TRV, + pq_verifier: &PQV, + ) -> Result, JwtValidationError> { + decoded + .verify_hybrid(traditional_verifier, pq_verifier, traditional_pk, pq_pk) + .map_err(|err| JwtValidationError::Signature { + source: err, + signer_ctx: SignerContext::Issuer, + }) + } + + /// Verify the signature using the given the `traditional_pk`, `pq_pk`, `traditional_verifier` and `pq_verifier`. + fn verify_decoded_signature( + decoded: JwsValidationItem<'_>, + traditional_pk: &TraditionalJwk, + pq_pk: &PostQuantumJwk, + traditional_verifier: &TRV, + pq_verifier: &PQV, + ) -> Result, JwtValidationError> + where + T: Clone + serde::Serialize + serde::de::DeserializeOwned, + { + // Verify the JWS signature and obtain the decoded token containing the protected header and raw claims + let DecodedJws { protected, claims, .. } = + Self::verify_signature_raw(decoded, traditional_pk, pq_pk, traditional_verifier, pq_verifier)?; + + let credential_claims: CredentialJwtClaims<'_, T> = + CredentialJwtClaims::from_json_slice(&claims).map_err(|err| { + JwtValidationError::CredentialStructure(crate::Error::JwtClaimsSetDeserializationError(err.into())) + })?; + + let custom_claims = credential_claims.custom.clone(); + + // Construct the credential token containing the credential and the protected header. + let credential: Credential = credential_claims + .try_into_credential() + .map_err(JwtValidationError::CredentialStructure)?; + + Ok(DecodedJwtCredential { + credential, + header: Box::new(protected), + custom_claims, + }) + } +} diff --git a/identity_credential/src/validator/jwt_credential_validation/mod.rs b/identity_credential/src/validator/jwt_credential_validation/mod.rs index 25c0d4f494..d42b0e045e 100644 --- a/identity_credential/src/validator/jwt_credential_validation/mod.rs +++ b/identity_credential/src/validator/jwt_credential_validation/mod.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 //! Contains functionality for validating credentials issued as JWTs. @@ -6,10 +6,14 @@ mod decoded_jwt_credential; mod error; mod jwt_credential_validation_options; mod jwt_credential_validator; +#[cfg(feature = "hybrid")] +mod jwt_credential_validator_hybrid; mod jwt_credential_validator_utils; pub use decoded_jwt_credential::*; pub use error::*; pub use jwt_credential_validation_options::*; pub use jwt_credential_validator::*; +#[cfg(feature = "hybrid")] +pub use jwt_credential_validator_hybrid::*; pub use jwt_credential_validator_utils::*; diff --git a/identity_credential/src/validator/jwt_presentation_validation/jwt_presentation_validator_hybrid.rs b/identity_credential/src/validator/jwt_presentation_validation/jwt_presentation_validator_hybrid.rs new file mode 100644 index 0000000000..3d5df7e27a --- /dev/null +++ b/identity_credential/src/validator/jwt_presentation_validation/jwt_presentation_validator_hybrid.rs @@ -0,0 +1,168 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use identity_core::common::Object; +use identity_core::common::Timestamp; +use identity_core::common::Url; +use identity_core::convert::FromJson; +use identity_did::CoreDID; +use identity_document::document::CoreDocument; +use identity_verification::jws::DecodedJws; +use identity_verification::jws::JwsVerifier; +use std::str::FromStr; + +use crate::credential::Jwt; +use crate::presentation::Presentation; +use crate::presentation::PresentationJwtClaims; +use crate::validator::jwt_credential_validation::JwtValidationError; +use crate::validator::jwt_credential_validation::SignerContext; + +use super::CompoundJwtPresentationValidationError; +use super::DecodedJwtPresentation; +use super::JwtPresentationValidationOptions; + +/// Struct for validating [`Presentation`] signed with a PQ/T signature. +#[derive(Debug, Clone)] +#[non_exhaustive] +pub struct JwtPresentationValidatorHybrid(TRV, PQV); + +impl JwtPresentationValidatorHybrid +where + TRV: JwsVerifier, + PQV: JwsVerifier, +{ + /// Creates a new [`JwtPresentationValidatorHybrid`] using a specific traditional [`JwsVerifier`] and a specific PQ + /// [`JwsVerifier`]. + pub fn with_signature_verifiers(traditional_signature_verifier: TRV, pq_signature_verifier: PQV) -> Self { + Self(traditional_signature_verifier, pq_signature_verifier) + } + + /// Validates a [`Presentation`] signed with a PQ/T signature. + /// + /// The following properties are validated according to `options`: + /// - the JWT can be decoded into a semantically valid presentation. + /// - the expiration and issuance date contained in the JWT claims. + /// - the holder's PQ/T signature. + /// + /// Validation is done with respect to the properties set in `options`. + /// + /// # Warning + /// + /// * This method does NOT validate the constituent credentials and therefore also not the relationship between the + /// credentials' subjects and the presentation holder. This can be done with + /// [`JwtCredentialValidationOptions`](crate::validator::JwtCredentialValidationOptions). + /// * The lack of an error returned from this method is in of itself not enough to conclude that the presentation can + /// be trusted. This section contains more information on additional checks that should be carried out before and + /// after calling this method. + /// + /// ## The state of the supplied DID Documents. + /// + /// The caller must ensure that the DID Documents in `holder` and `issuers` are up-to-date. + /// + /// # Errors + /// + /// An error is returned whenever a validated condition is not satisfied or when decoding fails. + pub fn validate( + &self, + presentation: &Jwt, + holder: &HDOC, + options: &JwtPresentationValidationOptions, + ) -> Result, CompoundJwtPresentationValidationError> + where + HDOC: AsRef + ?Sized, + T: Clone + serde::Serialize + serde::de::DeserializeOwned, + CRED: Clone + serde::Serialize + serde::de::DeserializeOwned + Clone, + { + // Verify JWS. + let decoded_jws: DecodedJws<'_> = holder + .as_ref() + .verify_jws_hybrid( + presentation.as_str(), + None, + &self.0, + &self.1, + &options.presentation_verifier_options, + ) + .map_err(|err| { + CompoundJwtPresentationValidationError::one_presentation_error(JwtValidationError::PresentationJwsError(err)) + })?; + + let claims: PresentationJwtClaims<'_, CRED, T> = PresentationJwtClaims::from_json_slice(&decoded_jws.claims) + .map_err(|err| { + CompoundJwtPresentationValidationError::one_presentation_error(JwtValidationError::PresentationStructure( + crate::Error::JwtClaimsSetDeserializationError(err.into()), + )) + })?; + + // Verify that holder document matches holder in presentation. + let holder_did: CoreDID = CoreDID::from_str(claims.iss.as_str()).map_err(|err| { + CompoundJwtPresentationValidationError::one_presentation_error(JwtValidationError::SignerUrl { + signer_ctx: SignerContext::Holder, + source: err.into(), + }) + })?; + + if &holder_did != ::id(holder.as_ref()) { + return Err(CompoundJwtPresentationValidationError::one_presentation_error( + JwtValidationError::DocumentMismatch(SignerContext::Holder), + )); + } + + // Check the expiration date. + let expiration_date: Option = claims + .exp + .map(|exp| { + Timestamp::from_unix(exp).map_err(|err| { + CompoundJwtPresentationValidationError::one_presentation_error(JwtValidationError::PresentationStructure( + crate::Error::JwtClaimsSetDeserializationError(err.into()), + )) + }) + }) + .transpose()?; + + if expiration_date.is_some_and(|exp| exp < options.earliest_expiry_date.unwrap_or_default()) { + return Err(CompoundJwtPresentationValidationError::one_presentation_error( + JwtValidationError::ExpirationDate, + )); + } + // Check issuance date. + let issuance_date: Option = match claims.issuance_date { + Some(iss) => { + if iss.iat.is_some() || iss.nbf.is_some() { + Some(iss.to_issuance_date().map_err(|err| { + CompoundJwtPresentationValidationError::one_presentation_error(JwtValidationError::PresentationStructure( + crate::Error::JwtClaimsSetDeserializationError(err.into()), + )) + })?) + } else { + None + } + } + None => None, + }; + + if issuance_date.is_some_and(|iss| iss > options.latest_issuance_date.unwrap_or_default()) { + return Err(CompoundJwtPresentationValidationError::one_presentation_error( + JwtValidationError::IssuanceDate, + )); + } + + let aud: Option = claims.aud.clone(); + let custom_claims: Option = claims.custom.clone(); + + let presentation: Presentation = claims.try_into_presentation().map_err(|err| { + CompoundJwtPresentationValidationError::one_presentation_error(JwtValidationError::PresentationStructure(err)) + })?; + + let decoded_jwt_presentation: DecodedJwtPresentation = DecodedJwtPresentation { + presentation, + header: Box::new(decoded_jws.protected), + expiration_date, + issuance_date, + aud, + custom_claims, + }; + + Ok(decoded_jwt_presentation) + } +} diff --git a/identity_credential/src/validator/jwt_presentation_validation/mod.rs b/identity_credential/src/validator/jwt_presentation_validation/mod.rs index a9bb144080..4a3afcd572 100644 --- a/identity_credential/src/validator/jwt_presentation_validation/mod.rs +++ b/identity_credential/src/validator/jwt_presentation_validation/mod.rs @@ -1,14 +1,18 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 mod decoded_jwt_presentation; mod error; mod jwt_presentation_validation_options; mod jwt_presentation_validator; +#[cfg(feature = "hybrid")] +mod jwt_presentation_validator_hybrid; mod jwt_presentation_validator_utils; pub use decoded_jwt_presentation::*; pub use error::*; pub use jwt_presentation_validation_options::*; pub use jwt_presentation_validator::*; +#[cfg(feature = "hybrid")] +pub use jwt_presentation_validator_hybrid::*; pub use jwt_presentation_validator_utils::*; diff --git a/identity_did/src/did_compositejwk.rs b/identity_did/src/did_compositejwk.rs new file mode 100644 index 0000000000..54ad7d7e69 --- /dev/null +++ b/identity_did/src/did_compositejwk.rs @@ -0,0 +1,84 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use std::fmt::Debug; +use std::fmt::Display; +use std::str::FromStr; + +use identity_jose::jwk::CompositeJwk; +use identity_jose::jwu::decode_b64_json; + +use crate::CoreDID; +use crate::Error; +use crate::DID; + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Deserialize, serde::Serialize)] +#[repr(transparent)] +#[serde(into = "CoreDID", try_from = "CoreDID")] +/// A type representing a `did:compositejwk` DID. +pub struct DIDCompositeJwk(CoreDID); + +impl DIDCompositeJwk { + /// [`DIDCompositeJwk`]'s method. + pub const METHOD: &'static str = "compositejwk"; + + /// Tries to parse a [`DIDCompositeJwk`] from a string. + pub fn parse(s: &str) -> Result { + s.parse() + } + + /// Returns the JWK encoded inside this did:jwk. + pub fn composite_jwk(&self) -> CompositeJwk { + decode_b64_json(self.method_id()).expect("did:compositejwk encodes a valid compositeJwk") + } +} + +impl AsRef for DIDCompositeJwk { + fn as_ref(&self) -> &CoreDID { + &self.0 + } +} + +impl From for CoreDID { + fn from(value: DIDCompositeJwk) -> Self { + value.0 + } +} + +impl<'a> TryFrom<&'a str> for DIDCompositeJwk { + type Error = Error; + fn try_from(value: &'a str) -> Result { + value.parse() + } +} + +impl Display for DIDCompositeJwk { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.0) + } +} + +impl FromStr for DIDCompositeJwk { + type Err = Error; + fn from_str(s: &str) -> Result { + s.parse::().and_then(TryFrom::try_from) + } +} + +impl From for String { + fn from(value: DIDCompositeJwk) -> Self { + value.to_string() + } +} + +impl TryFrom for DIDCompositeJwk { + type Error = Error; + fn try_from(value: CoreDID) -> Result { + let Self::METHOD = value.method() else { + return Err(Error::InvalidMethodName); + }; + decode_b64_json::(value.method_id()) + .map(|_| Self(value)) + .map_err(|_| Error::InvalidMethodId) + } +} diff --git a/identity_did/src/did_jwk.rs b/identity_did/src/did_jwk.rs index 5ebd61021c..edead3bd01 100644 --- a/identity_did/src/did_jwk.rs +++ b/identity_did/src/did_jwk.rs @@ -3,25 +3,38 @@ use std::fmt::Debug; use std::fmt::Display; +use std::hash::Hash; use std::str::FromStr; use identity_jose::jwk::Jwk; use identity_jose::jwu::decode_b64_json; +use identity_jose::jwu::encode_b64_json; use crate::CoreDID; use crate::Error; use crate::DID; -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Deserialize, serde::Serialize)] -#[repr(transparent)] +#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize)] #[serde(into = "CoreDID", try_from = "CoreDID")] /// A type representing a `did:jwk` DID. -pub struct DIDJwk(CoreDID); +pub struct DIDJwk { + did: CoreDID, + jwk: Jwk, +} impl DIDJwk { /// [`DIDJwk`]'s method. pub const METHOD: &'static str = "jwk"; + /// Creates a new [DIDJwk] from the given [Jwk]. + pub fn new(jwk: impl Into) -> Self { + let jwk = jwk.into(); + let did_str = format!("did:jwk:{}", encode_b64_json(&jwk).expect("valid JSON")); + let did = did_str.parse().expect("valid CoreDID"); + + Self { did, jwk } + } + /// Tries to parse a [`DIDJwk`] from a string. pub fn parse(s: &str) -> Result { s.parse() @@ -29,19 +42,48 @@ impl DIDJwk { /// Returns the JWK encoded inside this did:jwk. pub fn jwk(&self) -> Jwk { - decode_b64_json(self.method_id()).expect("did:jwk encodes a valid JWK") + self.jwk.clone() + } + + /// Returns a reference to the [Jwk] encoded inside this did:jwk. + pub fn as_jwk(&self) -> &Jwk { + &self.jwk + } +} + +impl Ord for DIDJwk { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.did.cmp(&other.did) + } +} + +impl PartialOrd for DIDJwk { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl Hash for DIDJwk { + fn hash(&self, state: &mut H) { + self.did.hash(state) } } impl AsRef for DIDJwk { fn as_ref(&self) -> &CoreDID { - &self.0 + &self.did + } +} + +impl AsRef for DIDJwk { + fn as_ref(&self) -> &Jwk { + &self.jwk } } impl From for CoreDID { fn from(value: DIDJwk) -> Self { - value.0 + value.did } } @@ -54,7 +96,7 @@ impl<'a> TryFrom<&'a str> for DIDJwk { impl Display for DIDJwk { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.0) + write!(f, "{}", self.did) } } @@ -71,14 +113,20 @@ impl From for String { } } +impl From for Jwk { + fn from(value: DIDJwk) -> Self { + value.jwk + } +} + impl TryFrom for DIDJwk { type Error = Error; fn try_from(value: CoreDID) -> Result { let Self::METHOD = value.method() else { return Err(Error::InvalidMethodName); }; - decode_b64_json::(value.method_id()) - .map(|_| Self(value)) + decode_b64_json(value.method_id()) + .map(|jwk| Self { did: value, jwk }) .map_err(|_| Error::InvalidMethodId) } } @@ -108,6 +156,18 @@ mod tests { assert_eq!(did.jwk(), target_jwk); } + #[test] + fn test_new() { + let jwk = Jwk::from_json_value(serde_json::json!({ + "kty":"OKP","crv":"X25519","use":"enc","x":"3p7bfXt9wbTTW2HC7OQ1Nz-DQ8hbeGdNrfx-FG-IK08" + })) + .unwrap(); + let target_did_jwk = DIDJwk::parse(&format!("did:jwk:{}", encode_b64_json(&jwk).unwrap())).unwrap(); + + let did_jwk = DIDJwk::new(jwk); + assert_eq!(target_did_jwk, did_jwk); + } + #[test] fn test_invalid_deserialization() { assert!( diff --git a/identity_did/src/lib.rs b/identity_did/src/lib.rs index 62c846847e..f2aa19a2da 100644 --- a/identity_did/src/lib.rs +++ b/identity_did/src/lib.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 #![forbid(unsafe_code)] @@ -18,6 +18,7 @@ #[allow(clippy::module_inception)] mod did; +mod did_compositejwk; mod did_jwk; mod did_url; mod error; @@ -27,5 +28,6 @@ pub use crate::did_url::RelativeDIDUrl; pub use ::did_url_parser::DID as BaseDIDUrl; pub use did::CoreDID; pub use did::DID; +pub use did_compositejwk::*; pub use did_jwk::*; pub use error::Error; diff --git a/identity_document/src/document/core_document.rs b/identity_document/src/document/core_document.rs index 1e1a340bb4..8887eeea72 100644 --- a/identity_document/src/document/core_document.rs +++ b/identity_document/src/document/core_document.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use core::convert::TryInto as _; @@ -7,6 +7,7 @@ use core::fmt::Formatter; use std::collections::HashMap; use std::convert::Infallible; +use identity_did::DIDCompositeJwk; use identity_did::DIDJwk; use identity_verification::jose::jwk::Jwk; use identity_verification::jose::jws::DecodedJws; @@ -983,6 +984,63 @@ impl CoreDocument { .verify(signature_verifier, public_key) .map_err(Error::JwsVerificationError) } + + /// Decodes and verifies the provided PQ/T JWS according to the passed [`JwsVerificationOptions`] with a + /// traditional [`JwsVerifier`] and PQ [`JwsVerifier`]. + /// + /// Regardless of which options are passed the following conditions must be met in order for a verification attempt to + /// take place. + /// - The JWS must be encoded according to the JWS compact serialization. + /// - The `kid` value in the protected header must be an identifier of a verification method in this DID document, or + /// set explicitly in the `options`. + // + // NOTE: This is tested in `identity_storage` and `identity_credential`. + pub fn verify_jws_hybrid<'jws, TRV: JwsVerifier, PQV: JwsVerifier>( + &self, + jws: &'jws str, + detached_payload: Option<&'jws [u8]>, + traditional_verifier: &TRV, + pq_verifier: &PQV, + options: &JwsVerificationOptions, + ) -> Result> { + let validation_item = Decoder::new() + .decode_compact_serialization(jws.as_bytes(), detached_payload) + .map_err(Error::JwsVerificationError)?; + + let nonce: Option<&str> = options.nonce.as_deref(); + // Validate the nonce + if validation_item.nonce() != nonce { + return Err(Error::JwsVerificationError( + identity_verification::jose::error::Error::InvalidParam("invalid nonce value"), + )); + } + + let method_url_query: DIDUrlQuery<'_> = match &options.method_id { + Some(method_id) => method_id.into(), + None => validation_item + .kid() + .ok_or(Error::JwsVerificationError( + identity_verification::jose::error::Error::InvalidParam("missing kid value"), + ))? + .into(), + }; + + let composite_public_key = self + .resolve_method(method_url_query, options.method_scope) + .ok_or(Error::MethodNotFound)? + .data() + .try_composite_public_key() + .map_err(Error::InvalidKeyMaterial)?; + + validation_item + .verify_hybrid( + traditional_verifier, + pq_verifier, + composite_public_key.traditional_public_key(), + composite_public_key.pq_public_key(), + ) + .map_err(Error::JwsVerificationError) + } } impl CoreDocument { @@ -1002,6 +1060,24 @@ impl CoreDocument { } } +impl CoreDocument { + /// Creates a [`CoreDocument`] from a did:compositejwk DID. + pub fn expand_did_compositejwk(did_compositejwk: DIDCompositeJwk) -> Result { + let verification_method = + VerificationMethod::try_from(did_compositejwk.clone()).map_err(Error::InvalidKeyMaterial)?; + let verification_method_id = verification_method.id().clone(); + + DocumentBuilder::default() + .id(did_compositejwk.into()) + .verification_method(verification_method) + .assertion_method(verification_method_id.clone()) + .authentication(verification_method_id.clone()) + .capability_invocation(verification_method_id.clone()) + .capability_delegation(verification_method_id.clone()) + .build() + } +} + #[cfg(test)] mod tests { use identity_core::convert::FromJson; diff --git a/identity_iota/Cargo.toml b/identity_iota/Cargo.toml index 6d710fc814..bafa9e77fc 100644 --- a/identity_iota/Cargo.toml +++ b/identity_iota/Cargo.toml @@ -24,13 +24,13 @@ identity_verification = { version = "=1.6.0-beta", path = "../identity_verificat iota_interaction.workspace = true [target.'cfg(target_arch = "wasm32")'.dependencies] -iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction", default-features = false } +iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction", default-features = false } [dev-dependencies] # required for doc test anyhow = "1.0.64" identity_iota = { version = "=1.6.0-beta", path = "./", features = ["memstore"] } -iota-sdk = { git = "https://github.com/iotaledger/iota.git", package = "iota-sdk", tag = "v1.4.1" } +iota-sdk = { git = "https://github.com/iotaledger/iota.git", package = "iota-sdk", tag = "v1.7.0" } rand = "0.8.5" secret-storage = { git = "https://github.com/iotaledger/secret-storage.git", tag = "v0.3.0" } tokio = { version = "1.46.1", features = ["full"] } @@ -87,9 +87,19 @@ sd-jwt-vc = ["identity_credential/sd-jwt-vc"] # Enables zero knowledge selective disclosurable VCs jpt-bbs-plus = ["identity_storage/jpt-bbs-plus", "identity_credential/jpt-bbs-plus"] +# Enables PQC +pqc = ["identity_storage/pqc"] +pqc-liboqs = ["identity_storage/pqc-liboqs"] + +# Enables PQ/T Hybrid +hybrid = ["identity_storage/hybrid", "identity_credential/hybrid"] +hybrid-liboqs = ["identity_storage/hybrid-liboqs", "identity_credential/hybrid"] # Enables integration with IOTA Keytool. keytool = ["identity_iota_core/keytool", "identity_storage/keytool"] +# Enables the integration with IOTA Resource Locators (IRLs). +irl = ["identity_core/irl"] + [package.metadata.docs.rs] # To build locally: # RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --all-features --no-deps --workspace --open diff --git a/identity_iota/README.md b/identity_iota/README.md index 30cf08f6c5..51b8425e76 100644 --- a/identity_iota/README.md +++ b/identity_iota/README.md @@ -1,4 +1,4 @@ -![banner](https://github.com/iotaledger/identity/raw/HEAD/.github/banner_identity.svg) +![banner](https://github.com/iotaledger/identity/raw/HEAD/.github/banner_identity.png)

StackExchange diff --git a/identity_iota_core/Cargo.toml b/identity_iota_core/Cargo.toml index 25e5d0dc35..832fc61d8e 100644 --- a/identity_iota_core/Cargo.toml +++ b/identity_iota_core/Cargo.toml @@ -24,7 +24,7 @@ num-derive = { version = "0.4", default-features = false } num-traits = { version = "0.2", default-features = false, features = ["std"] } once_cell = { version = "1.18", default-features = false, features = ["std"] } prefix-hex = { version = "0.7", default-features = false } -product_common = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "product_common", default-features = false } +product_common = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "product_common", default-features = false } ref-cast = { version = "1.0.14", default-features = false } serde.workspace = true serde_json.workspace = true @@ -45,16 +45,16 @@ secret-storage = { git = "https://github.com/iotaledger/secret-storage.git", tag serde-aux = { version = "4.5.0", optional = true } [target.'cfg(not(target_arch = "wasm32"))'.dependencies] -iota-config = { git = "https://github.com/iotaledger/iota.git", package = "iota-config", tag = "v1.4.1", optional = true } -iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction", optional = true } -iota_interaction_rust = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction_rust", optional = true } -iota-sdk = { git = "https://github.com/iotaledger/iota.git", package = "iota-sdk", tag = "v1.4.1", optional = true } -move-core-types = { git = "https://github.com/iotaledger/iota.git", package = "move-core-types", tag = "v1.4.1", optional = true } -shared-crypto = { git = "https://github.com/iotaledger/iota.git", package = "shared-crypto", tag = "v1.4.1", optional = true } +iota-config = { git = "https://github.com/iotaledger/iota.git", package = "iota-config", tag = "v1.7.0", optional = true } +iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction", optional = true } +iota_interaction_rust = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction_rust", optional = true } +iota-sdk = { git = "https://github.com/iotaledger/iota.git", package = "iota-sdk", tag = "v1.7.0", optional = true } +move-core-types = { git = "https://github.com/iotaledger/iota.git", package = "move-core-types", tag = "v1.7.0", optional = true } +shared-crypto = { git = "https://github.com/iotaledger/iota.git", package = "shared-crypto", tag = "v1.7.0", optional = true } tokio = { version = "1.46.1", default-features = false, features = ["macros", "sync", "rt", "process"] } [target.'cfg(target_arch = "wasm32")'.dependencies] -iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction", default-features = false, optional = true } +iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction", default-features = false, optional = true } # Dependency iota_interaction_ts is always used on wasm32 platform. It is not controlled by the "iota-client" feature # because it's unclear how to implement this. wasm32 build will most probably always use the "iota-client" feature diff --git a/identity_iota_core/src/rebased/migration/multicontroller.rs b/identity_iota_core/src/rebased/migration/multicontroller.rs index 459710a1f3..35c51bdc2c 100644 --- a/identity_iota_core/src/rebased/migration/multicontroller.rs +++ b/identity_iota_core/src/rebased/migration/multicontroller.rs @@ -182,7 +182,7 @@ impl TryFrom> for Multicontroller { let controllers = controllers .contents .into_iter() - .map(|Entry { key: id, value: vp }| (u64::try_from(vp).map(|vp| (id, vp)))) + .map(|Entry { key: id, value: vp }| u64::try_from(vp).map(|vp| (id, vp))) .collect::>()?; Ok(Multicontroller { diff --git a/identity_jose/Cargo.toml b/identity_jose/Cargo.toml index 82540b6a58..5678991a48 100644 --- a/identity_jose/Cargo.toml +++ b/identity_jose/Cargo.toml @@ -25,10 +25,10 @@ thiserror.workspace = true zeroize = { version = "1.6", default-features = false, features = ["std", "zeroize_derive"] } [target.'cfg(not(target_arch = "wasm32"))'.dependencies] -iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction" } +iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction" } [target.'cfg(target_arch = "wasm32")'.dependencies] -iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction", default-features = false } +iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction", default-features = false } [dev-dependencies] iota-crypto = { version = "0.23", features = ["ed25519", "random", "hmac"] } diff --git a/identity_jose/src/jwk/composite_jwk.rs b/identity_jose/src/jwk/composite_jwk.rs new file mode 100644 index 0000000000..c4d0ad5000 --- /dev/null +++ b/identity_jose/src/jwk/composite_jwk.rs @@ -0,0 +1,117 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use std::fmt::Display; +use std::str::FromStr; + +use crate::jwk::PostQuantumJwk; +use crate::jwk::TraditionalJwk; + +/// Algorithms used to generate hybrid signatures. +#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)] +#[non_exhaustive] +pub enum CompositeAlgId { + /// DER encoded value in hex = 060B6086480186FA6B5008013E + #[serde(rename = "id-MLDSA44-Ed25519")] + IdMldsa44Ed25519, + /// DER encoded value in hex = 060B6086480186FA6B50080147 + #[serde(rename = "id-MLDSA65-Ed25519")] + IdMldsa65Ed25519, +} + +impl CompositeAlgId { + /// Returns the JWS algorithm as a `str` slice. + pub const fn name(self) -> &'static str { + match self { + Self::IdMldsa44Ed25519 => "id-MLDSA44-Ed25519", + Self::IdMldsa65Ed25519 => "id-MLDSA65-Ed25519", + } + } + + /// Returns the [CompositeAlgId]'s domain as a byte slice. + pub const fn domain(self) -> &'static [u8] { + match self { + Self::IdMldsa44Ed25519 => &[ + 0x06, 0x0B, 0x60, 0x86, 0x48, 0x01, 0x86, 0xFA, 0x6B, 0x50, 0x08, 0x01, 0x3E, + ], + Self::IdMldsa65Ed25519 => &[ + 0x06, 0x0B, 0x60, 0x86, 0x48, 0x01, 0x86, 0xFA, 0x6B, 0x50, 0x08, 0x01, 0x47, + ], + } + } + + /// Returns the prefix used for composite signatures. + pub const COMPOSITE_SIGNATURE_PREFIX: &[u8] = b"CompositeAlgorithmSignatures2025"; +} + +/// Represent a combination of a traditional public key and a post-quantum public key both in Jwk format. +#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)] +#[serde(rename_all = "camelCase")] +pub struct CompositeJwk { + alg_id: CompositeAlgId, + traditional_public_key: TraditionalJwk, + pq_public_key: PostQuantumJwk, +} + +impl CompositeJwk { + /// Create a new CompositePublicKey structure. + pub fn new(alg_id: CompositeAlgId, traditional_public_key: TraditionalJwk, pq_public_key: PostQuantumJwk) -> Self { + Self { + alg_id, + traditional_public_key: traditional_public_key.into_public().unwrap(), + pq_public_key: pq_public_key.into_public().unwrap(), + } + } + /// Get the `algId` value. + pub fn alg_id(&self) -> CompositeAlgId { + self.alg_id + } + /// Get the post-quantum public key in Jwk format. + pub fn pq_public_key(&self) -> &PostQuantumJwk { + &self.pq_public_key + } + /// Get the traditional public key in Jwk format. + pub fn traditional_public_key(&self) -> &TraditionalJwk { + &self.traditional_public_key + } +} + +impl FromStr for CompositeAlgId { + type Err = CompositeAlgParsingError; + + fn from_str(string: &str) -> std::result::Result { + match string { + "id-MLDSA44-Ed25519" => Ok(Self::IdMldsa44Ed25519), + "id-MLDSA65-Ed25519" => Ok(Self::IdMldsa65Ed25519), + invalid => Err(CompositeAlgParsingError { + input: invalid.to_owned(), + }), + } + } +} + +/// Error that might occure when parsing a [CompositeAlgId] out of a string. +#[derive(Debug, thiserror::Error)] +#[non_exhaustive] +pub struct CompositeAlgParsingError { + /// The input string. + pub input: String, +} + +impl Display for CompositeAlgParsingError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "invalid CompositeAlgId `{}`; valid values are: `{}`, `{}`", + self.input, + CompositeAlgId::IdMldsa44Ed25519.name(), + CompositeAlgId::IdMldsa65Ed25519.name() + ) + } +} + +impl From for crate::error::Error { + fn from(_: CompositeAlgParsingError) -> Self { + crate::error::Error::JwsAlgorithmParsingError + } +} diff --git a/identity_jose/src/jwk/jwk_akp.rs b/identity_jose/src/jwk/jwk_akp.rs new file mode 100644 index 0000000000..f379ccc19f --- /dev/null +++ b/identity_jose/src/jwk/jwk_akp.rs @@ -0,0 +1,78 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +// ============================================================================= +// Algorithm Key Pair (AKP) key parameters for Post-quantum algorithm +// ============================================================================= + +use zeroize::Zeroize; + +use crate::jwk::JwkParams; + +use super::JwkType; + +/// Parameters for Post-Quantum algorithm keys +/// +/// [More Info](https://datatracker.ietf.org/doc/html/draft-ietf-cose-dilithium-06) +#[derive( + Clone, Debug, Default, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Deserialize, serde::Serialize, Zeroize, +)] +#[zeroize(drop)] +pub struct JwkParamsAkp { + /// The public key as a base64url-encoded value. + #[serde(rename = "pub")] + pub public: String, // Public Key + /// The private key as a base64url-encoded value. + #[serde(skip_serializing_if = "Option::is_none", rename = "priv")] + pub private: Option, // Private Key +} + +impl JwkParamsAkp { + /// Creates new JWK AKP Params. + pub const fn new() -> Self { + Self { + public: String::new(), + private: None, + } + } + + /// Returns the key type `kty`. + pub const fn kty(&self) -> JwkType { + JwkType::Akp + } + + /// Returns a clone with _all_ private key components unset. + pub fn to_public(&self) -> Self { + Self { + public: self.public.clone(), + private: None, + } + } + + /// Returns `true` if _all_ private key components of the key are unset, `false` otherwise. + pub fn is_public(&self) -> bool { + self.private.is_none() + } + + /// Returns `true` if _all_ private key components of the key are set, `false` otherwise. + pub fn is_private(&self) -> bool { + self.private.is_some() + } + + /// Unsets private key component. + pub fn strip_private(&mut self) { + self.private = None; + } + + /// Returns this key with the private key components unset. + pub fn into_public(mut self) -> Self { + self.strip_private(); + self + } +} + +impl From for JwkParams { + fn from(other: JwkParamsAkp) -> Self { + JwkParams::Akp(other) + } +} diff --git a/identity_jose/src/jwk/key.rs b/identity_jose/src/jwk/key.rs index 3ad0ff0c1c..fc6499ca00 100644 --- a/identity_jose/src/jwk/key.rs +++ b/identity_jose/src/jwk/key.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use crypto::hashes::sha::SHA256; @@ -13,6 +13,7 @@ use crate::jwk::EcxCurve; use crate::jwk::EdCurve; use crate::jwk::JwkOperation; use crate::jwk::JwkParams; +use crate::jwk::JwkParamsAkp; use crate::jwk::JwkParamsEc; use crate::jwk::JwkParamsOct; use crate::jwk::JwkParamsOkp; @@ -261,6 +262,9 @@ impl Jwk { (JwkType::Okp, value @ JwkParams::Okp(_)) => { self.set_params_unchecked(value); } + (JwkType::Akp, value @ JwkParams::Akp(_)) => { + self.set_params_unchecked(value); + } (_, _) => { return Err(Error::InvalidParam("`params` type does not match `kty`")); } @@ -339,6 +343,22 @@ impl Jwk { } } + /// Returns the [`JwkParamsAkp`] in this JWK if it is of type `Akp`. + pub fn try_akp_params(&self) -> Result<&JwkParamsAkp> { + match self.params() { + JwkParams::Akp(params) => Ok(params), + _ => Err(Error::KeyError("Akp")), + } + } + + /// Returns a mutable reference to the [`JwkParamsAkp`] in this JWK if it is of type `Akp`. + pub fn try_akp_params_mut(&mut self) -> Result<&mut JwkParamsAkp> { + match self.params_mut() { + JwkParams::Akp(params) => Ok(params), + _ => Err(Error::KeyError("Akp")), + } + } + // =========================================================================== // Thumbprint // =========================================================================== @@ -387,6 +407,9 @@ impl Jwk { JwkParams::Okp(JwkParamsOkp { crv, x, .. }) => { format!(r#"{{"crv":"{crv}","kty":"{kty}","x":"{x}"}}"#) } + JwkParams::Akp(JwkParamsAkp { public, .. }) => { + format!(r#"{{"kty":"{kty}","pub":"{public}"}}"#) + } } } @@ -439,6 +462,7 @@ impl Jwk { JwkParams::Rsa(params) => params.is_private(), JwkParams::Oct(_) => true, JwkParams::Okp(params) => params.is_private(), + JwkParams::Akp(params) => params.is_private(), } } diff --git a/identity_jose/src/jwk/key_hybrid.rs b/identity_jose/src/jwk/key_hybrid.rs new file mode 100644 index 0000000000..69ac58783d --- /dev/null +++ b/identity_jose/src/jwk/key_hybrid.rs @@ -0,0 +1,439 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS +// SPDX-License-Identifier: Apache-2.0 + +use std::ops::Deref; +use std::str::FromStr; + +use identity_core::common::Url; + +use crate::error::Error; +use crate::error::Result; +use crate::jwk::Jwk; +use crate::jwk::JwkOperation; +use crate::jwk::JwkParams; +use crate::jwk::JwkParamsAkp; +use crate::jwk::JwkParamsEc; +use crate::jwk::JwkParamsOct; +use crate::jwk::JwkParamsOkp; +use crate::jwk::JwkParamsRsa; +use crate::jwk::JwkType; +use crate::jwk::JwkUse; +use crate::jws::JwsAlgorithm; + +/// A post-quantum key encoded as JWK. +#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)] +#[serde(transparent)] +pub struct PostQuantumJwk(Jwk); + +impl PostQuantumJwk { + /// Creates a new `[PostQuantumJwk]`. + pub fn new(paramsakp: JwkParamsAkp) -> Self { + Self(Jwk { + kty: JwkType::Akp, + use_: None, + key_ops: None, + alg: None, + kid: None, + x5u: None, + x5c: None, + x5t: None, + x5t_s256: None, + params: JwkParams::Akp(paramsakp), + }) + } + + /// Creates a new `[PostQuantumJwk]` from the given kty. + pub fn from_kty(kty: impl Into) -> Result { + let kty: JwkType = kty.into(); + if kty != JwkType::Akp { + return Err(Error::KeyError("PostQuantumJwk can only be created with JwkType::Akp")); + } + + Ok(Self(Jwk { + kty, + use_: None, + key_ops: None, + alg: None, + kid: None, + x5u: None, + x5c: None, + x5t: None, + x5t_s256: None, + params: JwkParams::new(kty), + })) + } + + /// Creates a new `[PostQuantumJwk]` from the given params. + pub fn from_params(params: impl Into) -> Result { + let params: JwkParams = params.into(); + + if params.kty() != JwkType::Akp { + return Err(Error::KeyError( + "PostQuantumJwk can only be created from a JwkParamsAkp", + )); + } + + Ok(Self(Jwk { + kty: params.kty(), + use_: None, + key_ops: None, + alg: None, + kid: None, + x5u: None, + x5c: None, + x5t: None, + x5t_s256: None, + params, + })) + } + + /// Sets a value for the key use parameter (use). + pub fn set_use(&mut self, value: impl Into) { + self.0.set_use(value) + } + + /// Sets values for the key operations parameter (key_ops). + pub fn set_key_ops(&mut self, value: impl IntoIterator>) { + self.0.set_key_ops(value); + } + + /// Sets a value for the algorithm property (alg). + pub fn set_alg(&mut self, value: impl Into) -> Result<()> { + let alg = JwsAlgorithm::from_str(&value.into()).map_err(|_| Error::InvalidParam("Invalid JWS algorithm"))?; + if !is_post_quantum(&alg) { + return Err(Error::InvalidParam( + "PostQuantumJwk can only be created with a post-quantum JWS algorithm", + )); + } + self.0.set_alg(alg.to_string()); + Ok(()) + } + + /// Sets a value for the key ID property (kid). + pub fn set_kid(&mut self, value: impl Into) { + self.0.set_kid(value); + } + + /// Sets a value for the X.509 URL property (x5u). + pub fn set_x5u(&mut self, value: impl Into) { + self.0.set_x5u(value); + } + + /// Sets values for the X.509 certificate chain property (x5c). + pub fn set_x5c(&mut self, value: impl IntoIterator>) { + self.0.set_x5c(value); + } + + /// Sets a value for the X.509 certificate SHA-1 thumbprint property (x5t). + pub fn set_x5t(&mut self, value: impl Into) { + self.0.set_x5t(value); + } + + /// Sets a value for the X.509 certificate SHA-256 thumbprint property + /// (x5t#S256). + pub fn set_x5t_s256(&mut self, value: impl Into) { + self.0.set_x5t_s256(value); + } + + /// Sets the value of the custom inner JWK properties. Only for `Akp` keys. + pub fn set_params(&mut self, params: impl Into) -> Result<()> { + let params: JwkParams = params.into(); + if params.kty() != JwkType::Akp { + return Err(Error::InvalidParam("`params` type does not match `Akp`")); + } + self.0.set_params_unchecked(params); + Ok(()) + } + + /// Returns the [`JwkParamsAkp`] in this JWK. + pub fn akp_params(&self) -> &JwkParamsAkp { + self + .0 + .try_akp_params() + .expect("PostQuantumJwk must have JwkParamsAkp as params") + } + + /// Returns a mutable reference to the [`JwkParamsAkp`] in this JWK. + pub fn akp_params_mut(&mut self) -> &mut JwkParamsAkp { + self + .0 + .try_akp_params_mut() + .expect("PostQuantumJwk must have JwkParamsAkp as params") + } + + /// Removes all private key components. + #[inline(always)] + pub fn strip_private(&mut self) { + self.0.params_mut().strip_private(); + } + + /// Returns this key with _all_ private key components unset. + pub fn into_public(mut self) -> Option { + self.0.params.strip_private(); + Some(self) + } +} + +impl Deref for PostQuantumJwk { + type Target = Jwk; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl TryFrom for PostQuantumJwk { + type Error = Error; + + fn try_from(value: Jwk) -> Result { + let alg = JwsAlgorithm::from_str(value.alg().ok_or(Error::KeyError("Missing JWK algorithm"))?)?; + if value.kty != JwkType::Akp && !is_post_quantum(&alg) { + return Err(Error::KeyError( + "PostQuantumJwk can only be created from a post quantum Jwk", + )); + } + + Ok(Self(value)) + } +} + +impl AsRef for PostQuantumJwk { + fn as_ref(&self) -> &Jwk { + &self.0 + } +} + +impl From for Jwk { + fn from(value: PostQuantumJwk) -> Self { + value.0 + } +} + +/// Wrapper to the [`Jwk`] structure to enforce the exclusive use of traditional JWK encoded keys in the +/// [`CompositeJwk`] +#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)] +#[serde(transparent)] +pub struct TraditionalJwk(Jwk); + +impl TraditionalJwk { + /// Creates a new `[TraditionalJwk]` from a `[JwkParamsOkp]`. + pub fn new(kty: JwkParamsOkp) -> Self { + Self(Jwk { + kty: JwkType::Okp, + use_: None, + key_ops: None, + alg: None, + kid: None, + x5u: None, + x5c: None, + x5t: None, + x5t_s256: None, + params: JwkParams::Okp(kty), + }) + } + + /// Creates a new `[TraditionalJwk]` from the given kty. + pub fn from_kty(kty: JwkType) -> Result { + if kty == JwkType::Akp { + return Err(Error::KeyError( + "TraditionalJwk can only be created with different from JwkType::Akp", + )); + } + + Ok(Self(Jwk { + kty, + use_: None, + key_ops: None, + alg: None, + kid: None, + x5u: None, + x5c: None, + x5t: None, + x5t_s256: None, + params: JwkParams::new(kty), + })) + } + + /// Creates a new `[TraditionalJwk]` from the given params. + pub fn from_params(params: impl Into) -> Result { + let params: JwkParams = params.into(); + + if params.kty() == JwkType::Akp { + return Err(Error::KeyError( + "TraditionalJwk can only be created with different from JwkType::Akp", + )); + } + + Ok(Self(Jwk { + kty: params.kty(), + use_: None, + key_ops: None, + alg: None, + kid: None, + x5u: None, + x5c: None, + x5t: None, + x5t_s256: None, + params, + })) + } + + /// Sets a value for the key use parameter (use). + pub fn set_use(&mut self, value: impl Into) { + self.0.set_use(value) + } + + /// Sets values for the key operations parameter (key_ops). + pub fn set_key_ops(&mut self, value: impl IntoIterator>) { + self.0.set_key_ops(value); + } + + /// Sets a value for the algorithm property (alg). + pub fn set_alg(&mut self, value: impl Into) -> Result<()> { + let alg = JwsAlgorithm::from_str(&value.into()).map_err(|_| Error::InvalidParam("Invalid JWS algorithm"))?; + if is_post_quantum(&alg) { + return Err(Error::InvalidParam( + "TraditionalJwk can only be created with a traditional JWS algorithm", + )); + } + self.0.set_alg(alg.to_string()); + Ok(()) + } + + /// Sets a value for the key ID property (kid). + pub fn set_kid(&mut self, value: impl Into) { + self.0.set_kid(value); + } + + /// Sets a value for the X.509 URL property (x5u). + pub fn set_x5u(&mut self, value: impl Into) { + self.0.set_x5u(value); + } + + /// Sets values for the X.509 certificate chain property (x5c). + pub fn set_x5c(&mut self, value: impl IntoIterator>) { + self.0.set_x5c(value); + } + + /// Sets a value for the X.509 certificate SHA-1 thumbprint property (x5t). + pub fn set_x5t(&mut self, value: impl Into) { + self.0.set_x5t(value); + } + + /// Sets a value for the X.509 certificate SHA-256 thumbprint property + /// (x5t#S256). + pub fn set_x5t_s256(&mut self, value: impl Into) { + self.0.set_x5t_s256(value); + } + + /// Sets the value of the custom JWK properties. + /// + /// The passed `params` must be appropriate for the key type (`kty`), an error is returned otherwise. + /// + /// If you want to set `params` unchecked, use [`set_params_unchecked`](Self::set_params_unchecked). + pub fn set_params(&mut self, params: impl Into) -> Result<()> { + self.0.set_params(params) + } + + /// Sets the value of the custom JWK properties. + /// + /// Does not check whether the passed params are appropriate for the set key type (`kty`). + pub fn set_params_unchecked(&mut self, value: impl Into) { + self.0.set_params_unchecked(value) + } + + /// Returns a mutable reference to the [`JwkParamsEc`] in this inner JWK if it is of type `Ec`. + pub fn try_ec_params_mut(&mut self) -> Result<&mut JwkParamsEc> { + self.0.try_ec_params_mut() + } + + /// Returns a mutable reference to the [`JwkParamsRsa`] in this inner JWK if it is of type `Rsa`. + pub fn try_rsa_params_mut(&mut self) -> Result<&mut JwkParamsRsa> { + self.0.try_rsa_params_mut() + } + + /// Returns a mutable reference to the [`JwkParamsOct`] in this JWK if it is of type `Oct`. + pub fn try_oct_params_mut(&mut self) -> Result<&mut JwkParamsOct> { + self.0.try_oct_params_mut() + } + + /// Returns a mutable reference to the [`JwkParamsOkp`] in this inner JWK if it is of type `Okp`. + pub fn try_okp_params_mut(&mut self) -> Result<&mut JwkParamsOkp> { + self.0.try_okp_params_mut() + } + + /// Removes all private key components. + /// In the case of [JwkParams::Oct], this method does nothing. + #[inline(always)] + pub fn strip_private(&mut self) { + self.0.params_mut().strip_private(); + } + + /// Returns this key with _all_ private key components unset. + /// In the case of [JwkParams::Oct], this method returns [None]. + pub fn into_public(mut self) -> Option { + if matches!(&self.params, JwkParams::Oct(_)) { + None + } else { + self.0.params.strip_private(); + Some(self) + } + } +} + +impl Deref for TraditionalJwk { + type Target = Jwk; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl TryFrom for TraditionalJwk { + type Error = Error; + + fn try_from(value: Jwk) -> Result { + let alg = JwsAlgorithm::from_str(value.alg().ok_or(Error::KeyError("Missing JWK algorithm"))?)?; + if value.kty == JwkType::Akp && is_post_quantum(&alg) { + return Err(Error::KeyError( + "TraditionalJwk can only be created from a traditional Jwk", + )); + } + Ok(Self(value)) + } +} + +impl AsRef for TraditionalJwk { + fn as_ref(&self) -> &Jwk { + &self.0 + } +} + +impl From for Jwk { + fn from(value: TraditionalJwk) -> Self { + value.0 + } +} + +fn is_post_quantum(alg: &JwsAlgorithm) -> bool { + matches!( + alg, + JwsAlgorithm::FALCON1024 + | JwsAlgorithm::FALCON512 + | JwsAlgorithm::ML_DSA_44 + | JwsAlgorithm::ML_DSA_65 + | JwsAlgorithm::ML_DSA_87 + | JwsAlgorithm::SLH_DSA_SHA2_128s + | JwsAlgorithm::SLH_DSA_SHAKE_128s + | JwsAlgorithm::SLH_DSA_SHA2_128f + | JwsAlgorithm::SLH_DSA_SHAKE_128f + | JwsAlgorithm::SLH_DSA_SHA2_192s + | JwsAlgorithm::SLH_DSA_SHAKE_192s + | JwsAlgorithm::SLH_DSA_SHA2_192f + | JwsAlgorithm::SLH_DSA_SHAKE_192f + | JwsAlgorithm::SLH_DSA_SHA2_256s + | JwsAlgorithm::SLH_DSA_SHAKE_256s + | JwsAlgorithm::SLH_DSA_SHA2_256f + | JwsAlgorithm::SLH_DSA_SHAKE_256f + ) +} diff --git a/identity_jose/src/jwk/key_params.rs b/identity_jose/src/jwk/key_params.rs index 8c97da41d9..984bf16a69 100644 --- a/identity_jose/src/jwk/key_params.rs +++ b/identity_jose/src/jwk/key_params.rs @@ -1,8 +1,10 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use zeroize::Zeroize; +use super::BlsCurve; +use super::JwkParamsAkp; use crate::error::Error; use crate::error::Result; use crate::jwk::EcCurve; @@ -10,8 +12,6 @@ use crate::jwk::EcxCurve; use crate::jwk::EdCurve; use crate::jwk::JwkType; -use super::BlsCurve; - /// Algorithm-specific parameters for JSON Web Keys. /// /// [More Info](https://tools.ietf.org/html/rfc7518#section-6) @@ -28,6 +28,8 @@ pub enum JwkParams { Oct(JwkParamsOct), /// Octet Key Pairs parameters. Okp(JwkParamsOkp), + /// Algorithm Key Pair Type parameters + Akp(JwkParamsAkp), } impl JwkParams { @@ -38,6 +40,7 @@ impl JwkParams { JwkType::Rsa => Self::Rsa(JwkParamsRsa::new()), JwkType::Oct => Self::Oct(JwkParamsOct::new()), JwkType::Okp => Self::Okp(JwkParamsOkp::new()), + JwkType::Akp => Self::Akp(JwkParamsAkp::new()), } } @@ -48,6 +51,7 @@ impl JwkParams { Self::Rsa(inner) => inner.kty(), Self::Oct(inner) => inner.kty(), Self::Okp(inner) => inner.kty(), + Self::Akp(_) => JwkType::Akp, } } @@ -60,6 +64,7 @@ impl JwkParams { Self::Ec(inner) => Some(Self::Ec(inner.to_public())), Self::Rsa(inner) => Some(Self::Rsa(inner.to_public())), Self::Oct(_) => None, + Self::Akp(inner) => Some(Self::Akp(inner.to_public())), } } @@ -71,6 +76,7 @@ impl JwkParams { Self::Ec(inner) => inner.strip_private(), Self::Rsa(inner) => inner.strip_private(), Self::Oct(_) => (), + Self::Akp(inner) => inner.strip_private(), } } @@ -92,6 +98,7 @@ impl JwkParams { Self::Ec(value) => value.is_public(), Self::Rsa(value) => value.is_public(), Self::Oct(value) => value.is_public(), + Self::Akp(value) => value.is_public(), } } } diff --git a/identity_jose/src/jwk/key_type.rs b/identity_jose/src/jwk/key_type.rs index 59cdbaa5cc..e8b0a60b00 100644 --- a/identity_jose/src/jwk/key_type.rs +++ b/identity_jose/src/jwk/key_type.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use core::fmt::Display; @@ -22,6 +22,10 @@ pub enum JwkType { /// Octet string key pairs. #[serde(rename = "OKP")] Okp, + /// Algorithm Key Pair, JSON Web Key Type for the ML-DSA and SLH-DSA Algorithm Family. + /// [More Info] (https://datatracker.ietf.org/doc/html/draft-ietf-cose-dilithium-06#name-algorithm-key-pair-type) + #[serde(rename = "AKP")] + Akp, } impl JwkType { @@ -32,6 +36,7 @@ impl JwkType { Self::Rsa => "RSA", Self::Oct => "oct", Self::Okp => "OKP", + Self::Akp => "AKP", } } } diff --git a/identity_jose/src/jwk/mod.rs b/identity_jose/src/jwk/mod.rs index 14a271976f..589c65149b 100644 --- a/identity_jose/src/jwk/mod.rs +++ b/identity_jose/src/jwk/mod.rs @@ -1,23 +1,29 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 //! JSON Web Keys ([JWK](https://tools.ietf.org/html/rfc7517)) +mod composite_jwk; #[cfg(feature = "jwk-conversion")] mod conversion; mod curve; +mod jwk_akp; mod jwk_ext; mod key; +mod key_hybrid; mod key_operation; mod key_params; mod key_set; mod key_type; mod key_use; +pub use self::composite_jwk::*; #[cfg(feature = "jwk-conversion")] pub use self::conversion::*; pub use self::curve::*; +pub use self::jwk_akp::*; pub use self::key::*; +pub use self::key_hybrid::*; pub use self::key_operation::*; pub use self::key_params::*; pub use self::key_set::*; diff --git a/identity_jose/src/jws/algorithm.rs b/identity_jose/src/jws/algorithm.rs index 1d6b1c319c..bdf830bf26 100644 --- a/identity_jose/src/jws/algorithm.rs +++ b/identity_jose/src/jws/algorithm.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use core::fmt::Display; @@ -44,6 +44,67 @@ pub enum JwsAlgorithm { NONE, /// EdDSA signature algorithms EdDSA, + /// JSON Web Signature Algorithm for ML-DSA-44 + /// [More Info](https://datatracker.ietf.org/doc/html/draft-ietf-cose-dilithium#name-the-ml-dsa-algorithm-family) + #[serde(rename = "ML-DSA-44")] + ML_DSA_44, + /// JSON Web Signature Algorithm for ML-DSA-44 + /// [More Info](https://datatracker.ietf.org/doc/html/draft-ietf-cose-dilithium#name-the-ml-dsa-algorithm-family) + #[serde(rename = "ML-DSA-65")] + ML_DSA_65, + /// JSON Web Signature Algorithm for ML-DSA-44 + /// [More Info](https://datatracker.ietf.org/doc/html/draft-ietf-cose-dilithium#name-the-ml-dsa-algorithm-family) + #[serde(rename = "ML-DSA-87")] + ML_DSA_87, + /// JSON Web Signature Algorithm for SLH-DSA-SHA2-128s + /// [More Info](https://datatracker.ietf.org/doc/html/draft-ietf-cose-sphincs-plus#name-the-slh-dsa-algorithm-famil) + #[serde(rename = "SLH-DSA-SHA2-128s")] + SLH_DSA_SHA2_128s, + /// JSON Web Signature Algorithm for SLH-DSA-SHAKE-128s + /// [More Info](https://datatracker.ietf.org/doc/html/draft-ietf-cose-sphincs-plus#name-the-slh-dsa-algorithm-famil) + #[serde(rename = "SLH-DSA-SHAKE-128s")] + SLH_DSA_SHAKE_128s, + /// JSON Web Signature Algorithm for SLH-DSA-SHA2-128f + /// [More Info](https://datatracker.ietf.org/doc/html/draft-ietf-cose-sphincs-plus#name-the-slh-dsa-algorithm-famil) + #[serde(rename = "SLH-DSA-SHA2-128f")] + SLH_DSA_SHA2_128f, + ///SLH_DSA_SHAKE_128f + #[serde(rename = "SLH-DSA-SHAKE-128f")] + SLH_DSA_SHAKE_128f, + ///SLH_DSA_SHA2_192s + #[serde(rename = "SLH-DSA-SHA2-192s")] + SLH_DSA_SHA2_192s, + ///SLH_DSA_SHAKE_192s + #[serde(rename = "SLH-DSA-SHAKE-192s")] + SLH_DSA_SHAKE_192s, + ///SLH-DSA-SHA2-192f + #[serde(rename = "SLH-DSA-SHA2-192f")] + SLH_DSA_SHA2_192f, + ///SLH-DSA-SHAKE-192f + #[serde(rename = "SLH-DSA-SHAKE-192f")] + SLH_DSA_SHAKE_192f, + ///SLH-DSA-SHA2-256s + #[serde(rename = "SLH-DSA-SHA2-256s")] + SLH_DSA_SHA2_256s, + ///SLH-DSA-SHA2-256s + #[serde(rename = "SLH-DSA-SHAKE-256s")] + SLH_DSA_SHAKE_256s, + ///SLH-DSA-SHA2-256f + #[serde(rename = "SLH-DSA-SHA2-256f")] + SLH_DSA_SHA2_256f, + ///SLH-DSA-SHAKE-256f + #[serde(rename = "SLH-DSA-SHAKE-256f")] + SLH_DSA_SHAKE_256f, + ///FALCON512 + FALCON512, + ///FALCON1024 + FALCON1024, + ///id-MLDSA44-Ed25519 + #[serde(rename = "id-MLDSA44-Ed25519")] + IdMldsa44Ed25519, + ///id-MLDSA65-Ed25519 + #[serde(rename = "id-MLDSA65-Ed25519")] + IdMldsa65Ed25519, /// Custom algorithm #[cfg(feature = "custom_alg")] #[serde(untagged)] @@ -73,6 +134,25 @@ impl JwsAlgorithm { Self::ES256K, Self::NONE, Self::EdDSA, + Self::ML_DSA_44, + Self::ML_DSA_65, + Self::ML_DSA_87, + Self::SLH_DSA_SHA2_128s, + Self::SLH_DSA_SHAKE_128s, + Self::SLH_DSA_SHA2_128f, + Self::SLH_DSA_SHAKE_128f, + Self::SLH_DSA_SHA2_192s, + Self::SLH_DSA_SHAKE_192s, + Self::SLH_DSA_SHA2_192f, + Self::SLH_DSA_SHAKE_192f, + Self::SLH_DSA_SHA2_256s, + Self::SLH_DSA_SHAKE_256s, + Self::SLH_DSA_SHA2_256f, + Self::SLH_DSA_SHAKE_256f, + Self::FALCON512, + Self::FALCON1024, + Self::IdMldsa44Ed25519, + Self::IdMldsa65Ed25519, ]; /// Returns the JWS algorithm as a `str` slice. @@ -94,6 +174,25 @@ impl JwsAlgorithm { Self::ES256K => "ES256K", Self::NONE => "none", Self::EdDSA => "EdDSA", + Self::ML_DSA_44 => "ML-DSA-44", + Self::ML_DSA_65 => "ML-DSA-65", + Self::ML_DSA_87 => "ML-DSA-87", + Self::SLH_DSA_SHA2_128s => "SLH-DSA-SHA2-128s", + Self::SLH_DSA_SHAKE_128s => "SLH-DSA-SHAKE-128s", + Self::SLH_DSA_SHA2_128f => "SLH-DSA-SHA2-128f", + Self::SLH_DSA_SHAKE_128f => "SLH-DSA-SHAKE-128f", + Self::SLH_DSA_SHA2_192s => "SLH-DSA-SHA2-192s", + Self::SLH_DSA_SHAKE_192s => "SLH-DSA-SHAKE-192s", + Self::SLH_DSA_SHA2_192f => "SLH-DSA-SHA2-192f", + Self::SLH_DSA_SHAKE_192f => "SLH-DSA-SHAKE-192f", + Self::SLH_DSA_SHA2_256s => "SLH-DSA-SHA2-256s", + Self::SLH_DSA_SHAKE_256s => "SLH-DSA-SHAKE-256s", + Self::SLH_DSA_SHA2_256f => "SLH-DSA-SHA2-256f", + Self::SLH_DSA_SHAKE_256f => "SLH-DSA-SHAKE-256f", + Self::FALCON512 => "FALCON512", + Self::FALCON1024 => "FALCON1024", + Self::IdMldsa44Ed25519 => "id-MLDSA44-Ed25519", + Self::IdMldsa65Ed25519 => "id-MLDSA65-Ed25519", } } @@ -116,6 +215,25 @@ impl JwsAlgorithm { Self::ES256K => "ES256K".to_string(), Self::NONE => "none".to_string(), Self::EdDSA => "EdDSA".to_string(), + Self::ML_DSA_44 => "ML-DSA-44".to_string(), + Self::ML_DSA_65 => "ML-DSA-65".to_string(), + Self::ML_DSA_87 => "ML-DSA-87".to_string(), + Self::SLH_DSA_SHA2_128s => "SLH-DSA-SHA2-128s".to_string(), + Self::SLH_DSA_SHAKE_128s => "SLH-DSA-SHAKE-128s".to_string(), + Self::SLH_DSA_SHA2_128f => "SLH-DSA-SHA2-128f".to_string(), + Self::SLH_DSA_SHAKE_128f => "SLH-DSA-SHAKE-128f".to_string(), + Self::SLH_DSA_SHA2_192s => "SLH-DSA-SHA2-192s".to_string(), + Self::SLH_DSA_SHAKE_192s => "SLH-DSA-SHAKE-192s".to_string(), + Self::SLH_DSA_SHA2_192f => "SLH-DSA-SHA2-192f".to_string(), + Self::SLH_DSA_SHAKE_192f => "SLH-DSA-SHAKE-192f".to_string(), + Self::SLH_DSA_SHA2_256s => "SLH-DSA-SHA2-256s".to_string(), + Self::SLH_DSA_SHAKE_256s => "SLH-DSA-SHAKE-256s".to_string(), + Self::SLH_DSA_SHA2_256f => "SLH-DSA-SHA2-256f".to_string(), + Self::SLH_DSA_SHAKE_256f => "SLH-DSA-SHAKE-256f".to_string(), + Self::FALCON512 => "FALCON512".to_string(), + Self::FALCON1024 => "FALCON1024".to_string(), + Self::IdMldsa44Ed25519 => "id-MLDSA44-Ed25519".to_string(), + Self::IdMldsa65Ed25519 => "id-MLDSA65-Ed25519".to_string(), Self::Custom(name) => name.clone(), } } @@ -141,6 +259,25 @@ impl FromStr for JwsAlgorithm { "ES256K" => Ok(Self::ES256K), "none" => Ok(Self::NONE), "EdDSA" => Ok(Self::EdDSA), + "ML-DSA-44" => Ok(Self::ML_DSA_44), + "ML-DSA-65" => Ok(Self::ML_DSA_65), + "ML-DSA-87" => Ok(Self::ML_DSA_87), + "SLH-DSA-SHA2-128s" => Ok(Self::SLH_DSA_SHA2_128s), + "SLH-DSA-SHAKE-128s" => Ok(Self::SLH_DSA_SHAKE_128s), + "SLH-DSA-SHA2-128f" => Ok(Self::SLH_DSA_SHA2_128f), + "SLH-DSA-SHAKE-128f" => Ok(Self::SLH_DSA_SHAKE_128f), + "SLH-DSA-SHA2-192s" => Ok(Self::SLH_DSA_SHA2_192s), + "SLH-DSA-SHAKE-192s" => Ok(Self::SLH_DSA_SHAKE_192s), + "SLH-DSA-SHA2-192f" => Ok(Self::SLH_DSA_SHA2_192f), + "SLH-DSA-SHAKE-192f" => Ok(Self::SLH_DSA_SHAKE_192f), + "SLH-DSA-SHA2-256s" => Ok(Self::SLH_DSA_SHA2_256s), + "SLH-DSA-SHAKE-256s" => Ok(Self::SLH_DSA_SHAKE_256s), + "SLH-DSA-SHA2-256f" => Ok(Self::SLH_DSA_SHA2_256f), + "SLH-DSA-SHAKE-256f" => Ok(Self::SLH_DSA_SHAKE_256f), + "FALCON512" => Ok(Self::FALCON512), + "FALCON1024" => Ok(Self::FALCON1024), + "id-MLDSA44-Ed25519" => Ok(Self::IdMldsa44Ed25519), + "id-MLDSA65-Ed25519" => Ok(Self::IdMldsa65Ed25519), #[cfg(feature = "custom_alg")] value => Ok(Self::Custom(value.to_string())), #[cfg(not(feature = "custom_alg"))] diff --git a/identity_jose/src/jws/decoder.rs b/identity_jose/src/jws/decoder.rs index c1635c86d3..334b58c579 100644 --- a/identity_jose/src/jws/decoder.rs +++ b/identity_jose/src/jws/decoder.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use core::str; @@ -6,7 +6,10 @@ use std::borrow::Cow; use crate::error::Error; use crate::error::Result; +use crate::jwk::CompositeAlgId; use crate::jwk::Jwk; +use crate::jwk::PostQuantumJwk; +use crate::jwk::TraditionalJwk; use crate::jws::JwsAlgorithm; use crate::jws::JwsHeader; use crate::jwu::create_message; @@ -175,6 +178,89 @@ impl<'a> JwsValidationItem<'a> { claims, }) } + + /// Hybrid signature verification. + pub fn verify_hybrid( + self, + traditional_verifier: &TRV, + pq_verifier: &PQV, + traditional_pk: &TraditionalJwk, + pq_pk: &PostQuantumJwk, + ) -> Result> + where + TRV: JwsVerifier, + PQV: JwsVerifier, + { + // Destructure data + let JwsValidationItem { + headers, + claims, + signing_input, + decoded_signature, + } = self; + + let (protected, unprotected): (JwsHeader, Option>) = match headers { + DecodedHeaders::Protected(protected) => (protected, None), + DecodedHeaders::Both { protected, unprotected } => (protected, Some(unprotected)), + DecodedHeaders::Unprotected(_) => return Err(Error::MissingHeader("missing protected header")), + }; + + // Extract and validate alg from the protected header. + let alg: JwsAlgorithm = protected.alg().ok_or(Error::ProtectedHeaderWithoutAlg)?; + + let domain = match alg { + JwsAlgorithm::IdMldsa44Ed25519 => CompositeAlgId::IdMldsa44Ed25519.domain(), + JwsAlgorithm::IdMldsa65Ed25519 => CompositeAlgId::IdMldsa65Ed25519.domain(), + _ => return Err(Error::JwsAlgorithmParsingError), + }; + + // M' = Prefix || Domain || len(ctx) || ctx || M + //Prefix: CompositeAlgorithmSignatures2025 + let mut input = CompositeAlgId::COMPOSITE_SIGNATURE_PREFIX.to_vec(); + + //Domain: id-MLDSA44-Ed25519 or id-MLDSA65-Ed25519 + input.extend_from_slice(domain); + + //len(ctx) = 0 + input.push(0x00); + + //M + input.extend(signing_input); + + traditional_pk.check_alg(JwsAlgorithm::EdDSA.name())?; + + let (extracted_signature_t, extracted_signature_pq) = + decoded_signature.split_at(crypto::signatures::ed25519::Signature::LENGTH); + + // Construct verification input + let input1 = VerificationInput { + alg: JwsAlgorithm::EdDSA, + signing_input: input.clone().into(), + decoded_signature: extracted_signature_t.into(), + }; + + // Call the traditional verifier + traditional_verifier + .verify(input1, traditional_pk) + .map_err(Error::SignatureVerificationError)?; + + let input2 = VerificationInput { + alg, + signing_input: input.into(), + decoded_signature: extracted_signature_pq.into(), + }; + + // Call the PQ verifier + pq_verifier + .verify(input2, pq_pk) + .map_err(Error::SignatureVerificationError)?; + + Ok(DecodedJws { + protected, + unprotected, + claims, + }) + } } // ============================================================================================= diff --git a/identity_pqc_verifier/Cargo.toml b/identity_pqc_verifier/Cargo.toml new file mode 100644 index 0000000000..0e5129a807 --- /dev/null +++ b/identity_pqc_verifier/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "identity_pqc_verifier" +version = "1.6.0-beta" +authors.workspace = true +edition.workspace = true +homepage.workspace = true +keywords = ["iota", "identity", "jose", "jwk", "jws"] +license.workspace = true +readme = "./README.md" +repository.workspace = true + +description = "JWS PQC signature verification for IOTA Identity" + +[dependencies] +identity_jose = { version = "=1.6.0-beta", path = "../identity_jose", default-features = true } +oqs.workspace = true diff --git a/identity_pqc_verifier/README.md b/identity_pqc_verifier/README.md new file mode 100644 index 0000000000..e9d2246616 --- /dev/null +++ b/identity_pqc_verifier/README.md @@ -0,0 +1,4 @@ +IOTA Identity - PQC Verifier +=== + +This crate implements a `JwsVerifier` capable of verifying Post-Quantum (PQ) signatures, based on [liboqs-rust](https://github.com/open-quantum-safe/liboqs-rust) signatures implementation. \ No newline at end of file diff --git a/identity_pqc_verifier/src/lib.rs b/identity_pqc_verifier/src/lib.rs new file mode 100644 index 0000000000..bde0b543ba --- /dev/null +++ b/identity_pqc_verifier/src/lib.rs @@ -0,0 +1,8 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +mod oqs_verifier; +mod pqc_verifier; + +pub use oqs_verifier::*; +pub use pqc_verifier::*; diff --git a/identity_pqc_verifier/src/oqs_verifier.rs b/identity_pqc_verifier/src/oqs_verifier.rs new file mode 100644 index 0000000000..e932e113db --- /dev/null +++ b/identity_pqc_verifier/src/oqs_verifier.rs @@ -0,0 +1,131 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use identity_jose::jwk::CompositeAlgId; +use identity_jose::jwk::Jwk; +use identity_jose::jwk::JwkParamsAkp; +use identity_jose::jws::SignatureVerificationError; +use identity_jose::jws::SignatureVerificationErrorKind; +use identity_jose::jws::VerificationInput; +use oqs::sig::Algorithm; +use oqs::sig::Sig; +use std::ops::Deref; + +/// A verifier that can handle the [`Algorithm`] PQC algorithms. +#[derive(Debug)] +#[non_exhaustive] +pub struct OQSVerifier; + +impl OQSVerifier { + /// Verify a JWS signature secured with the [`Algorithm`] defined in liboqs. + pub fn verify(input: VerificationInput, public_key: &Jwk, alg: Algorithm) -> Result<(), SignatureVerificationError> { + let params: &JwkParamsAkp = public_key + .try_akp_params() + .map_err(|_| SignatureVerificationErrorKind::UnsupportedKeyType)?; + + let pk = identity_jose::jwu::decode_b64(params.public.as_str()).map_err(|_| { + SignatureVerificationError::new(SignatureVerificationErrorKind::KeyDecodingFailure) + .with_custom_message("could not decode 'pub' parameter from jwk") + })?; + + oqs::init(); + + let scheme = Sig::new(alg).map_err(|_| { + SignatureVerificationError::new(SignatureVerificationErrorKind::Unspecified) + .with_custom_message("signature scheme init failed") + })?; + + let public_key = scheme + .public_key_from_bytes(&pk) + .ok_or(SignatureVerificationError::new( + SignatureVerificationErrorKind::KeyDecodingFailure, + ))?; + + let signature = scheme + .signature_from_bytes(input.decoded_signature.deref()) + .ok_or(SignatureVerificationErrorKind::InvalidSignature)?; + + Ok( + scheme + .verify(&input.signing_input, signature, public_key) + .map_err(|_| SignatureVerificationErrorKind::InvalidSignature)?, + ) + } + + /// Verify a JWS signature signed with a ctx and secured with the [`Algorithm`] defined in liboqs, used in hybrid + /// signature. The ctx value is set as the Domain separator value for binding the signature to the Composite OID. + pub fn verify_hybrid_signature( + input: VerificationInput, + public_key: &Jwk, + alg: Algorithm, + ) -> Result<(), SignatureVerificationError> { + let params: &JwkParamsAkp = public_key + .try_akp_params() + .map_err(|_| SignatureVerificationErrorKind::UnsupportedKeyType)?; + + let pk = identity_jose::jwu::decode_b64(params.public.as_str()).map_err(|_| { + SignatureVerificationError::new(SignatureVerificationErrorKind::KeyDecodingFailure) + .with_custom_message("could not decode 'pub' parameter from jwk") + })?; + + oqs::init(); + + let scheme = Sig::new(alg).map_err(|_| { + SignatureVerificationError::new(SignatureVerificationErrorKind::Unspecified) + .with_custom_message("signature scheme init failed") + })?; + + let public_key = scheme + .public_key_from_bytes(&pk) + .ok_or(SignatureVerificationError::new( + SignatureVerificationErrorKind::KeyDecodingFailure, + ))?; + + let signature = scheme + .signature_from_bytes(input.decoded_signature.deref()) + .ok_or(SignatureVerificationErrorKind::InvalidSignature)?; + + let ctx = match alg { + Algorithm::MlDsa44 => CompositeAlgId::IdMldsa44Ed25519.domain(), + Algorithm::MlDsa65 => CompositeAlgId::IdMldsa65Ed25519.domain(), + _ => { + return Err(SignatureVerificationError::new( + SignatureVerificationErrorKind::UnsupportedKeyType, + )) + } + }; + + Ok( + scheme + .verify_with_ctx_str(&input.signing_input, signature, ctx, public_key) + .map_err(|_| SignatureVerificationErrorKind::InvalidSignature)?, + ) + } +} + +#[cfg(test)] +mod tests { + use oqs::sig::Algorithm; + use oqs::sig::Sig; + + #[test] + fn test_sig_and_verify() { + oqs::init(); + let scheme = Sig::new(Algorithm::MlDsa44).unwrap(); + let (pk, sk) = scheme.keypair().unwrap(); + let message = b"test_message"; + let signature = scheme.sign(message, &sk).unwrap(); + assert!(scheme.verify(message, &signature, &pk).is_ok()); + } + + #[test] + fn test_sig_and_invalid_verify() { + oqs::init(); + let scheme = Sig::new(Algorithm::MlDsa87).unwrap(); + let (pk, sk) = scheme.keypair().unwrap(); + let message = b"test_message"; + let wrong_message = b"wrong_message"; + let signature = scheme.sign(message, &sk).unwrap(); + assert!(scheme.verify(wrong_message, &signature, &pk).is_err()); + } +} diff --git a/identity_pqc_verifier/src/pqc_verifier.rs b/identity_pqc_verifier/src/pqc_verifier.rs new file mode 100644 index 0000000000..17dd75e875 --- /dev/null +++ b/identity_pqc_verifier/src/pqc_verifier.rs @@ -0,0 +1,51 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use identity_jose::jwk::Jwk; +use identity_jose::jws::JwsAlgorithm; +use identity_jose::jws::JwsVerifier; +use identity_jose::jws::SignatureVerificationError; +use identity_jose::jws::SignatureVerificationErrorKind; +use identity_jose::jws::VerificationInput; +use oqs::sig::Algorithm; + +use crate::OQSVerifier; + +/// An implementor of [`JwsVerifier`] that can handle the +/// [`JwsAlgorithm::ML_DSA_44`](identity_jose::jws::JwsAlgorithm::ML_DSA_44) +/// | [`JwsAlgorithm::ML_DSA_65`](identity_jose::jws::JwsAlgorithm::ML_DSA_65) +/// | [`JwsAlgorithm::ML_DSA_87`](identity_jose::jws::JwsAlgorithm::ML_DSA_87) +/// | [`JwsAlgorithm::IdMldsa44Ed25519`](identity_jose::jws::JwsAlgorithm::IdMldsa44Ed25519) +/// | [`JwsAlgorithm::IdMldsa65Ed25519`](identity_jose::jws::JwsAlgorithm::IdMldsa65Ed25519) algorithms. +#[derive(Debug)] +#[non_exhaustive] +pub struct PQCJwsVerifier; + +impl Default for PQCJwsVerifier { + /// Constructs an [`PQCJwsVerifier`]. This is the only way to obtain an [`PQCJwsVerifier`]. + fn default() -> Self { + Self + } +} + +impl JwsVerifier for PQCJwsVerifier { + /// This implements verification of JWS signatures signed with the + /// [`JwsAlgorithm::ML_DSA_44`](identity_jose::jws::JwsAlgorithm::ML_DSA_44) + /// | [`JwsAlgorithm::ML_DSA_65`](identity_jose::jws::JwsAlgorithm::ML_DSA_65) + /// | [`JwsAlgorithm::ML_DSA_87`](identity_jose::jws::JwsAlgorithm::ML_DSA_87) + /// | [`JwsAlgorithm::IdMldsa44Ed25519`](identity_jose::jws::JwsAlgorithm::IdMldsa44Ed25519) + /// | [`JwsAlgorithm::IdMldsa65Ed25519`](identity_jose::jws::JwsAlgorithm::IdMldsa65Ed25519) algorithms. + // Allow unused variables in case of no-default-features. + #[allow(unused_variables)] + fn verify(&self, input: VerificationInput, public_key: &Jwk) -> std::result::Result<(), SignatureVerificationError> { + match input.alg { + JwsAlgorithm::ML_DSA_44 => OQSVerifier::verify(input, public_key, Algorithm::MlDsa44), + JwsAlgorithm::ML_DSA_65 => OQSVerifier::verify(input, public_key, Algorithm::MlDsa65), + JwsAlgorithm::ML_DSA_87 => OQSVerifier::verify(input, public_key, Algorithm::MlDsa87), + JwsAlgorithm::IdMldsa44Ed25519 => OQSVerifier::verify_hybrid_signature(input, public_key, Algorithm::MlDsa44), + JwsAlgorithm::IdMldsa65Ed25519 => OQSVerifier::verify_hybrid_signature(input, public_key, Algorithm::MlDsa65), + + _ => Err(SignatureVerificationErrorKind::UnsupportedAlg.into()), + } + } +} diff --git a/identity_resolver/src/resolution/resolver.rs b/identity_resolver/src/resolution/resolver.rs index 4519c45d39..423d0ca384 100644 --- a/identity_resolver/src/resolution/resolver.rs +++ b/identity_resolver/src/resolution/resolver.rs @@ -1,9 +1,10 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use core::future::Future; use futures::stream::FuturesUnordered; use futures::TryStreamExt; +use identity_did::DIDCompositeJwk; use identity_did::DIDJwk; use identity_did::DID; use std::collections::HashSet; @@ -264,6 +265,24 @@ impl + 'static> Resolver> { } } +impl + 'static> Resolver> { + /// Attaches a handler capable of resolving `did:compositejwk` DIDs. + pub fn attach_did_compositejwk_handler(&mut self) { + let handler = + |did_compositejwk: DIDCompositeJwk| async move { CoreDocument::expand_did_compositejwk(did_compositejwk) }; + self.attach_handler(DIDCompositeJwk::METHOD.to_string(), handler) + } +} + +impl + 'static> Resolver> { + /// Attaches a handler capable of resolving `did:compositejwk` DIDs. + pub fn attach_did_compositejwk_handler(&mut self) { + let handler = + |did_compositejwk: DIDCompositeJwk| async move { CoreDocument::expand_did_compositejwk(did_compositejwk) }; + self.attach_handler(DIDCompositeJwk::METHOD.to_string(), handler) + } +} + #[cfg(all(feature = "iota", not(target_arch = "wasm32")))] mod iota_handler { use crate::ErrorCause; diff --git a/identity_storage/Cargo.toml b/identity_storage/Cargo.toml index ae7ca3cca4..5e19d36173 100644 --- a/identity_storage/Cargo.toml +++ b/identity_storage/Cargo.toml @@ -26,6 +26,7 @@ identity_verification = { version = "=1.6.0-beta", path = "../identity_verificat iota-crypto = { version = "0.23.2", default-features = false, features = ["ed25519", "random"], optional = true } json-proof-token = { workspace = true, optional = true } k256 = { version = "0.13.3", default-features = false, features = ["std", "ecdsa", "ecdsa-core", "jwk"], optional = true } +oqs = { workspace = true, optional = true } p256 = { version = "0.13.2", default-features = false, features = ["std", "ecdsa", "ecdsa-core", "jwk"], optional = true } rand = { version = "0.8.5", default-features = false, features = ["std", "std_rng"], optional = true } seahash = { version = "4.1.0", default-features = false } @@ -37,17 +38,17 @@ tokio = { version = "1.46.1", default-features = false, features = ["macros", "s zkryptium = { workspace = true, optional = true } [target.'cfg(not(target_arch = "wasm32"))'.dependencies] -iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction", optional = true } +iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction", optional = true } [target.'cfg(target_arch = "wasm32")'.dependencies] -iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "iota_interaction", default-features = false, optional = true } +iota_interaction = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "iota_interaction", default-features = false, optional = true } [dev-dependencies] identity_credential = { version = "=1.6.0-beta", path = "../identity_credential", features = ["revocation-bitmap"] } identity_ecdsa_verifier = { version = "=1.6.0-beta", path = "../identity_ecdsa_verifier", default-features = false, features = ["es256"] } identity_eddsa_verifier = { version = "=1.6.0-beta", path = "../identity_eddsa_verifier", default-features = false, features = ["ed25519"] } once_cell = { version = "1.18", default-features = false } -product_common = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.0", package = "product_common", default-features = false } +product_common = { git = "https://github.com/iotaledger/product-core.git", tag = "v0.8.3", package = "product_common", default-features = false } tokio = { version = "1.46.1", default-features = false, features = ["macros", "sync", "rt"] } [features] @@ -84,5 +85,11 @@ keytool = [ "dep:fastcrypto", ] +# Enables PQC (JwkStoragePQ implementation needed) +pqc = [] +pqc-liboqs = ["pqc", "memstore", "dep:oqs"] +hybrid = ["pqc", "dep:iota-crypto"] +hybrid-liboqs = ["hybrid", "pqc-liboqs"] + [lints] workspace = true diff --git a/identity_storage/src/key_id_storage/method_digest.rs b/identity_storage/src/key_id_storage/method_digest.rs index c6eb4fd59d..122ab4644b 100644 --- a/identity_storage/src/key_id_storage/method_digest.rs +++ b/identity_storage/src/key_id_storage/method_digest.rs @@ -1,6 +1,7 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 +use identity_core::convert::ToJson; use identity_verification::MethodData; use identity_verification::VerificationMethod; use seahash::SeaHasher; @@ -56,6 +57,15 @@ impl MethodDigest { match method_data { MethodData::PublicKeyJwk(jwk) => hasher.write(jwk.thumbprint_sha256().as_ref()), + MethodData::CompositeJwk(composite) => { + let algid = composite + .alg_id() + .to_json_vec() + .map_err(|err| MethodDigestConstructionError::new(DataDecodingFailure).with_source(err))?; + hasher.write(&algid); + hasher.write(composite.traditional_public_key().thumbprint_sha256().as_ref()); + hasher.write(composite.pq_public_key().thumbprint_sha256().as_ref()); + } _ => hasher.write( &method_data .try_decode() diff --git a/identity_storage/src/key_storage/bls.rs b/identity_storage/src/key_storage/bls.rs index 2a3b38a0a7..f1ec6dd273 100644 --- a/identity_storage/src/key_storage/bls.rs +++ b/identity_storage/src/key_storage/bls.rs @@ -31,8 +31,8 @@ where /// Generates a new BBS+ keypair using either `BLS12381-SHA256` or `BLS12381-SHAKE256`. pub fn generate_bbs_keypair(alg: ProofAlgorithm) -> KeyStorageResult<(BBSplusSecretKey, BBSplusPublicKey)> { match alg { - ProofAlgorithm::BLS12381_SHA256 => random_bbs_keypair::(), - ProofAlgorithm::BLS12381_SHAKE256 => random_bbs_keypair::(), + ProofAlgorithm::BBS => random_bbs_keypair::(), + ProofAlgorithm::BBS_SHAKE256 => random_bbs_keypair::(), _ => return Err(KeyStorageErrorKind::UnsupportedProofAlgorithm.into()), } .map_err(|err| KeyStorageError::new(KeyStorageErrorKind::Unspecified).with_source(err)) @@ -130,8 +130,8 @@ pub fn sign_bbs( header: &[u8], ) -> KeyStorageResult> { match alg { - ProofAlgorithm::BLS12381_SHA256 => _sign_bbs::(data, sk, pk, header), - ProofAlgorithm::BLS12381_SHAKE256 => _sign_bbs::(data, sk, pk, header), + ProofAlgorithm::BBS => _sign_bbs::(data, sk, pk, header), + ProofAlgorithm::BBS_SHAKE256 => _sign_bbs::(data, sk, pk, header), _ => return Err(KeyStorageErrorKind::UnsupportedProofAlgorithm.into()), } .map_err(|e| { @@ -188,10 +188,8 @@ pub fn update_bbs_signature( KeyStorageError::new(KeyStorageErrorKind::Unspecified).with_custom_message("invalid signature size".to_owned()) })?; match alg { - ProofAlgorithm::BLS12381_SHA256 => _update_bbs_signature::(exact_size_signature, sk, update_ctx), - ProofAlgorithm::BLS12381_SHAKE256 => { - _update_bbs_signature::(exact_size_signature, sk, update_ctx) - } + ProofAlgorithm::BBS => _update_bbs_signature::(exact_size_signature, sk, update_ctx), + ProofAlgorithm::BBS_SHAKE256 => _update_bbs_signature::(exact_size_signature, sk, update_ctx), _ => return Err(KeyStorageErrorKind::UnsupportedProofAlgorithm.into()), } .map(Vec::from) diff --git a/identity_storage/src/key_storage/jwk_storage_pqc.rs b/identity_storage/src/key_storage/jwk_storage_pqc.rs new file mode 100644 index 0000000000..0d53d515b7 --- /dev/null +++ b/identity_storage/src/key_storage/jwk_storage_pqc.rs @@ -0,0 +1,29 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use crate::key_storage::KeyId; +use crate::key_storage::KeyType; +use async_trait::async_trait; +use identity_verification::jose::jws::JwsAlgorithm; +use identity_verification::jwk::PostQuantumJwk; + +use super::jwk_gen_output::JwkGenOutput; +use super::JwkStorage; +use super::KeyStorageResult; + +/// Extension to the JwkStorage to handle post-quantum keys. +#[cfg_attr(not(feature = "send-sync-storage"), async_trait(?Send))] +#[cfg_attr(feature = "send-sync-storage", async_trait)] +pub trait JwkStoragePQ: JwkStorage { + /// Generates a JWK representing a PQ key. + async fn generate_pq_key(&self, key_type: KeyType, alg: JwsAlgorithm) -> KeyStorageResult; + + /// Sign the provided `data` using a PQ algorithm, ctx is optional for the ctx paramter of the algorithm ML-DSA. + async fn pq_sign( + &self, + key_id: &KeyId, + data: &[u8], + public_key: &PostQuantumJwk, + ctx: Option<&[u8]>, + ) -> KeyStorageResult>; +} diff --git a/identity_storage/src/key_storage/memstore.rs b/identity_storage/src/key_storage/memstore.rs index 076dbba98d..815586ba02 100644 --- a/identity_storage/src/key_storage/memstore.rs +++ b/identity_storage/src/key_storage/memstore.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung, Fondazione Links +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links // SPDX-License-Identifier: Apache-2.0 use core::fmt::Debug; @@ -207,6 +207,10 @@ impl JwkMemStore { const BLS12381G2_KEY_TYPE_STR: &'static str = "BLS12381G2"; /// The BLS12381G2 key type pub const BLS12381G2_KEY_TYPE: KeyType = KeyType::from_static_str(Self::BLS12381G2_KEY_TYPE_STR); + + const PQ_KEY_TYPE_STR: &'static str = "AKP"; + /// ML-DSA algorithms key types; + pub const PQ_KEY_TYPE: KeyType = KeyType::from_static_str(Self::PQ_KEY_TYPE_STR); } impl MemStoreKeyType { @@ -307,6 +311,250 @@ fn check_key_alg_compatibility(key_type: MemStoreKeyType, alg: &JwsAlgorithm) -> } } +#[cfg(feature = "pqc-liboqs")] +mod pqc_liboqs { + use async_trait::async_trait; + use identity_verification::jose::jwk::Jwk; + use identity_verification::jose::jwk::JwkType; + use identity_verification::jose::jws::JwsAlgorithm; + use identity_verification::jwk::JwkParams; + use identity_verification::jwk::PostQuantumJwk; + use identity_verification::jwu; + use oqs::sig::Algorithm; + use oqs::sig::Sig; + use std::str::FromStr; + use tokio::sync::RwLockReadGuard; + use tokio::sync::RwLockWriteGuard; + + use super::random_key_id; + use super::JwkKeyStore; + use super::JwkMemStore; + use super::KeyId; + use super::KeyStorageError; + use super::KeyStorageErrorKind; + use super::KeyStorageResult; + use super::KeyType; + use crate::key_storage::jwk_storage_pqc::JwkStoragePQ; + use crate::JwkGenOutput; + + fn check_pq_alg_compatibility(alg: &JwsAlgorithm) -> KeyStorageResult { + match alg { + JwsAlgorithm::ML_DSA_44 => Ok(Algorithm::MlDsa44), + JwsAlgorithm::ML_DSA_65 => Ok(Algorithm::MlDsa65), + JwsAlgorithm::ML_DSA_87 => Ok(Algorithm::MlDsa87), + JwsAlgorithm::SLH_DSA_SHA2_128s => Ok(Algorithm::SphincsSha2128sSimple), + JwsAlgorithm::SLH_DSA_SHAKE_128s => Ok(Algorithm::SphincsShake128sSimple), + JwsAlgorithm::SLH_DSA_SHA2_128f => Ok(Algorithm::SphincsSha2128fSimple), + + JwsAlgorithm::SLH_DSA_SHAKE_128f => Ok(Algorithm::SphincsShake128fSimple), + JwsAlgorithm::SLH_DSA_SHA2_192s => Ok(Algorithm::SphincsSha2192sSimple), + JwsAlgorithm::SLH_DSA_SHAKE_192s => Ok(Algorithm::SphincsShake192sSimple), + JwsAlgorithm::SLH_DSA_SHA2_192f => Ok(Algorithm::SphincsSha2192fSimple), + JwsAlgorithm::SLH_DSA_SHAKE_192f => Ok(Algorithm::SphincsShake192fSimple), + JwsAlgorithm::SLH_DSA_SHA2_256s => Ok(Algorithm::SphincsSha2256sSimple), + JwsAlgorithm::SLH_DSA_SHAKE_256s => Ok(Algorithm::SphincsShake256sSimple), + JwsAlgorithm::SLH_DSA_SHA2_256f => Ok(Algorithm::SphincsSha2256fSimple), + JwsAlgorithm::SLH_DSA_SHAKE_256f => Ok(Algorithm::SphincsShake256fSimple), + + JwsAlgorithm::FALCON512 => Ok(Algorithm::Falcon512), + JwsAlgorithm::FALCON1024 => Ok(Algorithm::Falcon1024), + other => Err( + KeyStorageError::new(KeyStorageErrorKind::UnsupportedSignatureAlgorithm) + .with_custom_message(format!("{other} is not supported")), + ), + } + } + + /// JwkStoragePQ implementation for JwkMemStore based on liboqs. + #[cfg_attr(not(feature = "send-sync-storage"), async_trait(?Send))] + #[cfg_attr(feature = "send-sync-storage", async_trait)] + impl JwkStoragePQ for JwkMemStore { + async fn generate_pq_key(&self, key_type: KeyType, alg: JwsAlgorithm) -> KeyStorageResult { + if key_type != JwkMemStore::PQ_KEY_TYPE { + return Err( + KeyStorageError::new(KeyStorageErrorKind::UnsupportedKeyType) + .with_custom_message(format!("unsupported key type {key_type}")), + ); + } + + let oqs_alg = check_pq_alg_compatibility(&alg)?; + oqs::init(); + + let scheme = Sig::new(oqs_alg).map_err(|err| { + KeyStorageError::new(KeyStorageErrorKind::Unspecified) + .with_custom_message("signature scheme init failed".to_string()) + .with_source(err) + })?; + let (pk, sk) = scheme.keypair().map_err(|err| { + KeyStorageError::new(KeyStorageErrorKind::Unspecified) + .with_custom_message("keypair generation failed!".to_string()) + .with_source(err) + })?; + + let kid: KeyId = random_key_id(); + + let public = jwu::encode_b64(pk.into_vec()); + let private = jwu::encode_b64(sk.into_vec()); + + let mut jwk_params = match alg { + JwsAlgorithm::ML_DSA_44 => JwkParams::new(JwkType::Akp), + JwsAlgorithm::ML_DSA_65 => JwkParams::new(JwkType::Akp), + JwsAlgorithm::ML_DSA_87 => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHA2_128s => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHAKE_128s => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHA2_128f => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHAKE_128f => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHA2_192s => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHAKE_192s => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHA2_192f => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHAKE_192f => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHA2_256s => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHAKE_256s => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHA2_256f => JwkParams::new(JwkType::Akp), + JwsAlgorithm::SLH_DSA_SHAKE_256f => JwkParams::new(JwkType::Akp), + JwsAlgorithm::FALCON512 => JwkParams::new(JwkType::Akp), + JwsAlgorithm::FALCON1024 => JwkParams::new(JwkType::Akp), + other => { + return Err( + KeyStorageError::new(KeyStorageErrorKind::UnsupportedSignatureAlgorithm) + .with_custom_message(format!("{other} is not supported")), + ); + } + }; + + match jwk_params { + JwkParams::Akp(ref mut params) => { + params.public = public; + params.private = Some(private); + } + _ => { + return Err( + KeyStorageError::new(KeyStorageErrorKind::UnsupportedKeyType).with_custom_message("Should NOT happen!"), + ) + } + } + + let mut jwk = Jwk::from_params(jwk_params); + + jwk.set_alg(alg.name()); + jwk.set_kid(jwk.thumbprint_sha256_b64()); + let public_jwk: Jwk = jwk.to_public().expect("should only panic if kty == oct"); + + let mut jwk_store: RwLockWriteGuard<'_, JwkKeyStore> = self.jwk_store.write().await; + jwk_store.insert(kid.clone(), jwk); + + Ok(JwkGenOutput::new(kid, public_jwk)) + } + + async fn pq_sign( + &self, + key_id: &KeyId, + data: &[u8], + public_key: &PostQuantumJwk, + ctx: Option<&[u8]>, + ) -> KeyStorageResult> { + let jwk_store: RwLockReadGuard<'_, JwkKeyStore> = self.jwk_store.read().await; + + // Extract the required alg from the given public key + let alg = public_key + .alg() + .ok_or(KeyStorageErrorKind::UnsupportedSignatureAlgorithm) + .and_then(|alg_str| { + JwsAlgorithm::from_str(alg_str).map_err(|_| KeyStorageErrorKind::UnsupportedSignatureAlgorithm) + })?; + + let oqs_alg = check_pq_alg_compatibility(&alg)?; + + // Check that `kty` is `AKP`. + match alg { + JwsAlgorithm::ML_DSA_44 + | JwsAlgorithm::ML_DSA_65 + | JwsAlgorithm::ML_DSA_87 + | JwsAlgorithm::SLH_DSA_SHA2_128s + | JwsAlgorithm::SLH_DSA_SHAKE_128s + | JwsAlgorithm::SLH_DSA_SHA2_128f + | JwsAlgorithm::SLH_DSA_SHAKE_128f + | JwsAlgorithm::SLH_DSA_SHA2_192s + | JwsAlgorithm::SLH_DSA_SHAKE_192s + | JwsAlgorithm::SLH_DSA_SHA2_192f + | JwsAlgorithm::SLH_DSA_SHAKE_192f + | JwsAlgorithm::SLH_DSA_SHA2_256s + | JwsAlgorithm::SLH_DSA_SHAKE_256s + | JwsAlgorithm::SLH_DSA_SHA2_256f + | JwsAlgorithm::SLH_DSA_SHAKE_256f + | JwsAlgorithm::FALCON512 + | JwsAlgorithm::FALCON1024 => public_key.try_akp_params().map_err(|err| { + KeyStorageError::new(KeyStorageErrorKind::Unspecified) + .with_custom_message(format!("expected a Jwk with AKP params in order to sign with {alg}")) + .with_source(err) + })?, + other => { + return Err( + KeyStorageError::new(KeyStorageErrorKind::UnsupportedSignatureAlgorithm) + .with_custom_message(format!("{other} is not supported")), + ); + } + }; + + // Obtain the corresponding private key and sign `data`. + let jwk: &Jwk = jwk_store + .get(key_id) + .ok_or_else(|| KeyStorageError::new(KeyStorageErrorKind::KeyNotFound))?; + + let params = jwk.try_akp_params().unwrap(); + + let sk_bytes = params + .private + .as_deref() + .map(jwu::decode_b64) + .ok_or_else(|| { + KeyStorageError::new(KeyStorageErrorKind::Unspecified) + .with_custom_message("expected Jwk `private` param to be present") + })? + .map_err(|err| { + KeyStorageError::new(KeyStorageErrorKind::Unspecified) + .with_custom_message("unable to decode `private` param") + .with_source(err) + })?; + oqs::init(); + + let scheme = Sig::new(oqs_alg).map_err(|err| { + KeyStorageError::new(KeyStorageErrorKind::Unspecified) + .with_custom_message("signature scheme init failed".to_string()) + .with_source(err) + })?; + + let secret_key = scheme.secret_key_from_bytes(&sk_bytes).ok_or( + KeyStorageError::new(KeyStorageErrorKind::Unspecified).with_custom_message("invalid private key".to_string()), + )?; + + let signature: oqs::sig::Signature; + + if let Some(ctx) = ctx { + if !scheme.has_ctx_str_support() { + return Err( + KeyStorageError::new(KeyStorageErrorKind::Unspecified) + .with_custom_message("signature with ctx is not supported with this algorithm".to_string()), + ); + } + signature = scheme.sign_with_ctx_str(data, ctx, secret_key).map_err(|err| { + KeyStorageError::new(KeyStorageErrorKind::Unspecified) + .with_custom_message("signature computation failed".to_string()) + .with_source(err) + })?; + } else { + signature = scheme.sign(data, secret_key).map_err(|err| { + KeyStorageError::new(KeyStorageErrorKind::Unspecified) + .with_custom_message("signature computation failed".to_string()) + .with_source(err) + })?; + } + + Ok(signature.into_vec()) + } + } +} + #[cfg(feature = "jpt-bbs-plus")] mod bbs_plus_impl { use std::str::FromStr as _; diff --git a/identity_storage/src/key_storage/mod.rs b/identity_storage/src/key_storage/mod.rs index 0a949b011c..b1bf201d35 100644 --- a/identity_storage/src/key_storage/mod.rs +++ b/identity_storage/src/key_storage/mod.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 //! A Key Storage is used to securely store private keys. @@ -13,6 +13,8 @@ mod jwk_gen_output; mod jwk_storage; #[cfg(feature = "jpt-bbs-plus")] mod jwk_storage_bbs_plus_ext; +#[cfg(feature = "pqc")] +mod jwk_storage_pqc; mod key_id; mod key_storage_error; mod key_type; @@ -30,6 +32,8 @@ pub mod public_modules { pub use super::jwk_storage::*; #[cfg(feature = "jpt-bbs-plus")] pub use super::jwk_storage_bbs_plus_ext::*; + #[cfg(feature = "pqc")] + pub use super::jwk_storage_pqc::*; pub use super::key_id::*; pub use super::key_storage_error::*; pub use super::key_type::*; diff --git a/identity_storage/src/storage/did_jwk_document_ext.rs b/identity_storage/src/storage/did_jwk_document_ext.rs new file mode 100644 index 0000000000..285e9a6e68 --- /dev/null +++ b/identity_storage/src/storage/did_jwk_document_ext.rs @@ -0,0 +1,265 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use crate::JwkGenOutput; +use crate::JwkStorage; +#[cfg(feature = "jpt-bbs-plus")] +use crate::JwkStorageBbsPlusExt; +use crate::JwkStorageDocumentError as Error; +#[cfg(feature = "pqc")] +use crate::JwkStoragePQ; +#[cfg(feature = "hybrid")] +use crate::KeyId; +use crate::KeyIdStorage; +use crate::KeyType; +use crate::MethodDigest; +use async_trait::async_trait; +#[cfg(feature = "hybrid")] +use identity_did::DIDCompositeJwk; +use identity_did::DIDJwk; +use identity_document::document::CoreDocument; +#[cfg(feature = "hybrid")] +use identity_verification::jwk::CompositeAlgId; +#[cfg(feature = "hybrid")] +use identity_verification::jwk::CompositeJwk; +use identity_verification::jws::JwsAlgorithm; +use identity_verification::jwu::encode_b64_json; +#[cfg(feature = "jpt-bbs-plus")] +use jsonprooftoken::jpa::algs::ProofAlgorithm; + +use super::Storage; +use super::StorageResult; + +/// Extension trait for creating JWK-based DID documents for traditional, zk, PQ and hybrid keys +#[cfg_attr(not(feature = "send-sync-storage"), async_trait(?Send))] +#[cfg_attr(feature = "send-sync-storage", async_trait)] +pub trait DidJwkDocumentExt { + /// Create a JWK-based DID documents with traditional keys. Returns the DID document and the fragment + async fn new_did_jwk( + storage: &Storage, + key_type: KeyType, + alg: JwsAlgorithm, + ) -> StorageResult<(CoreDocument, String)> + where + K: JwkStorage, + I: KeyIdStorage; + /// Create a JWK-based DID documents with PQ keys. Returns the DID document and the fragment + #[cfg(feature = "pqc")] + async fn new_did_jwk_pqc( + storage: &Storage, + key_type: KeyType, + alg: JwsAlgorithm, + ) -> StorageResult<(CoreDocument, String)> + where + K: JwkStoragePQ, + I: KeyIdStorage; + /// Create a JWK-based DID documents with zk keys. Returns the DID document and the fragment + #[cfg(feature = "jpt-bbs-plus")] + async fn new_did_jwk_zk( + storage: &Storage, + key_type: KeyType, + alg: ProofAlgorithm, + ) -> StorageResult<(CoreDocument, String)> + where + K: JwkStorageBbsPlusExt, + I: KeyIdStorage; + + /// Create a JWK-based DID documents with hybrid keys. Returns the DID document and the fragment + #[cfg(feature = "hybrid")] + async fn new_did_compositejwk( + storage: &Storage, + alg: identity_verification::jwk::CompositeAlgId, + ) -> StorageResult<(CoreDocument, String)> + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage; +} + +#[cfg_attr(not(feature = "send-sync-storage"), async_trait(?Send))] +#[cfg_attr(feature = "send-sync-storage", async_trait)] +impl DidJwkDocumentExt for CoreDocument { + async fn new_did_jwk( + storage: &Storage, + key_type: KeyType, + alg: JwsAlgorithm, + ) -> StorageResult<(CoreDocument, String)> + where + K: JwkStorage, + I: KeyIdStorage, + { + let JwkGenOutput { key_id, jwk } = K::generate(storage.key_storage(), key_type, alg) + .await + .map_err(Error::KeyStorageError)?; + + let b64 = encode_b64_json(&jwk).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let did = + DIDJwk::parse(format!("{}{}", "did:jwk:", b64).as_str()).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let document = CoreDocument::expand_did_jwk(did).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let fragment = "0"; + + let verification_method = document + .resolve_method(fragment, None) + .ok_or(identity_verification::Error::MissingIdFragment) + .map_err(Error::VerificationMethodConstructionError)?; + + let method_digest = MethodDigest::new(verification_method).map_err(Error::MethodDigestConstructionError)?; + + I::insert_key_id(storage.key_id_storage(), method_digest, key_id.clone()) + .await + .map_err(Error::KeyIdStorageError)?; + + Ok((document, fragment.to_string())) + } + + #[cfg(feature = "pqc")] + async fn new_did_jwk_pqc( + storage: &Storage, + key_type: KeyType, + alg: JwsAlgorithm, + ) -> StorageResult<(CoreDocument, String)> + where + K: JwkStoragePQ, + I: KeyIdStorage, + { + let JwkGenOutput { key_id, jwk } = K::generate_pq_key(storage.key_storage(), key_type, alg) + .await + .map_err(Error::KeyStorageError)?; + + let b64 = encode_b64_json(&jwk).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let did = + DIDJwk::parse(format!("{}{}", "did:jwk:", b64).as_str()).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let document = CoreDocument::expand_did_jwk(did).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let fragment = "0"; + + let verification_method = document + .resolve_method(fragment, None) + .ok_or(identity_verification::Error::MissingIdFragment) + .map_err(Error::VerificationMethodConstructionError)?; + + let method_digest = MethodDigest::new(verification_method).map_err(Error::MethodDigestConstructionError)?; + + I::insert_key_id(storage.key_id_storage(), method_digest, key_id.clone()) + .await + .map_err(Error::KeyIdStorageError)?; + + Ok((document, fragment.to_string())) + } + + #[cfg(feature = "jpt-bbs-plus")] + async fn new_did_jwk_zk( + storage: &Storage, + key_type: KeyType, + alg: ProofAlgorithm, + ) -> StorageResult<(CoreDocument, String)> + where + K: JwkStorageBbsPlusExt, + I: KeyIdStorage, + { + let JwkGenOutput { key_id, jwk } = K::generate_bbs(storage.key_storage(), key_type, alg) + .await + .map_err(Error::KeyStorageError)?; + + let b64 = encode_b64_json(&jwk).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let did = + DIDJwk::parse(format!("{}{}", "did:jwk:", b64).as_str()).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let document = CoreDocument::expand_did_jwk(did).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let fragment = "0"; + + let verification_method = document + .resolve_method(fragment, None) + .ok_or(identity_verification::Error::MissingIdFragment) + .map_err(Error::VerificationMethodConstructionError)?; + + let method_digest = MethodDigest::new(verification_method).map_err(Error::MethodDigestConstructionError)?; + + I::insert_key_id(storage.key_id_storage(), method_digest, key_id.clone()) + .await + .map_err(Error::KeyIdStorageError)?; + + Ok((document, fragment.to_string())) + } + + #[cfg(feature = "hybrid")] + async fn new_did_compositejwk( + storage: &Storage, + alg: CompositeAlgId, + ) -> StorageResult<(CoreDocument, String)> + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + { + use identity_verification::jwk::PostQuantumJwk; + use identity_verification::jwk::TraditionalJwk; + + let (pq_key_type, pq_alg, trad_key_type, trad_alg) = match alg { + CompositeAlgId::IdMldsa44Ed25519 => ( + KeyType::from_static_str("AKP"), + JwsAlgorithm::ML_DSA_44, + KeyType::from_static_str("Ed25519"), + JwsAlgorithm::EdDSA, + ), + CompositeAlgId::IdMldsa65Ed25519 => ( + KeyType::from_static_str("AKP"), + JwsAlgorithm::ML_DSA_65, + KeyType::from_static_str("Ed25519"), + JwsAlgorithm::EdDSA, + ), + _ => { + return Err(Error::InvalidJwsAlgorithm); + } + }; + + let JwkGenOutput { + key_id: t_key_id, + jwk: t_jwk, + } = K::generate(storage.key_storage(), trad_key_type, trad_alg) + .await + .map_err(Error::KeyStorageError)?; + + let JwkGenOutput { + key_id: pq_key_id, + jwk: pq_jwk, + } = K::generate_pq_key(storage.key_storage(), pq_key_type, pq_alg) + .await + .map_err(Error::KeyStorageError)?; + + let key_id = KeyId::new(format!("{}~{}", t_key_id.as_str(), pq_key_id.as_str())); + + let pq_jwk = PostQuantumJwk::try_from(pq_jwk).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let traditional_jwk = TraditionalJwk::try_from(t_jwk).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let composite_pk = CompositeJwk::new(alg, traditional_jwk, pq_jwk); + + let b64 = encode_b64_json(&composite_pk).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let did = DIDCompositeJwk::parse(format!("{}{}", "did:compositejwk:", b64).as_str()) + .map_err(|err| Error::EncodingError(Box::new(err)))?; + + let document = CoreDocument::expand_did_compositejwk(did).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let fragment = "0"; + + let verification_method = document + .resolve_method(fragment, None) + .ok_or(identity_verification::Error::MissingIdFragment) + .map_err(Error::VerificationMethodConstructionError)?; + + let method_digest = MethodDigest::new(verification_method).map_err(Error::MethodDigestConstructionError)?; + + I::insert_key_id(storage.key_id_storage(), method_digest, key_id.clone()) + .await + .map_err(Error::KeyIdStorageError)?; + + Ok((document, fragment.to_string())) + } +} diff --git a/identity_storage/src/storage/error.rs b/identity_storage/src/storage/error.rs index 307ecf24fb..dcb1f2a18e 100644 --- a/identity_storage/src/storage/error.rs +++ b/identity_storage/src/storage/error.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use crate::key_id_storage::KeyIdStorageError; @@ -24,6 +24,9 @@ pub enum JwkStorageDocumentError { /// Caused by the usage of a non-JWK method where a JWK method is expected. #[error("invalid method data format: expected publicKeyJwk")] NotPublicKeyJwk, + /// Caused by the usage of a non-Composite method where a Composite method is expected. + #[error("invalid method data format: expected compositePublicKey")] + NotCompositePublicKey, /// Caused by an invalid JWS algorithm. #[error("invalid JWS algorithm")] InvalidJwsAlgorithm, diff --git a/identity_storage/src/storage/hybrid_jws_document_ext.rs b/identity_storage/src/storage/hybrid_jws_document_ext.rs new file mode 100644 index 0000000000..193d2778f9 --- /dev/null +++ b/identity_storage/src/storage/hybrid_jws_document_ext.rs @@ -0,0 +1,512 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use super::JwkStorageDocumentError as Error; +use crate::try_undo_key_generation; +use crate::JwkGenOutput; +use crate::JwkStorage; +use crate::JwkStoragePQ; +use crate::JwsSignatureOptions; +use crate::KeyId; +use crate::KeyIdStorage; +use crate::KeyIdStorageErrorKind; +use crate::KeyType; +use crate::MethodDigest; +use crate::Storage; +use crate::StorageResult; +use async_trait::async_trait; +use identity_core::common::Object; +use identity_credential::credential::Credential; +use identity_credential::credential::Jws; +use identity_credential::credential::Jwt; +use identity_credential::presentation::JwtPresentationOptions; +use identity_credential::presentation::Presentation; +use identity_did::DIDUrl; +use identity_document::document::CoreDocument; +use identity_verification::jwk::CompositeAlgId; +use identity_verification::jwk::CompositeJwk; +use identity_verification::jwk::PostQuantumJwk; +use identity_verification::jwk::TraditionalJwk; +use identity_verification::jws::CharSet; +use identity_verification::jws::CompactJwsEncoder; +use identity_verification::jws::CompactJwsEncodingOptions; +use identity_verification::jws::JwsAlgorithm; +use identity_verification::jws::JwsHeader; +use identity_verification::MethodData; +use identity_verification::MethodScope; +use identity_verification::VerificationMethod; +use serde::de::DeserializeOwned; +use serde::Serialize; + +macro_rules! generate_method_hybrid_for_document_type { + ($t:ty, $name:ident) => { + async fn $name( + document: &mut $t, + storage: &Storage, + alg_id: CompositeAlgId, + fragment: Option<&str>, + scope: MethodScope, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + { + let (pq_key_type, pq_alg, trad_key_type, trad_alg) = match alg_id { + CompositeAlgId::IdMldsa44Ed25519 => ( + KeyType::from_static_str("AKP"), + JwsAlgorithm::ML_DSA_44, + KeyType::from_static_str("Ed25519"), + JwsAlgorithm::EdDSA, + ), + CompositeAlgId::IdMldsa65Ed25519 => ( + KeyType::from_static_str("AKP"), + JwsAlgorithm::ML_DSA_65, + KeyType::from_static_str("Ed25519"), + JwsAlgorithm::EdDSA, + ), + _ => { + return Err(Error::InvalidJwsAlgorithm); + } + }; + + let JwkGenOutput { + key_id: t_key_id, + jwk: t_jwk, + } = K::generate(storage.key_storage(), trad_key_type, trad_alg) + .await + .map_err(Error::KeyStorageError)?; + + let JwkGenOutput { + key_id: pq_key_id, + jwk: pq_jwk, + } = K::generate_pq_key(storage.key_storage(), pq_key_type, pq_alg) + .await + .map_err(Error::KeyStorageError)?; + + let composite_kid = KeyId::new(format!("{}~{}", t_key_id.as_str(), pq_key_id.as_str())); + + let pq_jwk = PostQuantumJwk::try_from(pq_jwk).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let traditional_jwk = TraditionalJwk::try_from(t_jwk).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let composite_pk = CompositeJwk::new(alg_id, traditional_jwk, pq_jwk); + + let method: VerificationMethod = { + match VerificationMethod::new_from_compositejwk(document.id().clone(), composite_pk, fragment) + .map_err(Error::VerificationMethodConstructionError) + { + Ok(method) => method, + Err(source) => { + let error = try_undo_key_generation(storage, &t_key_id, source).await; + let error = try_undo_key_generation(storage, &pq_key_id, error).await; + return Err(error); + } + } + }; + + // Extract data from method before inserting it into the DID document. + let method_digest: MethodDigest = MethodDigest::new(&method).map_err(Error::MethodDigestConstructionError)?; + let method_id: DIDUrl = method.id().clone(); + + // The fragment is always set on a method, so this error will never occur. + let fragment: String = method_id + .fragment() + .ok_or(identity_verification::Error::MissingIdFragment) + .map_err(Error::VerificationMethodConstructionError)? + .to_owned(); + + // Insert method into document and handle error upon failure. + if let Err(error) = document + .insert_method(method, scope) + .map_err(|_| Error::FragmentAlreadyExists) + { + let error = try_undo_key_generation(storage, &t_key_id, error).await; + let error = try_undo_key_generation(storage, &pq_key_id, error).await; + return Err(error); + }; + + // Insert the generated `KeyId` into storage under the computed method digest and handle the error if the + // operation fails. + if let Err(error) = ::insert_key_id(&storage.key_id_storage(), method_digest, composite_kid) + .await + .map_err(Error::KeyIdStorageError) + { + // Remove the method from the document as it can no longer be used. + let _ = document.remove_method(&method_id); + let error = try_undo_key_generation(storage, &t_key_id, error).await; + let error = try_undo_key_generation(storage, &pq_key_id, error).await; + return Err(error); + } + + Ok(fragment) + } + }; +} + +/// Extension trait to handle PQ/T hybrid operations. +#[cfg_attr(not(feature = "send-sync-storage"), async_trait(?Send))] +#[cfg_attr(feature = "send-sync-storage", async_trait)] +pub trait JwkDocumentExtHybrid { + /// Generate an Verification Method containing a PQ/T hybrid key. + async fn generate_method_hybrid( + &mut self, + storage: &Storage, + alg_id: CompositeAlgId, + fragment: Option<&str>, + scope: MethodScope, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage; + + /// Create a PQ/T hybrid JWS. + async fn create_jws( + &self, + storage: &Storage, + fragment: &str, + payload: &[u8], + options: &JwsSignatureOptions, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage; + + /// Create a PQ/T hybrid Verifiable Credential. + async fn create_credential_jwt_hybrid( + &self, + credential: &Credential, + storage: &Storage, + fragment: &str, + options: &JwsSignatureOptions, + custom_claims: Option, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync; + + /// Create a PQ/T hybrid Verifiable Presentation. + async fn create_presentation_jwt_hybrid( + &self, + presentation: &Presentation, + storage: &Storage, + fragment: &str, + signature_options: &JwsSignatureOptions, + presentation_options: &JwtPresentationOptions, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync, + CRED: Serialize + DeserializeOwned + Clone + Sync; +} + +generate_method_hybrid_for_document_type!(CoreDocument, generate_method_hybrid_core_document); + +#[cfg_attr(not(feature = "send-sync-storage"), async_trait(?Send))] +#[cfg_attr(feature = "send-sync-storage", async_trait)] +impl JwkDocumentExtHybrid for CoreDocument { + async fn generate_method_hybrid( + &mut self, + storage: &Storage, + alg_id: CompositeAlgId, + fragment: Option<&str>, + scope: MethodScope, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + { + generate_method_hybrid_core_document(self, storage, alg_id, fragment, scope).await + } + + /// Hybrid signature implementation + async fn create_jws( + &self, + storage: &Storage, + fragment: &str, + payload: &[u8], + options: &JwsSignatureOptions, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + { + // Obtain the method corresponding to the given fragment. + let method: &VerificationMethod = self.resolve_method(fragment, None).ok_or(Error::MethodNotFound)?; + let MethodData::CompositeJwk(ref composite) = method.data() else { + return Err(Error::NotCompositePublicKey); + }; + + let alg_id = composite.alg_id(); + let t_jwk = composite.traditional_public_key(); + let pq_jwk = composite.pq_public_key(); + + // Extract JwsAlgorithm. + let alg: JwsAlgorithm = alg_id.name().parse().map_err(|_| Error::InvalidJwsAlgorithm)?; + + // Create JWS header in accordance with options. + let header: JwsHeader = { + let mut header = JwsHeader::new(); + + header.set_alg(alg); + if let Some(custom) = &options.custom_header_parameters { + header.set_custom(custom.clone()) + } + + if let Some(ref kid) = options.kid { + header.set_kid(kid.clone()); + } else { + header.set_kid(method.id().to_string()); + } + + if let Some(b64) = options.b64 { + // Follow recommendation in https://datatracker.ietf.org/doc/html/rfc7797#section-7. + if !b64 { + header.set_b64(b64); + header.set_crit(["b64"]); + } + }; + + if let Some(typ) = &options.typ { + header.set_typ(typ.clone()) + } else { + // https://www.w3.org/TR/vc-data-model/#jwt-encoding + header.set_typ("JWT") + } + + if let Some(cty) = &options.cty { + header.set_cty(cty.clone()) + }; + + if let Some(url) = &options.url { + header.set_url(url.clone()) + }; + + if let Some(nonce) = &options.nonce { + header.set_nonce(nonce.clone()) + }; + + header + }; + + // Get the key identifier corresponding to the given method from the KeyId storage. + let method_digest: MethodDigest = MethodDigest::new(method).map_err(Error::MethodDigestConstructionError)?; + let key_id: KeyId = ::get_key_id(storage.key_id_storage(), &method_digest) + .await + .map_err(Error::KeyIdStorageError)?; + + let (t_key_id, pq_key_id) = match key_id.as_str().split_once("~") { + Some(v) => (KeyId::new(v.0), KeyId::new(v.1)), + None => { + // If the key_id is not in the expected format, we return an error. + return Err(Error::KeyIdStorageError(KeyIdStorageErrorKind::Unspecified.into())); + } + }; + + // Extract Compact JWS encoding options. + let encoding_options: CompactJwsEncodingOptions = if !options.detached_payload { + // We use this as a default and don't provide the extra UrlSafe check for now. + // Applications that require such checks can easily do so after JWS creation. + CompactJwsEncodingOptions::NonDetached { + charset_requirements: CharSet::Default, + } + } else { + CompactJwsEncodingOptions::Detached + }; + + let jws_encoder: CompactJwsEncoder<'_> = CompactJwsEncoder::new_with_options(payload, &header, encoding_options) + .map_err(|err| Error::EncodingError(err.into()))?; + + let domain = match alg { + JwsAlgorithm::IdMldsa44Ed25519 => CompositeAlgId::IdMldsa44Ed25519.domain(), + JwsAlgorithm::IdMldsa65Ed25519 => CompositeAlgId::IdMldsa65Ed25519.domain(), + _ => return Err(Error::InvalidJwsAlgorithm), + }; + + //M' = Prefix || Domain || len(ctx) || ctx || M + //let prefix = b"CompositeAlgorithmSignatures2025"; + + //Prefix: CompositeAlgorithmSignatures2025 + let mut input = CompositeAlgId::COMPOSITE_SIGNATURE_PREFIX.to_vec(); + + //Domain: id-MLDSA44-Ed25519 or id-MLDSA65-Ed25519 + input.extend_from_slice(domain); + + //len(ctx) = 0 + input.push(0x00); + + //M + input.extend(jws_encoder.signing_input()); + + let signature_t = ::sign(storage.key_storage(), &t_key_id, &input, t_jwk) + .await + .map_err(Error::KeyStorageError)?; + + let signature_pq = ::pq_sign(storage.key_storage(), &pq_key_id, &input, pq_jwk, Some(domain)) + .await + .map_err(Error::KeyStorageError)?; + + let signature = [signature_t, signature_pq].concat(); + + Ok(Jws::new(jws_encoder.into_jws(&signature))) + } + + async fn create_credential_jwt_hybrid( + &self, + credential: &Credential, + storage: &Storage, + fragment: &str, + options: &JwsSignatureOptions, + custom_claims: Option, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync, + { + if options.detached_payload { + return Err(Error::EncodingError(Box::::from( + "cannot use detached payload for credential signing", + ))); + } + + if !options.b64.unwrap_or(true) { + // JWTs should not have `b64` set per https://datatracker.ietf.org/doc/html/rfc7797#section-7. + return Err(Error::EncodingError(Box::::from( + "cannot use `b64 = false` with JWTs", + ))); + } + + let payload = credential + .serialize_jwt(custom_claims) + .map_err(Error::ClaimsSerializationError)?; + self + .create_jws(storage, fragment, payload.as_bytes(), options) + .await + .map(|jws| Jwt::new(jws.into())) + } + + async fn create_presentation_jwt_hybrid( + &self, + presentation: &Presentation, + storage: &Storage, + fragment: &str, + jws_options: &JwsSignatureOptions, + jwt_options: &JwtPresentationOptions, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync, + CRED: Clone + Serialize + DeserializeOwned + Sync, + { + if jws_options.detached_payload { + return Err(Error::EncodingError(Box::::from( + "cannot use detached payload for presentation signing", + ))); + } + + if !jws_options.b64.unwrap_or(true) { + // JWTs should not have `b64` set per https://datatracker.ietf.org/doc/html/rfc7797#section-7. + return Err(Error::EncodingError(Box::::from( + "cannot use `b64 = false` with JWTs", + ))); + } + let payload = presentation + .serialize_jwt(jwt_options) + .map_err(Error::ClaimsSerializationError)?; + self + .create_jws(storage, fragment, payload.as_bytes(), jws_options) + .await + .map(|jws| Jwt::new(jws.into())) + } +} + +// ==================================================================================================================== +// IotaDocument +// ==================================================================================================================== +#[cfg(feature = "iota-document")] +mod iota_document { + use crate::StorageResult; + + use super::*; + use identity_credential::credential::Jwt; + use identity_iota_core::IotaDocument; + + generate_method_hybrid_for_document_type!(IotaDocument, generate_method_hybrid_iota_document); + + #[cfg_attr(not(feature = "send-sync-storage"), async_trait(?Send))] + #[cfg_attr(feature = "send-sync-storage", async_trait)] + impl JwkDocumentExtHybrid for IotaDocument { + async fn generate_method_hybrid( + &mut self, + storage: &Storage, + alg_id: CompositeAlgId, + fragment: Option<&str>, + scope: MethodScope, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + { + generate_method_hybrid_iota_document(self, storage, alg_id, fragment, scope).await + } + + async fn create_jws( + &self, + storage: &Storage, + fragment: &str, + payload: &[u8], + options: &JwsSignatureOptions, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + { + self + .core_document() + .create_jws(storage, fragment, payload, options) + .await + } + + async fn create_credential_jwt_hybrid( + &self, + credential: &Credential, + storage: &Storage, + fragment: &str, + options: &JwsSignatureOptions, + custom_claims: Option, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync, + { + self + .core_document() + .create_credential_jwt_hybrid(credential, storage, fragment, options, custom_claims) + .await + } + + async fn create_presentation_jwt_hybrid( + &self, + presentation: &Presentation, + storage: &Storage, + fragment: &str, + options: &JwsSignatureOptions, + jwt_options: &JwtPresentationOptions, + ) -> StorageResult + where + K: JwkStorage + JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync, + CRED: Clone + Serialize + DeserializeOwned + Sync, + { + self + .core_document() + .create_presentation_jwt_hybrid(presentation, storage, fragment, options, jwt_options) + .await + } + } +} diff --git a/identity_storage/src/storage/mod.rs b/identity_storage/src/storage/mod.rs index b2e4ca3233..0012713da0 100644 --- a/identity_storage/src/storage/mod.rs +++ b/identity_storage/src/storage/mod.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 //! This module provides a type wrapping a key and key id storage. @@ -6,12 +6,18 @@ mod error; #[macro_use] mod jwk_document_ext; +#[cfg(feature = "hybrid")] +mod hybrid_jws_document_ext; #[cfg(feature = "jpt-bbs-plus")] mod jwp_document_ext; +#[cfg(feature = "pqc")] +mod pqc_jws_document_ext; mod signature_options; #[cfg(feature = "jpt-bbs-plus")] mod timeframe_revocation_ext; +mod did_jwk_document_ext; + #[cfg(feature = "storage-signer")] mod storage_signer; #[cfg(all(test, feature = "memstore"))] @@ -19,15 +25,21 @@ pub(crate) mod tests; pub use error::*; +#[cfg(feature = "hybrid")] +pub use hybrid_jws_document_ext::*; pub use jwk_document_ext::*; #[cfg(feature = "jpt-bbs-plus")] pub use jwp_document_ext::*; +#[cfg(feature = "pqc")] +pub use pqc_jws_document_ext::*; pub use signature_options::*; #[cfg(feature = "storage-signer")] pub use storage_signer::*; #[cfg(feature = "jpt-bbs-plus")] pub use timeframe_revocation_ext::*; +pub use did_jwk_document_ext::*; + /// A type wrapping a key and key id storage, typically used with [`JwkStorage`](crate::key_storage::JwkStorage) and /// [`KeyIdStorage`](crate::key_id_storage::KeyIdStorage) that should always be used together when calling methods from /// [`JwkDocumentExt`](crate::storage::JwkDocumentExt). diff --git a/identity_storage/src/storage/pqc_jws_document_ext.rs b/identity_storage/src/storage/pqc_jws_document_ext.rs new file mode 100644 index 0000000000..010ed2d9d5 --- /dev/null +++ b/identity_storage/src/storage/pqc_jws_document_ext.rs @@ -0,0 +1,406 @@ +// Copyright 2020-2025 IOTA Stiftung, Fondazione Links +// SPDX-License-Identifier: Apache-2.0 + +use super::JwkStorageDocumentError as Error; +use crate::key_id_storage::MethodDigest; +use crate::try_undo_key_generation; +use crate::JwkGenOutput; +use crate::JwkStoragePQ; +use crate::JwsSignatureOptions; +use crate::KeyIdStorage; +use crate::KeyType; +use crate::Storage; +use crate::StorageResult; +use async_trait::async_trait; +use identity_core::common::Object; +use identity_credential::credential::Credential; +use identity_credential::credential::Jws; +use identity_credential::credential::Jwt; +use identity_credential::presentation::JwtPresentationOptions; +use identity_credential::presentation::Presentation; +use identity_did::DIDUrl; +use identity_document::document::CoreDocument; +use identity_verification::jwk::PostQuantumJwk; +use identity_verification::jws::CharSet; +use identity_verification::jws::CompactJwsEncoder; +use identity_verification::jws::CompactJwsEncodingOptions; +use identity_verification::jws::JwsAlgorithm; +use identity_verification::jws::JwsHeader; +use identity_verification::MethodData; +use identity_verification::MethodScope; +use identity_verification::VerificationMethod; +use serde::de::DeserializeOwned; +use serde::Serialize; + +///New trait to handle PQ-based operations on DID Documents +#[cfg_attr(not(feature = "send-sync-storage"), async_trait(?Send))] +#[cfg_attr(feature = "send-sync-storage", async_trait)] +pub trait JwsDocumentExtPQC { + /// Generate new key material in the given `storage` and insert a new verification method with the corresponding PQ + /// public key material into the DID document. + async fn generate_method_pqc( + &mut self, + storage: &Storage, + key_type: KeyType, + alg: JwsAlgorithm, + fragment: Option<&str>, + scope: MethodScope, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage; + + /// Create a PQ JWS + async fn create_jws_pqc( + &self, + storage: &Storage, + fragment: &str, + payload: &[u8], + options: &JwsSignatureOptions, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage; + + /// Produces a JWT using PQC algorithms where the payload is produced from the given `credential` + /// in accordance with [VC Data Model v1.1](https://www.w3.org/TR/vc-data-model/#json-web-token). + /// + /// Unless the `kid` is explicitly set in the options, the `kid` in the protected header is the `id` + /// of the method identified by `fragment` and the JWS signature will be produced by the corresponding + /// private key backed by the `storage` in accordance with the passed `options`. + /// + /// The `custom_claims` can be used to set additional claims on the resulting JWT. + async fn create_credential_jwt_pqc( + &self, + credential: &Credential, + storage: &Storage, + fragment: &str, + options: &JwsSignatureOptions, + custom_claims: Option, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync; + + /// Produces a JWT using PQC algorithms where the payload is produced from the given `presentation` + /// in accordance with [VC Data Model v1.1](https://www.w3.org/TR/vc-data-model/#json-web-token). + /// + /// Unless the `kid` is explicitly set in the options, the `kid` in the protected header is the `id` + /// of the method identified by `fragment` and the JWS signature will be produced by the corresponding + /// private key backed by the `storage` in accordance with the passed `options`. + async fn create_presentation_jwt_pqc( + &self, + presentation: &Presentation, + storage: &Storage, + fragment: &str, + signature_options: &JwsSignatureOptions, + presentation_options: &JwtPresentationOptions, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync, + CRED: Clone + Serialize + DeserializeOwned + Sync; +} + +// ==================================================================================================================== +// CoreDocument +// ==================================================================================================================== + +generate_method_for_document_type!( + CoreDocument, + JwsAlgorithm, + JwkStoragePQ, + JwkStoragePQ::generate_pq_key, + generate_method_core_document +); + +#[cfg_attr(not(feature = "send-sync-storage"), async_trait(?Send))] +#[cfg_attr(feature = "send-sync-storage", async_trait)] +impl JwsDocumentExtPQC for CoreDocument { + async fn generate_method_pqc( + &mut self, + storage: &Storage, + key_type: KeyType, + alg: JwsAlgorithm, + fragment: Option<&str>, + scope: MethodScope, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage, + { + generate_method_core_document(self, storage, key_type, alg, fragment, scope).await + } + + async fn create_jws_pqc( + &self, + storage: &Storage, + fragment: &str, + payload: &[u8], + options: &JwsSignatureOptions, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage, + { + // Obtain the method corresponding to the given fragment. + let method: &VerificationMethod = self.resolve_method(fragment, None).ok_or(Error::MethodNotFound)?; + let MethodData::PublicKeyJwk(ref jwk) = method.data() else { + return Err(Error::NotPublicKeyJwk); + }; + + // Extract JwsAlgorithm. + let alg: JwsAlgorithm = jwk + .alg() + .unwrap_or("") + .parse() + .map_err(|_| Error::InvalidJwsAlgorithm)?; + + // Create JWS header in accordance with options. + let header: JwsHeader = { + let mut header = JwsHeader::new(); + + header.set_alg(alg); + if let Some(custom) = &options.custom_header_parameters { + header.set_custom(custom.clone()) + } + + if let Some(ref kid) = options.kid { + header.set_kid(kid.clone()); + } else { + header.set_kid(method.id().to_string()); + } + + if options.attach_jwk { + header.set_jwk(jwk.clone()) + }; + + if let Some(b64) = options.b64 { + // Follow recommendation in https://datatracker.ietf.org/doc/html/rfc7797#section-7. + if !b64 { + header.set_b64(b64); + header.set_crit(["b64"]); + } + }; + + if let Some(typ) = &options.typ { + header.set_typ(typ.clone()) + } else { + // https://www.w3.org/TR/vc-data-model/#jwt-encoding + header.set_typ("JWT") + } + + if let Some(cty) = &options.cty { + header.set_cty(cty.clone()) + }; + + if let Some(url) = &options.url { + header.set_url(url.clone()) + }; + + if let Some(nonce) = &options.nonce { + header.set_nonce(nonce.clone()) + }; + + header + }; + + // Get the key identifier corresponding to the given method from the KeyId storage. + let method_digest: MethodDigest = MethodDigest::new(method).map_err(Error::MethodDigestConstructionError)?; + let key_id = ::get_key_id(storage.key_id_storage(), &method_digest) + .await + .map_err(Error::KeyIdStorageError)?; + + // Extract Compact JWS encoding options. + let encoding_options: CompactJwsEncodingOptions = if !options.detached_payload { + // We use this as a default and don't provide the extra UrlSafe check for now. + // Applications that require such checks can easily do so after JWS creation. + CompactJwsEncodingOptions::NonDetached { + charset_requirements: CharSet::Default, + } + } else { + CompactJwsEncodingOptions::Detached + }; + + let jws_encoder: CompactJwsEncoder<'_> = CompactJwsEncoder::new_with_options(payload, &header, encoding_options) + .map_err(|err| Error::EncodingError(err.into()))?; + + let pq_jwk = PostQuantumJwk::try_from(jwk.clone()).map_err(|err| Error::EncodingError(Box::new(err)))?; + + let signature = ::pq_sign( + storage.key_storage(), + &key_id, + jws_encoder.signing_input(), + &pq_jwk, + None, + ) + .await + .map_err(Error::KeyStorageError)?; + Ok(Jws::new(jws_encoder.into_jws(&signature))) + } + + async fn create_credential_jwt_pqc( + &self, + credential: &Credential, + storage: &Storage, + fragment: &str, + options: &JwsSignatureOptions, + custom_claims: Option, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync, + { + if options.detached_payload { + return Err(Error::EncodingError(Box::::from( + "cannot use detached payload for credential signing", + ))); + } + + if !options.b64.unwrap_or(true) { + // JWTs should not have `b64` set per https://datatracker.ietf.org/doc/html/rfc7797#section-7. + return Err(Error::EncodingError(Box::::from( + "cannot use `b64 = false` with JWTs", + ))); + } + + let payload = credential + .serialize_jwt(custom_claims) + .map_err(Error::ClaimsSerializationError)?; + self + .create_jws_pqc(storage, fragment, payload.as_bytes(), options) + .await + .map(|jws| Jwt::new(jws.into())) + } + + async fn create_presentation_jwt_pqc( + &self, + presentation: &Presentation, + storage: &Storage, + fragment: &str, + jws_options: &JwsSignatureOptions, + jwt_options: &JwtPresentationOptions, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync, + CRED: Clone + Serialize + DeserializeOwned + Sync, + { + if jws_options.detached_payload { + return Err(Error::EncodingError(Box::::from( + "cannot use detached payload for presentation signing", + ))); + } + + if !jws_options.b64.unwrap_or(true) { + // JWTs should not have `b64` set per https://datatracker.ietf.org/doc/html/rfc7797#section-7. + return Err(Error::EncodingError(Box::::from( + "cannot use `b64 = false` with JWTs", + ))); + } + let payload = presentation + .serialize_jwt(jwt_options) + .map_err(Error::ClaimsSerializationError)?; + self + .create_jws_pqc(storage, fragment, payload.as_bytes(), jws_options) + .await + .map(|jws| Jwt::new(jws.into())) + } +} + +// ==================================================================================================================== +// IotaDocument +// ==================================================================================================================== +#[cfg(feature = "iota-document")] +mod iota_document { + + use super::*; + use identity_iota_core::IotaDocument; + + generate_method_for_document_type!( + IotaDocument, + JwsAlgorithm, + JwkStoragePQ, + JwkStoragePQ::generate_pq_key, + generate_method_iota_document + ); + + #[cfg_attr(not(feature = "send-sync-storage"), async_trait(?Send))] + #[cfg_attr(feature = "send-sync-storage", async_trait)] + impl JwsDocumentExtPQC for IotaDocument { + async fn generate_method_pqc( + &mut self, + storage: &Storage, + key_type: KeyType, + alg: JwsAlgorithm, + fragment: Option<&str>, + scope: MethodScope, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage, + { + generate_method_iota_document(self, storage, key_type, alg, fragment, scope).await + } + + async fn create_jws_pqc( + &self, + storage: &Storage, + fragment: &str, + payload: &[u8], + options: &JwsSignatureOptions, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage, + { + self + .core_document() + .create_jws_pqc(storage, fragment, payload, options) + .await + } + + async fn create_credential_jwt_pqc( + &self, + credential: &Credential, + storage: &Storage, + fragment: &str, + options: &JwsSignatureOptions, + custom_claims: Option, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync, + { + self + .core_document() + .create_credential_jwt_pqc(credential, storage, fragment, options, custom_claims) + .await + } + + async fn create_presentation_jwt_pqc( + &self, + presentation: &Presentation, + storage: &Storage, + fragment: &str, + jws_options: &JwsSignatureOptions, + jwt_options: &JwtPresentationOptions, + ) -> StorageResult + where + K: JwkStoragePQ, + I: KeyIdStorage, + T: Clone + Serialize + DeserializeOwned + Sync, + CRED: Clone + Serialize + DeserializeOwned + Sync, + { + self + .core_document() + .create_presentation_jwt_pqc(presentation, storage, fragment, jws_options, jwt_options) + .await + } + } +} diff --git a/identity_stronghold/src/storage/mod.rs b/identity_stronghold/src/storage/mod.rs index 2752f3b077..4e55062875 100644 --- a/identity_stronghold/src/storage/mod.rs +++ b/identity_stronghold/src/storage/mod.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2024 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 mod stronghold_jwk_storage; @@ -109,7 +109,7 @@ impl StrongholdStorage { .get_guards([location], |[sk]| { let sk = BBSplusSecretKey::from_bytes(&sk.borrow()).map_err(|e| FatalProcedureError::from(e.to_string()))?; let pk = sk.public_key(); - let public_jwk = encode_bls_jwk(&sk, &pk, ProofAlgorithm::BLS12381_SHA256).1; + let public_jwk = encode_bls_jwk(&sk, &pk, ProofAlgorithm::BBS).1; drop(Zeroizing::new(sk.to_bytes())); Ok(public_jwk) diff --git a/identity_stronghold/src/storage/stronghold_jwk_storage_bbs_plus_ext.rs b/identity_stronghold/src/storage/stronghold_jwk_storage_bbs_plus_ext.rs index 10fbe7faa0..eebdfdd8b4 100644 --- a/identity_stronghold/src/storage/stronghold_jwk_storage_bbs_plus_ext.rs +++ b/identity_stronghold/src/storage/stronghold_jwk_storage_bbs_plus_ext.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2024 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use async_trait::async_trait; @@ -39,7 +39,7 @@ impl JwkStorageBbsPlusExt for StrongholdStorage { ); } - if !matches!(alg, ProofAlgorithm::BLS12381_SHA256 | ProofAlgorithm::BLS12381_SHAKE256) { + if !matches!(alg, ProofAlgorithm::BBS | ProofAlgorithm::BBS_SHAKE256) { return Err(KeyStorageErrorKind::UnsupportedProofAlgorithm.into()); } diff --git a/identity_stronghold/src/tests/test_bbs_ext.rs b/identity_stronghold/src/tests/test_bbs_ext.rs index efa71f3cc2..df00053abc 100644 --- a/identity_stronghold/src/tests/test_bbs_ext.rs +++ b/identity_stronghold/src/tests/test_bbs_ext.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2024 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use identity_storage::key_storage::bls::expand_bls_jwk; @@ -23,7 +23,7 @@ use crate::StrongholdStorage; async fn stronghold_bbs_keypair_gen_works() -> anyhow::Result<()> { let stronghold_storage = StrongholdStorage::new(create_stronghold_secret_manager()); let JwkGenOutput { key_id, jwk, .. } = stronghold_storage - .generate_bbs(StrongholdKeyType::Bls12381G2.into(), ProofAlgorithm::BLS12381_SHA256) + .generate_bbs(StrongholdKeyType::Bls12381G2.into(), ProofAlgorithm::BBS) .await?; assert!(jwk.is_public()); @@ -36,7 +36,7 @@ async fn stronghold_bbs_keypair_gen_works() -> anyhow::Result<()> { async fn stronghold_bbs_keypair_gen_fails_with_wrong_key_type() -> anyhow::Result<()> { let stronghold_storage = StrongholdStorage::new(create_stronghold_secret_manager()); let error = stronghold_storage - .generate_bbs(StrongholdKeyType::Ed25519.into(), ProofAlgorithm::BLS12381_SHA256) + .generate_bbs(StrongholdKeyType::Ed25519.into(), ProofAlgorithm::BBS) .await .unwrap_err(); assert!(matches!(error.kind(), KeyStorageErrorKind::UnsupportedKeyType)); @@ -61,7 +61,7 @@ async fn stronghold_bbs_keypair_gen_fails_with_wrong_alg() -> anyhow::Result<()> async fn stronghold_sign_bbs_works() -> anyhow::Result<()> { let stronghold_storage = StrongholdStorage::new(create_stronghold_secret_manager()); let JwkGenOutput { key_id, jwk, .. } = stronghold_storage - .generate_bbs(StrongholdKeyType::Bls12381G2.into(), ProofAlgorithm::BLS12381_SHA256) + .generate_bbs(StrongholdKeyType::Bls12381G2.into(), ProofAlgorithm::BBS) .await?; let pk = expand_bls_jwk(&jwk)?.1; let sk = { @@ -78,13 +78,7 @@ async fn stronghold_sign_bbs_works() -> anyhow::Result<()> { let mut data = vec![0; 1024]; rand::thread_rng().fill_bytes(&mut data); - let expected_signature = sign_bbs( - ProofAlgorithm::BLS12381_SHA256, - std::slice::from_ref(&data), - &sk, - &pk, - &[], - )?; + let expected_signature = sign_bbs(ProofAlgorithm::BBS, std::slice::from_ref(&data), &sk, &pk, &[])?; let signature = stronghold_storage.sign_bbs(&key_id, &[data], &[], &jwk).await?; assert_eq!(signature, expected_signature); diff --git a/identity_verification/src/error.rs b/identity_verification/src/error.rs index 97070de3bf..2c9f2a3534 100644 --- a/identity_verification/src/error.rs +++ b/identity_verification/src/error.rs @@ -1,4 +1,4 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 //! Errors that may occur when working with Decentralized Identifiers. @@ -39,4 +39,7 @@ pub enum Error { /// Caused by key material that is not a JSON Web Key. #[error("verification material format is not publicKeyJwk")] NotPublicKeyJwk, + /// Caused by key material that is not a Composite Public Key. + #[error("verification material format is not compositePublicKey")] + NotCompositePublicKey, } diff --git a/identity_verification/src/verification_method/material.rs b/identity_verification/src/verification_method/material.rs index 8e881253c5..2dec04a865 100644 --- a/identity_verification/src/verification_method/material.rs +++ b/identity_verification/src/verification_method/material.rs @@ -1,6 +1,7 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 +use crate::jose::jwk::CompositeJwk; use crate::jose::jwk::Jwk; use core::fmt::Debug; use core::fmt::Formatter; @@ -27,6 +28,8 @@ pub enum MethodData { PublicKeyBase58(String), /// Verification Material in the JSON Web Key format. PublicKeyJwk(Jwk), + /// Verification Material containing two keys in JSON Web Key format, one traditional and one PQ. + CompositeJwk(CompositeJwk), /// Arbitrary verification material. #[serde(untagged)] Custom(CustomMethodData), @@ -59,7 +62,7 @@ impl MethodData { /// represented as a vector of bytes. pub fn try_decode(&self) -> Result> { match self { - Self::PublicKeyJwk(_) | Self::Custom(_) => Err(Error::InvalidMethodDataTransformation( + Self::PublicKeyJwk(_) | Self::Custom(_) | Self::CompositeJwk(_) => Err(Error::InvalidMethodDataTransformation( "method data is not base encoded", )), Self::PublicKeyMultibase(input) => { @@ -69,6 +72,20 @@ impl MethodData { } } + /// Returns the wrapped `CompositePublicKey` if the format is [`MethodData::CompositePublicKey`]. + pub fn composite_public_key(&self) -> Option<&CompositeJwk> { + if let Self::CompositeJwk(ref c) = self { + Some(c) + } else { + None + } + } + + /// Fallible version of [`Self::composite_public_key`](Self::composite_public_key). + pub fn try_composite_public_key(&self) -> Result<&CompositeJwk> { + self.composite_public_key().ok_or(Error::NotCompositePublicKey) + } + /// Returns the wrapped `Jwk` if the format is [`MethodData::PublicKeyJwk`]. pub fn public_key_jwk(&self) -> Option<&Jwk> { if let Self::PublicKeyJwk(ref jwk) = self { @@ -99,6 +116,7 @@ impl Debug for MethodData { Self::PublicKeyJwk(inner) => f.write_fmt(format_args!("PublicKeyJwk({inner:#?})")), Self::PublicKeyMultibase(inner) => f.write_fmt(format_args!("PublicKeyMultibase({inner})")), Self::PublicKeyBase58(inner) => f.write_fmt(format_args!("PublicKeyBase58({inner})")), + Self::CompositeJwk(inner) => f.write_fmt(format_args!("CompositePublicKey({inner:#?})")), Self::Custom(CustomMethodData { name, data }) => f.write_fmt(format_args!("{name}({data})")), } } diff --git a/identity_verification/src/verification_method/method.rs b/identity_verification/src/verification_method/method.rs index 084956c3a9..e0a36ebd06 100644 --- a/identity_verification/src/verification_method/method.rs +++ b/identity_verification/src/verification_method/method.rs @@ -1,11 +1,13 @@ -// Copyright 2020-2023 IOTA Stiftung +// Copyright 2020-2025 IOTA Stiftung, Fondazione LINKS // SPDX-License-Identifier: Apache-2.0 use core::fmt::Display; use core::fmt::Formatter; use std::borrow::Cow; +use identity_did::DIDCompositeJwk; use identity_did::DIDJwk; +use identity_jose::jwk::CompositeJwk; use identity_jose::jwk::Jwk; use serde::de; use serde::Deserialize; @@ -227,6 +229,50 @@ impl VerificationMethod { } } +impl VerificationMethod { + // =========================================================================== + // Constructors + // =========================================================================== + + /// Creates a new [`VerificationMethod`] from the given `did` and [`CompositeJwk`]. If `fragment` is not given + /// the `kid` value of the given `key` will be used, if present, otherwise an error is returned. + pub fn new_from_compositejwk(did: D, key: CompositeJwk, fragment: Option<&str>) -> Result { + // Lazily compute the composite fragment. + let composite_fragment = || { + let maybe_tpk_kid = key.traditional_public_key().kid(); + let maybe_pqpk_kid = key.pq_public_key().kid(); + if let (Some(tpk_kid), Some(pqpk_kid)) = (maybe_tpk_kid, maybe_pqpk_kid) { + Some(Cow::Owned(format!("{tpk_kid}~{pqpk_kid}"))) + } else { + maybe_tpk_kid.or(maybe_pqpk_kid).map(Cow::Borrowed) + } + }; + + let fragment = { + let given_fragment = fragment + .map(Cow::Borrowed) + .or_else(composite_fragment) + .ok_or(Error::InvalidMethod("an explicit fragment or kid is required"))?; + + // Make sure the fragment starts with "#" + if given_fragment.starts_with('#') { + given_fragment + } else { + Cow::Owned(format!("#{given_fragment}")) + } + }; + + let id: DIDUrl = did.to_url().join(fragment).map_err(Error::DIDUrlConstructionError)?; + + MethodBuilder::default() + .id(id) + .type_(MethodType::custom("CompositeJsonWebKey")) + .controller(did.into()) + .data(MethodData::CompositeJwk(key)) + .build() + } +} + impl Display for VerificationMethod { fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result { self.fmt_json(f) @@ -256,6 +302,14 @@ impl TryFrom for VerificationMethod { } } +impl TryFrom for VerificationMethod { + type Error = Error; + fn try_from(did: DIDCompositeJwk) -> Result { + let jwk = did.composite_jwk(); + Self::new_from_compositejwk(did, jwk, Some("0")) + } +} + // Horrible workaround for a tracked serde issue https://github.com/serde-rs/serde/issues/2200. Serde doesn't "consume" // the input when deserializing flattened enums (MethodData in this case) causing duplication of data (in this case // it ends up in the properties object). This workaround simply removes the duplication. @@ -285,6 +339,7 @@ impl From<_VerificationMethod> for VerificationMethod { MethodData::PublicKeyBase58(_) => "publicKeyBase58", MethodData::PublicKeyJwk(_) => "publicKeyJwk", MethodData::PublicKeyMultibase(_) => "publicKeyMultibase", + MethodData::CompositeJwk(_) => "compositeJwk", MethodData::Custom(CustomMethodData { name, .. }) => name.as_str(), }; properties.remove(key);