8883326918

Committed 29 Apr 2024 06:08PM UTC coverage: 68.711% (+2.1%) from 66.649%

Build # 8883326918

Build Type

push

github

Committed by

web-flow

Commit Message

feat(sdk-verification)!: Implementing DIF Presentation exchange protocol 2.0 for SDK to SDK OOB verification (#196)

Signed-off-by: Pete Vielhaber <peter.vielhaber@iohk.io>
Co-authored-by: Pete Vielhaber <peter.vielhaber@iohk.io>

Run Details

947 of 1539 branches covered (61.53%)

Branch coverage included in aggregate %.

273 of 363 new or added lines in 17 files covered. (75.21%)

3 existing lines in 3 files now uncovered.

2022 of 2782 relevant lines covered (72.68%)

15.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.23

/src/pollux/utils/JWT.ts

import * as didJWT from "did-jwt";
import * as didResolver from "did-resolver";

import { Castor } from "../../domain/buildingBlocks/Castor";
import {
  AlsoKnownAs,
  Controller,
  Services,
  VerificationMethods,
  DID,
  PrivateKey,
  Curve,
  PolluxError,
} from "../../domain";
import { JWTCredential } from "../../pollux/models/JWTVerifiableCredential";

export class JWT {
  private castor: Castor;

  constructor(castor: Castor) {
    this.castor = castor;
  }

  async verify(
    options: {
      issuerDID: DID,
      holderDID?: DID,
      jws: string
    }
  ): Promise<boolean> {
    try {
      const { issuerDID, jws, holderDID } = options;
      const resolved = await this.resolve(issuerDID.toString());
      const verificationMethod = resolved.didDocument?.verificationMethod;
      if (!verificationMethod) {
        throw new Error("Invalid did document");
      }

      const validVerificationMethod = didJWT.verifyJWS(jws, verificationMethod);
      const jwtObject = JWTCredential.fromJWS(jws);

      if (jwtObject.issuer !== issuerDID.toString()) {
        throw new Error("Invalid issuer");
      }

      if (jwtObject.isCredential && holderDID && holderDID.toString() !== jwtObject.subject) {
        throw new Error("Invalid subject (holder)");
      }

      return true;
    } catch (err) {
      return false;
    }
  }

  public async resolve(did: string): Promise<didResolver.DIDResolutionResult> {
    const resolved = await this.castor.resolveDID(did);
    const alsoKnownAs = resolved.coreProperties.find(
      (prop): prop is AlsoKnownAs => prop instanceof AlsoKnownAs
    );
    const controller = resolved.coreProperties.find(
      (prop): prop is Controller => prop instanceof Controller
    );
    const verificationMethods = resolved.coreProperties.find(
      (prop): prop is VerificationMethods => prop instanceof VerificationMethods
    );
    const service = resolved.coreProperties.find(
      (prop): prop is Services => prop instanceof Services
    );
    return {
      didResolutionMetadata: { contentType: "application/did+ld+json" },
      didDocumentMetadata: {},
      didDocument: {
        id: resolved.id.toString(),
        alsoKnownAs: alsoKnownAs && alsoKnownAs.values,
        controller:
          controller && controller.values
            ? controller.values.map((v) => v.toString())
            : [],
        verificationMethod:
          verificationMethods && verificationMethods.values
            ? verificationMethods.values.map((vm) => {
              if (vm.publicKeyMultibase) {
                return {
                  id: vm.id,
                  type: "EcdsaSecp256k1VerificationKey2019",
                  controller: vm.controller,
                  publicKeyMultibase: vm.publicKeyMultibase,
                };
              }
              if (vm.publicKeyJwk) {
                return {
                  id: vm.id,
                  type: "JsonWebKey2020",
                  controller: vm.controller,
                  publicKeyJwk: vm.publicKeyJwk,
                };
              }
              throw new Error("Invalid KeyType");
            })
            : [],
        service:
          service?.values?.reduce<didResolver.Service[]>((acc, service) => {
            const type = service.type.at(0);
            if (type === undefined) return acc;
            return acc.concat({
              id: service.id,
              type: type,
              serviceEndpoint: service.serviceEndpoint,
            });
          }, []) ?? [],
      },
    };
  }

  private getPrivateKeyAlgo(privateKey: PrivateKey): { alg: string, signer: didJWT.Signer } {
    if (privateKey.curve === Curve.SECP256K1) {
      return {
        alg: 'ES256K',
        signer: didJWT.ES256KSigner(privateKey.raw)
      };
    }
    if (privateKey.curve === Curve.ED25519) {
      return {
        alg: 'EdDSA',
        signer: didJWT.EdDSASigner(privateKey.raw)
      };
    }
    /* istanbul ignore next */
    throw new PolluxError.InvalidCredentialError(`Unsupported key type ${privateKey.curve}`)
  }

  async sign(
    options: {
      issuerDID: DID,
      privateKey: PrivateKey,
      payload: Partial<didJWT.JWTPayload>
    }
  ): Promise<string> {
    const { issuerDID, privateKey, payload } = options;
    if (!privateKey.isSignable()) {
      throw new Error("Key is not signable");
    }
    const { alg, signer } = this.getPrivateKeyAlgo(privateKey);
    const jwt = await didJWT.createJWT(
      payload,
      { issuer: issuerDID.toString(), signer },
      { alg }
    );
    return jwt;
  }
}

1	import * as didJWT from "did-jwt";
2	import * as didResolver from "did-resolver";
3
4	import { Castor } from "../../domain/buildingBlocks/Castor";
5	import {
6	AlsoKnownAs,
7	Controller,
8	Services,
9	VerificationMethods,
10	DID,
11	PrivateKey,
12	Curve,
13	PolluxError,
14	} from "../../domain";
15	import { JWTCredential } from "../../pollux/models/JWTVerifiableCredential";
16
17	export class JWT {
18	private castor: Castor;
19
20	constructor(castor: Castor) {
21	this.castor = castor;	94✔
22	}
23
24	async verify(
25	options: {
26	issuerDID: DID,
27	holderDID?: DID,
28	jws: string
29	}
30	): Promise<boolean> {
31	try {	12✔
32	const { issuerDID, jws, holderDID } = options;	12✔
33	const resolved = await this.resolve(issuerDID.toString());	12✔
34	const verificationMethod = resolved.didDocument?.verificationMethod;	11✔
35	if (!verificationMethod) {	11!
NEW 36	throw new Error("Invalid did document");	×
37	}
38
39	const validVerificationMethod = didJWT.verifyJWS(jws, verificationMethod);	11✔
40	const jwtObject = JWTCredential.fromJWS(jws);	9✔
41
42	if (jwtObject.issuer !== issuerDID.toString()) {	9!
NEW 43	throw new Error("Invalid issuer");	×
44	}
45
46	if (jwtObject.isCredential && holderDID && holderDID.toString() !== jwtObject.subject) {	9✔
47	throw new Error("Invalid subject (holder)");	1✔
48	}
49
50	return true;	8✔
51	} catch (err) {
52	return false;	4✔
53	}
54	}
55
56	public async resolve(did: string): Promise<didResolver.DIDResolutionResult> {
57	const resolved = await this.castor.resolveDID(did);	12✔
58	const alsoKnownAs = resolved.coreProperties.find(	11✔
59	(prop): prop is AlsoKnownAs => prop instanceof AlsoKnownAs	44✔
60	);
61	const controller = resolved.coreProperties.find(	11✔
62	(prop): prop is Controller => prop instanceof Controller	44✔
63	);
64	const verificationMethods = resolved.coreProperties.find(	11✔
65	(prop): prop is VerificationMethods => prop instanceof VerificationMethods	44✔
66	);
67	const service = resolved.coreProperties.find(	11✔
68	(prop): prop is Services => prop instanceof Services	33✔
69	);
70	return {	11✔
71	didResolutionMetadata: { contentType: "application/did+ld+json" },
72	didDocumentMetadata: {},
73	didDocument: {
74	id: resolved.id.toString(),
75	alsoKnownAs: alsoKnownAs && alsoKnownAs.values,	11!
76	controller:
77	controller && controller.values	22!
78	? controller.values.map((v) => v.toString())	×
79	: [],
80	verificationMethod:
81	verificationMethods && verificationMethods.values	33!
82	? verificationMethods.values.map((vm) => {
83	if (vm.publicKeyMultibase) {	22!
84	return {	22✔
85	id: vm.id,
86	type: "EcdsaSecp256k1VerificationKey2019",
87	controller: vm.controller,
88	publicKeyMultibase: vm.publicKeyMultibase,
89	};
90	}
91	if (vm.publicKeyJwk) {	×
92	return {	×
93	id: vm.id,
94	type: "JsonWebKey2020",
95	controller: vm.controller,
96	publicKeyJwk: vm.publicKeyJwk,
97	};
98	}
99	throw new Error("Invalid KeyType");	×
100	})
101	: [],
102	service:
103	service?.values?.reduce<didResolver.Service[]>((acc, service) => {	11!
104	const type = service.type.at(0);	×
105	if (type === undefined) return acc;	×
106	return acc.concat({	×
107	id: service.id,
108	type: type,
109	serviceEndpoint: service.serviceEndpoint,
110	});
111	}, []) ?? [],
112	},
113	};
114	}
115
116	private getPrivateKeyAlgo(privateKey: PrivateKey): { alg: string, signer: didJWT.Signer } {
117	if (privateKey.curve === Curve.SECP256K1) {	43!
118	return {	43✔
119	alg: 'ES256K',
120	signer: didJWT.ES256KSigner(privateKey.raw)
121	};
122	}
NEW 123	if (privateKey.curve === Curve.ED25519) {	×
NEW 124	return {	×
125	alg: 'EdDSA',
126	signer: didJWT.EdDSASigner(privateKey.raw)
127	};
128	}
129	/* istanbul ignore next */
130	throw new PolluxError.InvalidCredentialError(`Unsupported key type ${privateKey.curve}`)
131	}
132
133	async sign(
134	options: {
135	issuerDID: DID,
136	privateKey: PrivateKey,
137	payload: Partial<didJWT.JWTPayload>
138	}
139	): Promise<string> {
140	const { issuerDID, privateKey, payload } = options;	44✔
141	if (!privateKey.isSignable()) {	44✔
142	throw new Error("Key is not signable");	1✔
143	}
144	const { alg, signer } = this.getPrivateKeyAlgo(privateKey);	43✔
145	const jwt = await didJWT.createJWT(	43✔
146	payload,
147	{ issuer: issuerDID.toString(), signer },
148	{ alg }
149	);
150	return jwt;	43✔
151	}
152	}

input-output-hk / atala-prism-wallet-sdk-ts / 8883326918

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous