8735025845

Committed 18 Apr 2024 08:46AM UTC coverage: 67.784% (+2.3%) from 65.502%

Build # 8735025845

Build Type

Pull #196

github

Committed by

web-flow

Commit Message

Merge f8f265268 into 11cc07cfd

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

Run Details

923 of 1518 branches covered (60.8%)

Branch coverage included in aggregate %.

268 of 358 new or added lines in 17 files covered. (74.86%)

3 existing lines in 3 files now uncovered.

1989 of 2778 relevant lines covered (71.6%)

16.09 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,
} 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 Error("Not implemented")
  }

  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	} from "../../domain";
14	import { JWTCredential } from "../../pollux/models/JWTVerifiableCredential";
15
16	export class JWT {
17	private castor: Castor;
18
19	constructor(castor: Castor) {
20	this.castor = castor;	95✔
21	}
22
23	async verify(
24	options: {
25	issuerDID: DID,
26	holderDID?: DID,
27	jws: string
28	}
29	): Promise<boolean> {
30	try {	11✔
31	const { issuerDID, jws, holderDID } = options;	11✔
32	const resolved = await this.resolve(issuerDID.toString());	11✔
33	const verificationMethod = resolved.didDocument?.verificationMethod;	10✔
34	if (!verificationMethod) {	10!
NEW 35	throw new Error("Invalid did document");	×
36	}
37
38	const validVerificationMethod = didJWT.verifyJWS(jws, verificationMethod);	10✔
39	const jwtObject = JWTCredential.fromJWS(jws);	9✔
40
41	if (jwtObject.issuer !== issuerDID.toString()) {	9!
NEW 42	throw new Error("Invalid issuer");	×
43	}
44
45	if (jwtObject.isCredential && holderDID && holderDID.toString() !== jwtObject.subject) {	9✔
46	throw new Error("Invalid subject (holder)");	1✔
47	}
48
49	return true;	8✔
50	} catch (err) {
51	return false;	3✔
52	}
53	}
54
55	public async resolve(did: string): Promise<didResolver.DIDResolutionResult> {
56	const resolved = await this.castor.resolveDID(did);	11✔
57	const alsoKnownAs = resolved.coreProperties.find(	10✔
58	(prop): prop is AlsoKnownAs => prop instanceof AlsoKnownAs	40✔
59	);
60	const controller = resolved.coreProperties.find(	10✔
61	(prop): prop is Controller => prop instanceof Controller	40✔
62	);
63	const verificationMethods = resolved.coreProperties.find(	10✔
64	(prop): prop is VerificationMethods => prop instanceof VerificationMethods	40✔
65	);
66	const service = resolved.coreProperties.find(	10✔
67	(prop): prop is Services => prop instanceof Services	30✔
68	);
69	return {	10✔
70	didResolutionMetadata: { contentType: "application/did+ld+json" },
71	didDocumentMetadata: {},
72	didDocument: {
73	id: resolved.id.toString(),
74	alsoKnownAs: alsoKnownAs && alsoKnownAs.values,	10!
75	controller:
76	controller && controller.values	20!
77	? controller.values.map((v) => v.toString())	×
78	: [],
79	verificationMethod:
80	verificationMethods && verificationMethods.values	30!
81	? verificationMethods.values.map((vm) => {
82	if (vm.publicKeyMultibase) {	20!
83	return {	20✔
84	id: vm.id,
85	type: "EcdsaSecp256k1VerificationKey2019",
86	controller: vm.controller,
87	publicKeyMultibase: vm.publicKeyMultibase,
88	};
89	}
90	if (vm.publicKeyJwk) {	×
91	return {	×
92	id: vm.id,
93	type: "JsonWebKey2020",
94	controller: vm.controller,
95	publicKeyJwk: vm.publicKeyJwk,
96	};
97	}
98	throw new Error("Invalid KeyType");	×
99	})
100	: [],
101	service:
102	service?.values?.reduce<didResolver.Service[]>((acc, service) => {	10!
103	const type = service.type.at(0);	×
104	if (type === undefined) return acc;	×
105	return acc.concat({	×
106	id: service.id,
107	type: type,
108	serviceEndpoint: service.serviceEndpoint,
109	});
110	}, []) ?? [],
111	},
112	};
113	}
114
115	private getPrivateKeyAlgo(privateKey: PrivateKey): { alg: string, signer: didJWT.Signer } {
116
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 Error("Not implemented")
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 / 8735025845

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