@lifeready/core 0.6.0-beta.1

package/esm2015/lib/trusted-parties/tp-password-reset.service.js

@@ -0,0 +1,300 @@
+var TpPasswordResetService_1;
+import { __awaiter, __decorate, __rest } from "tslib";
+import { Injectable, Injector, NgZone } from '@angular/core';
+import { KeyService } from '../cryptography/key.service';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { CreateTpPasswordResetMutation, DeleteTpPasswordResetMutation, TpPasswordResetQuery, UpdateTpPasswordResetMutation, CancelTpPasswordResetRequestMutation, } from './tp-password-reset.gql';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import * as slip from '../cryptography/slip39.service';
+import { LrBadArgumentException, LrBadLogicException, } from '../_common/exceptions';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { LrMutation, LrService } from '../api/lr-graphql';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import * as i0 from "@angular/core";
+import * as i1 from "../cryptography/key.service";
+import * as i2 from "../cryptography/key-factory.service";
+import * as i3 from "../cryptography/encryption.service";
+import * as i4 from "../cryptography/key-graph.service";
+import * as i5 from "../cryptography/slip39.service";
+export class CreateSubAssembliesInput {
+}
+export class UpdateSubAssembliesInput extends CreateSubAssembliesInput {
+}
+export class CreateTpPasswordResetInput {
+}
+export class UpdateTpPasswordResetInput extends CreateTpPasswordResetInput {
+}
+let TpPasswordResetService = TpPasswordResetService_1 = class TpPasswordResetService extends LrService {
+    constructor(ngZone, injector, keyService, keyFactory, encryptionService, keyGraph, slip39Service) {
+        super(injector);
+        this.ngZone = ngZone;
+        this.injector = injector;
+        this.keyService = keyService;
+        this.keyFactory = keyFactory;
+        this.encryptionService = encryptionService;
+        this.keyGraph = keyGraph;
+        this.slip39Service = slip39Service;
+    }
+    getReset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.query({
+                query: TpPasswordResetQuery,
+            })).tpPasswordReset;
+        });
+    }
+    createReset(input) {
+        return this.mutate(this.createResetMutation(input));
+    }
+    createResetMutation(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { mutationInput } = yield this._createReset(input, (rawAssemblyKey) => __awaiter(this, void 0, void 0, function* () {
+                return this.prepareSlip39(input.createSubAssemblies, input.quorum, rawAssemblyKey);
+            }));
+            return new LrMutation({
+                mutation: CreateTpPasswordResetMutation,
+                variables: {
+                    input: mutationInput,
+                },
+            });
+        });
+    }
+    deleteReset() {
+        return this.mutate(this.deleteResetMutation());
+    }
+    deleteResetMutation() {
+        return new LrMutation({
+            mutation: DeleteTpPasswordResetMutation,
+        });
+    }
+    updateReset(input) {
+        return this.mutate(this.updateResetMutation(input));
+    }
+    updateResetMutation(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const passwordReset = yield this.getReset();
+            const { mutationInput, subjectKey, slipAssembly, assemblyKeyParams, } = yield this._createReset(input, (rawAssemblyKey) => __awaiter(this, void 0, void 0, function* () {
+                return this.prepareSlip39(input.createSubAssemblies.concat(input.updateSubAssemblies), input.quorum, rawAssemblyKey);
+            }));
+            const updateSubAssemblies = yield Promise.all(input.updateSubAssemblies.map((sa, saIndex) => __awaiter(this, void 0, void 0, function* () {
+                const subjectCipherData = yield this.encryptionService.encryptToString(subjectKey, {
+                    name: sa.name,
+                });
+                // Get the existing sub-assembly
+                const existingSa = passwordReset.assembly.subAssemblies.edges.find((edge) => edge.node.id === sa.id).node;
+                // Get approvers that do not exist yet
+                const createApprovers = [];
+                const updateApprovers = [];
+                sa.approverTps.forEach((tp) => {
+                    var _a;
+                    const approver = (_a = existingSa.approvers.edges.find((edge) => edge.node.tp.id === tp.id)) === null || _a === void 0 ? void 0 : _a.node;
+                    if (approver) {
+                        updateApprovers.push({
+                            tp,
+                            approverId: approver.id,
+                        });
+                    }
+                    else {
+                        createApprovers.push({
+                            tp,
+                        });
+                    }
+                });
+                return {
+                    subAssemblyId: sa.id,
+                    singleReject: sa.singleReject,
+                    quorum: sa.quorum,
+                    subjectCipherData,
+                    createApprovers: yield Promise.all(createApprovers.map(({ tp }, approverIndex) => __awaiter(this, void 0, void 0, function* () {
+                        return this.prepareApprover({
+                            tp,
+                            approverIndex,
+                            saIndex: saIndex + input.createSubAssemblies.length,
+                            slipAssembly,
+                            assemblyKeyParams,
+                            subjectKey,
+                        });
+                    }))),
+                    updateApprovers: yield Promise.all(updateApprovers.map(({ tp, approverId }, approverIndex) => __awaiter(this, void 0, void 0, function* () {
+                        return this.prepareApprover({
+                            approverId,
+                            tp,
+                            approverIndex: approverIndex + createApprovers.length,
+                            saIndex: saIndex + input.createSubAssemblies.length,
+                            slipAssembly,
+                            assemblyKeyParams,
+                            subjectKey,
+                        });
+                    }))),
+                };
+            })));
+            return new LrMutation({
+                mutation: UpdateTpPasswordResetMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, mutationInput), { assembly: Object.assign(Object.assign({}, mutationInput.assembly), { updateSubAssemblies }) }),
+                },
+            });
+        });
+    }
+    cancelResetRequest() {
+        return this.mutate(this.cancelResetRequestMutation());
+    }
+    cancelResetRequestMutation() {
+        return new LrMutation({
+            mutation: CancelTpPasswordResetRequestMutation,
+        });
+    }
+    validateApprovers(approvers) {
+        // Ensure all approvers have mkSharedKey.
+        for (const tp of approvers) {
+            if (!tp.currentUserSharedKey.userSharedKey.mkSharedKey) {
+                const msg = `tp ${tp.other.username} does not have mkSharedKey`;
+                console.log(msg);
+                throw new LrBadArgumentException(msg);
+            }
+        }
+    }
+    prepareApprover({ approverId, tp, approverIndex, saIndex, slipAssembly, assemblyKeyParams, subjectKey, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!tp.currentUserSharedKey.userSharedKey.mkSharedKey) {
+                throw new LrBadArgumentException(`Tp ${tp.other.username} does not have mkSharedKey. Need to reshared it first.`);
+            }
+            const sharedKey = yield this.keyFactory.createKey();
+            const tpMkSharedKey = yield this.keyGraph.getKey(tp.currentUserSharedKey.userSharedKey.mkSharedKey.id);
+            // For TP to access shared_key
+            const tpMkSharedKeyWrappedSharedKey = yield this.encryptionService.encryptToString(tpMkSharedKey.jwk, sharedKey.toJSON(true));
+            // For subject to access shared_key
+            const subjectKeyWrappedSharedKey = yield this.encryptionService.encryptToString(subjectKey, sharedKey.toJSON(true));
+            const saSlip = slipAssembly.subAssemblies[saIndex];
+            if (saSlip.index !== saIndex) {
+                // Paranoia
+                throw new LrBadLogicException('slip sub assembly index should match with array index');
+            }
+            // If quorum is 1, then using the same share for every member.
+            const share = saSlip.threshold === 1 ? saSlip.shares[0] : saSlip.shares[approverIndex];
+            const partialAssemblyKey = {
+                slip39: {
+                    share,
+                    subAssembly: {
+                        quorum: saSlip.threshold,
+                        size: saSlip.size,
+                    },
+                },
+                assemblyKeyParams,
+            };
+            console.log('partialAssemblyKey', partialAssemblyKey);
+            return {
+                tpMkSharedKeyId: tpMkSharedKey.id,
+                tpMkSharedKeyWrappedSharedKey,
+                subjectKeyWrappedSharedKey,
+                sharedCipherData: yield this.encryptionService.encryptToString(sharedKey, { a: '123' }),
+                sharedCipherApprovalData: '',
+                sharedCipherPartialAssemblyKey: yield this.encryptionService.encryptToString(sharedKey, partialAssemblyKey),
+                approverId: approverId || void 0,
+                tpId: approverId ? void 0 : tp.id,
+            };
+        });
+    }
+    // Prepare slip39
+    prepareSlip39(subAssemblies, assemblyQuorum, rawAssemblyKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Is there enough sub assemblies to meet quorum
+            if (subAssemblies.length < assemblyQuorum) {
+                throw new LrBadArgumentException('Not enough sub assemblies to meet quorum');
+            }
+            const slipAssembly = new slip.Assembly(assemblyQuorum);
+            subAssemblies.forEach((sa, index) => {
+                let approverCount = sa.approverTps.length;
+                // slip39 restricts quorum == 1 to have only 1 member. So we just share the same
+                // partial key for all sub assembly members.
+                if (sa.quorum === 1) {
+                    approverCount = 1;
+                }
+                slipAssembly.addSubAssembly(new slip.SubAssembly(index, sa.quorum, approverCount));
+            });
+            yield this.slip39Service.generateShares(rawAssemblyKey, TpPasswordResetService_1.SLIP39_PASSPHRASE, slipAssembly);
+            return slipAssembly;
+        });
+    }
+    _createReset(input, createSlipAssembly) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Create subject key
+            const masterKey = yield this.keyService.getCurrentMasterKey();
+            const subjectKey = yield this.keyFactory.createKey();
+            const assemblyKey = yield this.keyFactory.createKey();
+            const _a = assemblyKey.toJSON(true), { k: rawAssemblyKey } = _a, assemblyKeyParams = __rest(_a, ["k"]);
+            const assemblyKeyVerifierPrk = yield this.keyFactory.createPkcSignKey();
+            const wrappedAssemblyKeyVerifierPrk = yield this.encryptionService.encryptToString(assemblyKey, assemblyKeyVerifierPrk.toJSON(true));
+            const masterKeyWrappedSubjectKey = yield this.encryptionService.encryptToString(masterKey.jwk, subjectKey.toJSON(true));
+            const subjectKeyWrappedAssemblyKey = yield this.encryptionService.encryptToString(subjectKey, assemblyKey.toJSON(true));
+            // Encrypt the rootKey with the assemblyKey
+            const rootKey = yield this.keyService.getCurrentRootKey();
+            const assemblyCipherData = yield this.encryptionService.encryptToString(assemblyKey, {
+                rootKey: rootKey.jwk.toJSON(true),
+            });
+            const slipAssembly = yield createSlipAssembly(rawAssemblyKey);
+            // const slipAssembly = await this.prepareSlip39(input.createSubAssemblies, input.quorum, rawAssemblyKey);
+            const createSubAssemblies = yield Promise.all(input.createSubAssemblies.map((sa, saIndex) => __awaiter(this, void 0, void 0, function* () {
+                const subjectCipherData = yield this.encryptionService.encryptToString(subjectKey, {
+                    name: sa.name,
+                });
+                return {
+                    singleReject: sa.singleReject,
+                    quorum: sa.quorum,
+                    subjectCipherData,
+                    createApprovers: yield Promise.all(sa.approverTps.map((approverTp, approverIndex) => __awaiter(this, void 0, void 0, function* () {
+                        return this.prepareApprover({
+                            tp: approverTp,
+                            approverIndex,
+                            saIndex,
+                            slipAssembly,
+                            assemblyKeyParams,
+                            subjectKey,
+                        });
+                    }))),
+                };
+            })));
+            return {
+                subjectKey,
+                slipAssembly,
+                assemblyKeyParams,
+                mutationInput: {
+                    assembly: {
+                        singleReject: input.singleReject,
+                        quorum: input.quorum,
+                        masterKeyId: masterKey.id,
+                        masterKeyWrappedSubjectKey,
+                        subjectKeyWrappedAssemblyKey,
+                        subjectCipherData: '',
+                        assemblyCipherData,
+                        createSubAssemblies,
+                        assemblyKeyVerifierPbk: JSON.stringify(assemblyKeyVerifierPrk.toJSON()),
+                        wrappedAssemblyKeyVerifierPrk,
+                    },
+                },
+            };
+        });
+    }
+};
+TpPasswordResetService.SLIP39_PASSPHRASE = 'lifeready';
+TpPasswordResetService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TpPasswordResetService_Factory() { return new TpPasswordResetService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.KeyService), i0.ɵɵinject(i2.KeyFactoryService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i4.KeyGraphService), i0.ɵɵinject(i5.Slip39Service)); }, token: TpPasswordResetService, providedIn: "root" });
+TpPasswordResetService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+TpPasswordResetService.ctorParameters = () => [
+    { type: NgZone },
+    { type: Injector },
+    { type: KeyService },
+    { type: KeyFactoryService },
+    { type: EncryptionService },
+    { type: KeyGraphService },
+    { type: slip.Slip39Service }
+];
+TpPasswordResetService = TpPasswordResetService_1 = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], TpPasswordResetService);
+export { TpPasswordResetService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tp-password-reset.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/trusted-parties/tp-password-reset.service.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,EAC7B,oBAAoB,EACpB,6BAA6B,EAC7B,oCAAoC,GACrC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,KAAK,IAAI,MAAM,gCAAgC,CAAC;AACvD,OAAO,EACL,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAI/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,EAAoB,UAAU,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;;;;;;;AAEnE,MAAM,OAAO,wBAAwB;CAKpC;AAED,MAAM,OAAO,wBAAyB,SAAQ,wBAAwB;CAErE;AAED,MAAM,OAAO,0BAA0B;CAItC;AAED,MAAM,OAAO,0BAA2B,SAAQ,0BAA0B;CAEzE;IAmDY,sBAAsB,oCAAtB,sBAAuB,SAAQ,SAAS;IAGnD,YACU,MAAc,EACd,QAAkB,EAClB,UAAsB,EACtB,UAA6B,EAC7B,iBAAoC,EACpC,QAAyB,EACzB,aAAiC;QAEzC,KAAK,CAAC,QAAQ,CAAC,CAAC;QARR,WAAM,GAAN,MAAM,CAAQ;QACd,aAAQ,GAAR,QAAQ,CAAU;QAClB,eAAU,GAAV,UAAU,CAAY;QACtB,eAAU,GAAV,UAAU,CAAmB;QAC7B,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,aAAQ,GAAR,QAAQ,CAAiB;QACzB,kBAAa,GAAb,aAAa,CAAoB;IAG3C,CAAC;IAEK,QAAQ;;YACZ,OAAO,CACL,MAAM,IAAI,CAAC,KAAK,CAAC;gBACf,KAAK,EAAE,oBAAoB;aAC5B,CAAC,CACH,CAAC,eAAe,CAAC;QACpB,CAAC;KAAA;IAED,WAAW,CAAC,KAAiC;QAC3C,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC;IACtD,CAAC;IAEK,mBAAmB,CAAC,KAAiC;;YACzD,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,IAAI,CAAC,YAAY,CAC/C,KAAK,EACL,CAAO,cAAc,EAAE,EAAE;gBACvB,OAAO,IAAI,CAAC,aAAa,CACvB,KAAK,CAAC,mBAAmB,EACzB,KAAK,CAAC,MAAM,EACZ,cAAc,CACf,CAAC;YACJ,CAAC,CAAA,CACF,CAAC;YAEF,OAAO,IAAI,UAAU,CAAC;gBACpB,QAAQ,EAAE,6BAA6B;gBACvC,SAAS,EAAE;oBACT,KAAK,EAAE,aAAa;iBACrB;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAED,WAAW;QACT,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC,CAAC;IACjD,CAAC;IAED,mBAAmB;QACjB,OAAO,IAAI,UAAU,CAAC;YACpB,QAAQ,EAAE,6BAA6B;SACxC,CAAC,CAAC;IACL,CAAC;IAED,WAAW,CAAC,KAAiC;QAC3C,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC;IACtD,CAAC;IAEK,mBAAmB,CAAC,KAAiC;;YACzD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;YAE5C,MAAM,EACJ,aAAa,EACb,UAAU,EACV,YAAY,EACZ,iBAAiB,GAClB,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAO,cAAc,EAAE,EAAE;gBAC1D,OAAO,IAAI,CAAC,aAAa,CACvB,KAAK,CAAC,mBAAmB,CAAC,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAC3D,KAAK,CAAC,MAAM,EACZ,cAAc,CACf,CAAC;YACJ,CAAC,CAAA,CAAC,CAAC;YAEH,MAAM,mBAAmB,GAAG,MAAM,OAAO,CAAC,GAAG,CAC3C,KAAK,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAO,EAAE,EAAE,OAAO,EAAE,EAAE;gBAClD,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CACpE,UAAU,EACV;oBACE,IAAI,EAAE,EAAE,CAAC,IAAI;iBACd,CACF,CAAC;gBAEF,gCAAgC;gBAChC,MAAM,UAAU,GAAG,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAChE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CACjC,CAAC,IAAI,CAAC;gBAEP,sCAAsC;gBACtC,MAAM,eAAe,GAAG,EAAE,CAAC;gBAC3B,MAAM,eAAe,GAAG,EAAE,CAAC;gBAE3B,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE;;oBAC5B,MAAM,QAAQ,SAAG,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAC9C,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CACpC,0CAAE,IAAI,CAAC;oBACR,IAAI,QAAQ,EAAE;wBACZ,eAAe,CAAC,IAAI,CAAC;4BACnB,EAAE;4BACF,UAAU,EAAE,QAAQ,CAAC,EAAE;yBACxB,CAAC,CAAC;qBACJ;yBAAM;wBACL,eAAe,CAAC,IAAI,CAAC;4BACnB,EAAE;yBACH,CAAC,CAAC;qBACJ;gBACH,CAAC,CAAC,CAAC;gBAEH,OAAO;oBACL,aAAa,EAAE,EAAE,CAAC,EAAE;oBACpB,YAAY,EAAE,EAAE,CAAC,YAAY;oBAC7B,MAAM,EAAE,EAAE,CAAC,MAAM;oBACjB,iBAAiB;oBACjB,eAAe,EAAE,MAAM,OAAO,CAAC,GAAG,CAChC,eAAe,CAAC,GAAG,CAAC,CAAO,EAAE,EAAE,EAAE,EAAE,aAAa,EAAE,EAAE;wBAClD,OAAA,IAAI,CAAC,eAAe,CAAC;4BACnB,EAAE;4BACF,aAAa;4BACb,OAAO,EAAE,OAAO,GAAG,KAAK,CAAC,mBAAmB,CAAC,MAAM;4BACnD,YAAY;4BACZ,iBAAiB;4BACjB,UAAU;yBACX,CAAC,CAAA;sBAAA,CACH,CACF;oBACD,eAAe,EAAE,MAAM,OAAO,CAAC,GAAG,CAChC,eAAe,CAAC,GAAG,CAAC,CAAO,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,aAAa,EAAE,EAAE;wBAC9D,OAAA,IAAI,CAAC,eAAe,CAAC;4BACnB,UAAU;4BACV,EAAE;4BACF,aAAa,EAAE,aAAa,GAAG,eAAe,CAAC,MAAM;4BACrD,OAAO,EAAE,OAAO,GAAG,KAAK,CAAC,mBAAmB,CAAC,MAAM;4BACnD,YAAY;4BACZ,iBAAiB;4BACjB,UAAU;yBACX,CAAC,CAAA;sBAAA,CACH,CACF;iBACF,CAAC;YACJ,CAAC,CAAA,CAAC,CACH,CAAC;YAEF,OAAO,IAAI,UAAU,CAAC;gBACpB,QAAQ,EAAE,6BAA6B;gBACvC,SAAS,EAAE;oBACT,KAAK,kCACA,aAAa,KAChB,QAAQ,kCACH,aAAa,CAAC,QAAQ,KACzB,mBAAmB,MAEtB;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAED,kBAAkB;QAChB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE,CAAC,CAAC;IACxD,CAAC;IAED,0BAA0B;QACxB,OAAO,IAAI,UAAU,CAAC;YACpB,QAAQ,EAAE,oCAAoC;SAC/C,CAAC,CAAC;IACL,CAAC;IAED,iBAAiB,CAAC,SAAmB;QACnC,yCAAyC;QACzC,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE;YAC1B,IAAI,CAAC,EAAE,CAAC,oBAAoB,CAAC,aAAa,CAAC,WAAW,EAAE;gBACtD,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC,QAAQ,4BAA4B,CAAC;gBAChE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBACjB,MAAM,IAAI,sBAAsB,CAAC,GAAG,CAAC,CAAC;aACvC;SACF;IACH,CAAC;IAEa,eAAe,CAAC,EAC5B,UAAU,EACV,EAAE,EACF,aAAa,EACb,OAAO,EACP,YAAY,EACZ,iBAAiB,EACjB,UAAU,GASX;;YACC,IAAI,CAAC,EAAE,CAAC,oBAAoB,CAAC,aAAa,CAAC,WAAW,EAAE;gBACtD,MAAM,IAAI,sBAAsB,CAC9B,MAAM,EAAE,CAAC,KAAK,CAAC,QAAQ,wDAAwD,CAChF,CAAC;aACH;YAED,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YACpD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAC9C,EAAE,CAAC,oBAAoB,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,CACrD,CAAC;YACF,8BAA8B;YAC9B,MAAM,6BAA6B,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAChF,aAAa,CAAC,GAAG,EACjB,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CACvB,CAAC;YACF,mCAAmC;YACnC,MAAM,0BAA0B,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAC7E,UAAU,EACV,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CACvB,CAAC;YAEF,MAAM,MAAM,GAAG,YAAY,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YACnD,IAAI,MAAM,CAAC,KAAK,KAAK,OAAO,EAAE;gBAC5B,WAAW;gBACX,MAAM,IAAI,mBAAmB,CAC3B,uDAAuD,CACxD,CAAC;aACH;YAED,8DAA8D;YAC9D,MAAM,KAAK,GACT,MAAM,CAAC,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;YAE3E,MAAM,kBAAkB,GAAuB;gBAC7C,MAAM,EAAE;oBACN,KAAK;oBACL,WAAW,EAAE;wBACX,MAAM,EAAE,MAAM,CAAC,SAAS;wBACxB,IAAI,EAAE,MAAM,CAAC,IAAI;qBAClB;iBACF;gBACD,iBAAiB;aAClB,CAAC;YAEF,OAAO,CAAC,GAAG,CAAC,oBAAoB,EAAE,kBAAkB,CAAC,CAAC;YAEtD,OAAO;gBACL,eAAe,EAAE,aAAa,CAAC,EAAE;gBACjC,6BAA6B;gBAC7B,0BAA0B;gBAC1B,gBAAgB,EAAE,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAC5D,SAAS,EACT,EAAE,CAAC,EAAE,KAAK,EAAE,CACb;gBACD,wBAAwB,EAAE,EAAE;gBAC5B,8BAA8B,EAAE,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAC1E,SAAS,EACT,kBAAkB,CACnB;gBACD,UAAU,EAAE,UAAU,IAAI,KAAK,CAAC;gBAChC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE;aAClC,CAAC;QACJ,CAAC;KAAA;IAED,iBAAiB;IACH,aAAa,CACzB,aAAa,EACb,cAAsB,EACtB,cAAsB;;YAEtB,gDAAgD;YAChD,IAAI,aAAa,CAAC,MAAM,GAAG,cAAc,EAAE;gBACzC,MAAM,IAAI,sBAAsB,CAC9B,0CAA0C,CAC3C,CAAC;aACH;YAED,MAAM,YAAY,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;YAEvD,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE;gBAClC,IAAI,aAAa,GAAG,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC;gBAE1C,gFAAgF;gBAChF,4CAA4C;gBAC5C,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE;oBACnB,aAAa,GAAG,CAAC,CAAC;iBACnB;gBACD,YAAY,CAAC,cAAc,CACzB,IAAI,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,EAAE,aAAa,CAAC,CACtD,CAAC;YACJ,CAAC,CAAC,CAAC;YAEH,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CACrC,cAAc,EACd,wBAAsB,CAAC,iBAAiB,EACxC,YAAY,CACb,CAAC;YACF,OAAO,YAAY,CAAC;QACtB,CAAC;KAAA;IAEa,YAAY,CACxB,KAAiC,EACjC,kBAAkB;;YAElB,qBAAqB;YACrB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,mBAAmB,EAAE,CAAC;YAC9D,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YACrD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YACtD,MAAM,KAA8C,WAAW,CAAC,MAAM,CACpE,IAAI,CACE,EAFF,EAAE,CAAC,EAAE,cAAc,OAEjB,EAFsB,iBAAiB,cAAzC,KAA2C,CAEzC,CAAC;YACT,MAAM,sBAAsB,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,CAAC;YACxE,MAAM,6BAA6B,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAChF,WAAW,EACX,sBAAsB,CAAC,MAAM,CAAC,IAAI,CAAC,CACpC,CAAC;YAEF,MAAM,0BAA0B,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAC7E,SAAS,CAAC,GAAG,EACb,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CACxB,CAAC;YACF,MAAM,4BAA4B,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAC/E,UAAU,EACV,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CACzB,CAAC;YAEF,2CAA2C;YAC3C,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;YAE1D,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CACrE,WAAW,EACX;gBACE,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;aAClC,CACF,CAAC;YAEF,MAAM,YAAY,GAAG,MAAM,kBAAkB,CAAC,cAAc,CAAC,CAAC;YAC9D,0GAA0G;YAE1G,MAAM,mBAAmB,GAAG,MAAM,OAAO,CAAC,GAAG,CAC3C,KAAK,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAO,EAAE,EAAE,OAAO,EAAE,EAAE;gBAClD,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CACpE,UAAU,EACV;oBACE,IAAI,EAAE,EAAE,CAAC,IAAI;iBACd,CACF,CAAC;gBAEF,OAAO;oBACL,YAAY,EAAE,EAAE,CAAC,YAAY;oBAC7B,MAAM,EAAE,EAAE,CAAC,MAAM;oBACjB,iBAAiB;oBACjB,eAAe,EAAE,MAAM,OAAO,CAAC,GAAG,CAChC,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,CAAO,UAAU,EAAE,aAAa,EAAE,EAAE;wBACrD,OAAA,IAAI,CAAC,eAAe,CAAC;4BACnB,EAAE,EAAE,UAAU;4BACd,aAAa;4BACb,OAAO;4BACP,YAAY;4BACZ,iBAAiB;4BACjB,UAAU;yBACX,CAAC,CAAA;sBAAA,CACH,CACF;iBACF,CAAC;YACJ,CAAC,CAAA,CAAC,CACH,CAAC;YAEF,OAAO;gBACL,UAAU;gBACV,YAAY;gBACZ,iBAAiB;gBACjB,aAAa,EAAE;oBACb,QAAQ,EAAE;wBACR,YAAY,EAAE,KAAK,CAAC,YAAY;wBAChC,MAAM,EAAE,KAAK,CAAC,MAAM;wBACpB,WAAW,EAAE,SAAS,CAAC,EAAE;wBACzB,0BAA0B;wBAC1B,4BAA4B;wBAC5B,iBAAiB,EAAE,EAAE;wBACrB,kBAAkB;wBAClB,mBAAmB;wBACnB,sBAAsB,EAAE,IAAI,CAAC,SAAS,CACpC,sBAAsB,CAAC,MAAM,EAAE,CAChC;wBACD,6BAA6B;qBAC9B;iBACF;aACF,CAAC;QACJ,CAAC;KAAA;CACF,CAAA;AAlYe,wCAAiB,GAAG,WAAW,CAAC;;;YAJ/C,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YA7F8B,MAAM;YAAhB,QAAQ;YACpB,UAAU;YAkBV,iBAAiB;YAjBjB,iBAAiB;YAQjB,eAAe;YACZ,IAAI,CA6FgB,aAAa;;AAVhC,sBAAsB;IANlC,iBAAiB,CAAC;QACjB,UAAU,EAAE,QAAQ;KACrB,CAAC;GAIW,sBAAsB,CAmYlC;SAnYY,sBAAsB","sourcesContent":["import { Injectable, Injector, NgZone } from '@angular/core';\r\nimport { KeyService } from '../cryptography/key.service';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport {\r\n  CreateTpPasswordResetMutation,\r\n  DeleteTpPasswordResetMutation,\r\n  TpPasswordResetQuery,\r\n  UpdateTpPasswordResetMutation,\r\n  CancelTpPasswordResetRequestMutation,\r\n} from './tp-password-reset.gql';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport * as slip from '../cryptography/slip39.service';\r\nimport {\r\n  LrBadArgumentException,\r\n  LrBadLogicException,\r\n} from '../_common/exceptions';\r\nimport { PartialAssemblyKey } from '../scenario/scenario.types';\r\nimport { JWK } from 'node-jose';\r\nimport { Key } from '../cryptography/cryptography.types';\r\nimport { KeyFactoryService } from '../cryptography/key-factory.service';\r\nimport { LrGraphQLService, LrMutation, LrService } from '../api/lr-graphql';\r\nimport { TpNode } from '../api/types';\r\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\r\n\r\nexport class CreateSubAssembliesInput {\r\n  name: string;\r\n  quorum: number;\r\n  singleReject: boolean;\r\n  approverTps: TpNode[];\r\n}\r\n\r\nexport class UpdateSubAssembliesInput extends CreateSubAssembliesInput {\r\n  id: string;\r\n}\r\n\r\nexport class CreateTpPasswordResetInput {\r\n  quorum: number;\r\n  singleReject: boolean;\r\n  createSubAssemblies: CreateSubAssembliesInput[];\r\n}\r\n\r\nexport class UpdateTpPasswordResetInput extends CreateTpPasswordResetInput {\r\n  updateSubAssemblies: UpdateSubAssembliesInput[];\r\n}\r\n\r\nexport interface TpAssemblyApprovers {\r\n  id: string;\r\n  tp: {\r\n    id: string;\r\n  };\r\n  sharedKey: Key;\r\n  sharedCipherData?: string;\r\n  sharedCipherDataClearJson?: any;\r\n  sharedCipherApprovalData?: string;\r\n  sharedCipherApprovalDataClearJson?: any;\r\n}\r\n\r\nexport interface TpSubAssembly {\r\n  id: string;\r\n  singleReject: boolean;\r\n  quorum: number;\r\n  subjectCipherData: string;\r\n  plainSubjectCipherData: any;\r\n  approvers: TpAssemblyApprovers[];\r\n}\r\n\r\nexport interface TpAssembly {\r\n  singleReject: boolean;\r\n  quorum: number;\r\n  subjectKey: Key;\r\n  assemblyKey: Key;\r\n  assemblyCipherData: string;\r\n  plainAssemblyCipherData: any;\r\n  subAssemblies: TpSubAssembly[];\r\n}\r\n\r\nexport interface TpPasswordReset {\r\n  id: string;\r\n  assembly: TpAssembly;\r\n  applied: boolean;\r\n}\r\n\r\nexport interface RequestResetResult {\r\n  id: string;\r\n  associate_reset_user_token: string;\r\n  reset_username: string;\r\n}\r\n\r\n@RunOutsideAngular({\r\n  ngZoneName: 'ngZone',\r\n})\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class TpPasswordResetService extends LrService {\r\n  public static SLIP39_PASSPHRASE = 'lifeready';\r\n\r\n  constructor(\r\n    private ngZone: NgZone,\r\n    private injector: Injector,\r\n    private keyService: KeyService,\r\n    private keyFactory: KeyFactoryService,\r\n    private encryptionService: EncryptionService,\r\n    private keyGraph: KeyGraphService,\r\n    private slip39Service: slip.Slip39Service\r\n  ) {\r\n    super(injector);\r\n  }\r\n\r\n  async getReset() {\r\n    return (\r\n      await this.query({\r\n        query: TpPasswordResetQuery,\r\n      })\r\n    ).tpPasswordReset;\r\n  }\r\n\r\n  createReset(input: CreateTpPasswordResetInput) {\r\n    return this.mutate(this.createResetMutation(input));\r\n  }\r\n\r\n  async createResetMutation(input: CreateTpPasswordResetInput) {\r\n    const { mutationInput } = await this._createReset(\r\n      input,\r\n      async (rawAssemblyKey) => {\r\n        return this.prepareSlip39(\r\n          input.createSubAssemblies,\r\n          input.quorum,\r\n          rawAssemblyKey\r\n        );\r\n      }\r\n    );\r\n\r\n    return new LrMutation({\r\n      mutation: CreateTpPasswordResetMutation,\r\n      variables: {\r\n        input: mutationInput,\r\n      },\r\n    });\r\n  }\r\n\r\n  deleteReset() {\r\n    return this.mutate(this.deleteResetMutation());\r\n  }\r\n\r\n  deleteResetMutation() {\r\n    return new LrMutation({\r\n      mutation: DeleteTpPasswordResetMutation,\r\n    });\r\n  }\r\n\r\n  updateReset(input: UpdateTpPasswordResetInput) {\r\n    return this.mutate(this.updateResetMutation(input));\r\n  }\r\n\r\n  async updateResetMutation(input: UpdateTpPasswordResetInput) {\r\n    const passwordReset = await this.getReset();\r\n\r\n    const {\r\n      mutationInput,\r\n      subjectKey,\r\n      slipAssembly,\r\n      assemblyKeyParams,\r\n    } = await this._createReset(input, async (rawAssemblyKey) => {\r\n      return this.prepareSlip39(\r\n        input.createSubAssemblies.concat(input.updateSubAssemblies),\r\n        input.quorum,\r\n        rawAssemblyKey\r\n      );\r\n    });\r\n\r\n    const updateSubAssemblies = await Promise.all(\r\n      input.updateSubAssemblies.map(async (sa, saIndex) => {\r\n        const subjectCipherData = await this.encryptionService.encryptToString(\r\n          subjectKey,\r\n          {\r\n            name: sa.name,\r\n          }\r\n        );\r\n\r\n        // Get the existing sub-assembly\r\n        const existingSa = passwordReset.assembly.subAssemblies.edges.find(\r\n          (edge) => edge.node.id === sa.id\r\n        ).node;\r\n\r\n        // Get approvers that do not exist yet\r\n        const createApprovers = [];\r\n        const updateApprovers = [];\r\n\r\n        sa.approverTps.forEach((tp) => {\r\n          const approver = existingSa.approvers.edges.find(\r\n            (edge) => edge.node.tp.id === tp.id\r\n          )?.node;\r\n          if (approver) {\r\n            updateApprovers.push({\r\n              tp,\r\n              approverId: approver.id,\r\n            });\r\n          } else {\r\n            createApprovers.push({\r\n              tp,\r\n            });\r\n          }\r\n        });\r\n\r\n        return {\r\n          subAssemblyId: sa.id,\r\n          singleReject: sa.singleReject,\r\n          quorum: sa.quorum,\r\n          subjectCipherData,\r\n          createApprovers: await Promise.all(\r\n            createApprovers.map(async ({ tp }, approverIndex) =>\r\n              this.prepareApprover({\r\n                tp,\r\n                approverIndex,\r\n                saIndex: saIndex + input.createSubAssemblies.length, // slipAssembly is all sub-assemblies combined\r\n                slipAssembly,\r\n                assemblyKeyParams,\r\n                subjectKey,\r\n              })\r\n            )\r\n          ),\r\n          updateApprovers: await Promise.all(\r\n            updateApprovers.map(async ({ tp, approverId }, approverIndex) =>\r\n              this.prepareApprover({\r\n                approverId,\r\n                tp,\r\n                approverIndex: approverIndex + createApprovers.length,\r\n                saIndex: saIndex + input.createSubAssemblies.length, // slipAssembly is all sub-assemblies combined\r\n                slipAssembly,\r\n                assemblyKeyParams,\r\n                subjectKey,\r\n              })\r\n            )\r\n          ),\r\n        };\r\n      })\r\n    );\r\n\r\n    return new LrMutation({\r\n      mutation: UpdateTpPasswordResetMutation,\r\n      variables: {\r\n        input: {\r\n          ...mutationInput,\r\n          assembly: {\r\n            ...mutationInput.assembly,\r\n            updateSubAssemblies,\r\n          },\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  cancelResetRequest() {\r\n    return this.mutate(this.cancelResetRequestMutation());\r\n  }\r\n\r\n  cancelResetRequestMutation() {\r\n    return new LrMutation({\r\n      mutation: CancelTpPasswordResetRequestMutation,\r\n    });\r\n  }\r\n\r\n  validateApprovers(approvers: TpNode[]): void {\r\n    // Ensure all approvers have mkSharedKey.\r\n    for (const tp of approvers) {\r\n      if (!tp.currentUserSharedKey.userSharedKey.mkSharedKey) {\r\n        const msg = `tp ${tp.other.username} does not have mkSharedKey`;\r\n        console.log(msg);\r\n        throw new LrBadArgumentException(msg);\r\n      }\r\n    }\r\n  }\r\n\r\n  private async prepareApprover({\r\n    approverId,\r\n    tp,\r\n    approverIndex,\r\n    saIndex,\r\n    slipAssembly,\r\n    assemblyKeyParams,\r\n    subjectKey,\r\n  }: {\r\n    approverId?: string;\r\n    tp: TpNode;\r\n    approverIndex: number;\r\n    saIndex: number;\r\n    slipAssembly: slip.Assembly;\r\n    assemblyKeyParams: object;\r\n    subjectKey: JWK.Key;\r\n  }) {\r\n    if (!tp.currentUserSharedKey.userSharedKey.mkSharedKey) {\r\n      throw new LrBadArgumentException(\r\n        `Tp ${tp.other.username} does not have mkSharedKey. Need to reshared it first.`\r\n      );\r\n    }\r\n\r\n    const sharedKey = await this.keyFactory.createKey();\r\n    const tpMkSharedKey = await this.keyGraph.getKey(\r\n      tp.currentUserSharedKey.userSharedKey.mkSharedKey.id\r\n    );\r\n    // For TP to access shared_key\r\n    const tpMkSharedKeyWrappedSharedKey = await this.encryptionService.encryptToString(\r\n      tpMkSharedKey.jwk,\r\n      sharedKey.toJSON(true)\r\n    );\r\n    // For subject to access shared_key\r\n    const subjectKeyWrappedSharedKey = await this.encryptionService.encryptToString(\r\n      subjectKey,\r\n      sharedKey.toJSON(true)\r\n    );\r\n\r\n    const saSlip = slipAssembly.subAssemblies[saIndex];\r\n    if (saSlip.index !== saIndex) {\r\n      // Paranoia\r\n      throw new LrBadLogicException(\r\n        'slip sub assembly index should match with array index'\r\n      );\r\n    }\r\n\r\n    // If quorum is 1, then using the same share for every member.\r\n    const share =\r\n      saSlip.threshold === 1 ? saSlip.shares[0] : saSlip.shares[approverIndex];\r\n\r\n    const partialAssemblyKey: PartialAssemblyKey = {\r\n      slip39: {\r\n        share,\r\n        subAssembly: {\r\n          quorum: saSlip.threshold,\r\n          size: saSlip.size,\r\n        },\r\n      },\r\n      assemblyKeyParams,\r\n    };\r\n\r\n    console.log('partialAssemblyKey', partialAssemblyKey);\r\n\r\n    return {\r\n      tpMkSharedKeyId: tpMkSharedKey.id,\r\n      tpMkSharedKeyWrappedSharedKey,\r\n      subjectKeyWrappedSharedKey,\r\n      sharedCipherData: await this.encryptionService.encryptToString(\r\n        sharedKey,\r\n        { a: '123' }\r\n      ),\r\n      sharedCipherApprovalData: '',\r\n      sharedCipherPartialAssemblyKey: await this.encryptionService.encryptToString(\r\n        sharedKey,\r\n        partialAssemblyKey\r\n      ),\r\n      approverId: approverId || void 0,\r\n      tpId: approverId ? void 0 : tp.id,\r\n    };\r\n  }\r\n\r\n  // Prepare slip39\r\n  private async prepareSlip39(\r\n    subAssemblies,\r\n    assemblyQuorum: number,\r\n    rawAssemblyKey: string\r\n  ): Promise<slip.Assembly> {\r\n    // Is there enough sub assemblies to meet quorum\r\n    if (subAssemblies.length < assemblyQuorum) {\r\n      throw new LrBadArgumentException(\r\n        'Not enough sub assemblies to meet quorum'\r\n      );\r\n    }\r\n\r\n    const slipAssembly = new slip.Assembly(assemblyQuorum);\r\n\r\n    subAssemblies.forEach((sa, index) => {\r\n      let approverCount = sa.approverTps.length;\r\n\r\n      // slip39 restricts quorum == 1 to have only 1 member. So we just share the same\r\n      // partial key for all sub assembly members.\r\n      if (sa.quorum === 1) {\r\n        approverCount = 1;\r\n      }\r\n      slipAssembly.addSubAssembly(\r\n        new slip.SubAssembly(index, sa.quorum, approverCount)\r\n      );\r\n    });\r\n\r\n    await this.slip39Service.generateShares(\r\n      rawAssemblyKey,\r\n      TpPasswordResetService.SLIP39_PASSPHRASE,\r\n      slipAssembly\r\n    );\r\n    return slipAssembly;\r\n  }\r\n\r\n  private async _createReset(\r\n    input: CreateTpPasswordResetInput,\r\n    createSlipAssembly\r\n  ): Promise<any> {\r\n    // Create subject key\r\n    const masterKey = await this.keyService.getCurrentMasterKey();\r\n    const subjectKey = await this.keyFactory.createKey();\r\n    const assemblyKey = await this.keyFactory.createKey();\r\n    const { k: rawAssemblyKey, ...assemblyKeyParams } = assemblyKey.toJSON(\r\n      true\r\n    ) as any;\r\n    const assemblyKeyVerifierPrk = await this.keyFactory.createPkcSignKey();\r\n    const wrappedAssemblyKeyVerifierPrk = await this.encryptionService.encryptToString(\r\n      assemblyKey,\r\n      assemblyKeyVerifierPrk.toJSON(true)\r\n    );\r\n\r\n    const masterKeyWrappedSubjectKey = await this.encryptionService.encryptToString(\r\n      masterKey.jwk,\r\n      subjectKey.toJSON(true)\r\n    );\r\n    const subjectKeyWrappedAssemblyKey = await this.encryptionService.encryptToString(\r\n      subjectKey,\r\n      assemblyKey.toJSON(true)\r\n    );\r\n\r\n    // Encrypt the rootKey with the assemblyKey\r\n    const rootKey = await this.keyService.getCurrentRootKey();\r\n\r\n    const assemblyCipherData = await this.encryptionService.encryptToString(\r\n      assemblyKey,\r\n      {\r\n        rootKey: rootKey.jwk.toJSON(true),\r\n      }\r\n    );\r\n\r\n    const slipAssembly = await createSlipAssembly(rawAssemblyKey);\r\n    // const slipAssembly = await this.prepareSlip39(input.createSubAssemblies, input.quorum, rawAssemblyKey);\r\n\r\n    const createSubAssemblies = await Promise.all(\r\n      input.createSubAssemblies.map(async (sa, saIndex) => {\r\n        const subjectCipherData = await this.encryptionService.encryptToString(\r\n          subjectKey,\r\n          {\r\n            name: sa.name,\r\n          }\r\n        );\r\n\r\n        return {\r\n          singleReject: sa.singleReject,\r\n          quorum: sa.quorum,\r\n          subjectCipherData,\r\n          createApprovers: await Promise.all(\r\n            sa.approverTps.map(async (approverTp, approverIndex) =>\r\n              this.prepareApprover({\r\n                tp: approverTp,\r\n                approverIndex,\r\n                saIndex,\r\n                slipAssembly,\r\n                assemblyKeyParams,\r\n                subjectKey,\r\n              })\r\n            )\r\n          ),\r\n        };\r\n      })\r\n    );\r\n\r\n    return {\r\n      subjectKey,\r\n      slipAssembly,\r\n      assemblyKeyParams,\r\n      mutationInput: {\r\n        assembly: {\r\n          singleReject: input.singleReject,\r\n          quorum: input.quorum,\r\n          masterKeyId: masterKey.id,\r\n          masterKeyWrappedSubjectKey,\r\n          subjectKeyWrappedAssemblyKey,\r\n          subjectCipherData: '',\r\n          assemblyCipherData,\r\n          createSubAssemblies,\r\n          assemblyKeyVerifierPbk: JSON.stringify(\r\n            assemblyKeyVerifierPrk.toJSON()\r\n          ),\r\n          wrappedAssemblyKeyVerifierPrk,\r\n        },\r\n      },\r\n    };\r\n  }\r\n}\r\n"]}

package/esm2015/lib/trusted-parties/trusted-party.gql.js

@@ -0,0 +1,148 @@
+import gql from 'graphql-tag';
+import { KeyGraphField } from '../_common/queries.gql';
+import { KeyExchangeFields, UserSharedKeyFields, } from '../api/key-exchange.gql';
+import { SharedContactCardFields } from '../api/shared-contact-card.service';
+export const TrustedPartyProperties = `
+  id
+  user {
+    id
+    username
+  }
+  other{
+    id
+    username,
+    features {
+      shareVault
+    }
+  }
+  sharedContactCard {
+    ${SharedContactCardFields}
+  }
+  myContactCard {
+    ${SharedContactCardFields}
+  }
+  sharedScenarios {
+    edges {
+      node {
+        id
+      }
+    }
+  }
+  sharedItems {
+    directories {
+      edges {
+        node {
+          id
+        }
+      }
+    }
+  }
+  currentUserSharedKey {
+    userSharedKey {
+      keyExchange {
+        ${KeyExchangeFields}
+      }
+      ${UserSharedKeyFields}
+    }
+  }`;
+export const GetTrustedPartiesQuery = gql `
+query GetTrustedPartiesQuery {
+  tps {
+    edges {
+      node {
+        ${TrustedPartyProperties}
+      }
+    }
+  }
+  ${KeyGraphField}
+}`;
+export const GetAllTrustedPartiesQuery = gql `
+query GetAllTrustedPartiesQuery($userId: ID, $isExpired: Boolean, $inviteState: String, $sentInviteState: String) {
+  tps {
+    edges {
+      node {
+        ${TrustedPartyProperties}
+      }
+    }
+  }
+  invites: keyExchanges(
+    responder: $userId
+    isExpired: $isExpired
+    state: $inviteState
+    orderBy: "state,-created"
+  ) {
+    edges {
+      node {
+        ${KeyExchangeFields}
+      }
+    }
+  }
+  sentInvites: keyExchanges(
+    initiator: $userId
+    isExpired: $isExpired
+    state: $sentInviteState
+    orderBy: "state,-created"
+  ) {
+    edges {
+      node {
+        ${KeyExchangeFields}
+      }
+    }
+  }
+  ${KeyGraphField}
+}`;
+export const GetTrustedPartyQuery = gql `
+query GetTrustedPartyQuery($partyId: LrRelayIdInput!) {
+  tp(id: $partyId) {
+    ${TrustedPartyProperties}
+  }
+  ${KeyGraphField}
+}`;
+export const DeclineTrustedPartyInvitationMutation = gql `
+  mutation DeclineKeyExchange($input: DeclineKeyExchangeInput!) {
+    declineKeyExchange(input: $input) {
+      keyExchange {
+        id
+      }
+    }
+  }
+`;
+export const CancelTrustedPartyInvitationMutation = gql `
+  mutation CancelKeyExchange($input: CancelKeyExchangeInput!) {
+    cancelKeyExchange(input: $input) {
+      keyExchange {
+        id
+      }
+    }
+  }
+`;
+export const DeleteTrustedPartyMutation = gql `
+  mutation DeleteTpMutation($input: DeleteTpInput!) {
+    deleteTp(input: $input) {
+      id
+    }
+  }
+`;
+export const ShareCategoryMutation = gql `
+  mutation ShareDirectory($input: ShareDirectoryInput!) {
+    shareDirectory(input: $input) {
+      tpDirectory {
+        item {
+          plainMeta
+        }
+      }
+    }
+  }
+`;
+export const UnshareCategoryMutation = gql `
+  mutation UnshareDirectory($input: UnshareDirectoryInput!) {
+    unshareDirectory(input: $input) {
+      tpDirectory {
+        item {
+          plainMeta
+        }
+      }
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJ1c3RlZC1wYXJ0eS5ncWwuanMiLCJzb3VyY2VSb290IjoiQzovUHJvamVjdHMvdGVzdC9wcm9qZWN0cy9jb3JlL3NyYy8iLCJzb3VyY2VzIjpbImxpYi90cnVzdGVkLXBhcnRpZXMvdHJ1c3RlZC1wYXJ0eS5ncWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxHQUFHLE1BQU0sYUFBYSxDQUFDO0FBQzlCLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN2RCxPQUFPLEVBQ0wsaUJBQWlCLEVBQ2pCLG1CQUFtQixHQUNwQixNQUFNLHlCQUF5QixDQUFDO0FBQ2pDLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRTdFLE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHOzs7Ozs7Ozs7Ozs7OztNQWNoQyx1QkFBdUI7OztNQUd2Qix1QkFBdUI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztVQXFCbkIsaUJBQWlCOztRQUVuQixtQkFBbUI7O0lBRXZCLENBQUM7QUFFTCxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxHQUFHLENBQUE7Ozs7O1VBSy9CLHNCQUFzQjs7OztJQUk1QixhQUFhO0VBQ2YsQ0FBQztBQUVILE1BQU0sQ0FBQyxNQUFNLHlCQUF5QixHQUFHLEdBQUcsQ0FBQTs7Ozs7VUFLbEMsc0JBQXNCOzs7Ozs7Ozs7Ozs7VUFZdEIsaUJBQWlCOzs7Ozs7Ozs7Ozs7VUFZakIsaUJBQWlCOzs7O0lBSXZCLGFBQWE7RUFDZixDQUFDO0FBRUgsTUFBTSxDQUFDLE1BQU0sb0JBQW9CLEdBQUcsR0FBRyxDQUFBOzs7TUFHakMsc0JBQXNCOztJQUV4QixhQUFhO0VBQ2YsQ0FBQztBQUVILE1BQU0sQ0FBQyxNQUFNLHFDQUFxQyxHQUFHLEdBQUcsQ0FBQTs7Ozs7Ozs7Q0FRdkQsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLG9DQUFvQyxHQUFHLEdBQUcsQ0FBQTs7Ozs7Ozs7Q0FRdEQsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLDBCQUEwQixHQUFHLEdBQUcsQ0FBQTs7Ozs7O0NBTTVDLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxHQUFHLENBQUE7Ozs7Ozs7Ozs7Q0FVdkMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLEdBQUcsQ0FBQTs7Ozs7Ozs7OztDQVV6QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGdxbCBmcm9tICdncmFwaHFsLXRhZyc7XHJcbmltcG9ydCB7IEtleUdyYXBoRmllbGQgfSBmcm9tICcuLi9fY29tbW9uL3F1ZXJpZXMuZ3FsJztcclxuaW1wb3J0IHtcclxuICBLZXlFeGNoYW5nZUZpZWxkcyxcclxuICBVc2VyU2hhcmVkS2V5RmllbGRzLFxyXG59IGZyb20gJy4uL2FwaS9rZXktZXhjaGFuZ2UuZ3FsJztcclxuaW1wb3J0IHsgU2hhcmVkQ29udGFjdENhcmRGaWVsZHMgfSBmcm9tICcuLi9hcGkvc2hhcmVkLWNvbnRhY3QtY2FyZC5zZXJ2aWNlJztcclxuXHJcbmV4cG9ydCBjb25zdCBUcnVzdGVkUGFydHlQcm9wZXJ0aWVzID0gYFxyXG4gIGlkXHJcbiAgdXNlciB7XHJcbiAgICBpZFxyXG4gICAgdXNlcm5hbWVcclxuICB9XHJcbiAgb3RoZXJ7XHJcbiAgICBpZFxyXG4gICAgdXNlcm5hbWUsXHJcbiAgICBmZWF0dXJlcyB7XHJcbiAgICAgIHNoYXJlVmF1bHRcclxuICAgIH1cclxuICB9XHJcbiAgc2hhcmVkQ29udGFjdENhcmQge1xyXG4gICAgJHtTaGFyZWRDb250YWN0Q2FyZEZpZWxkc31cclxuICB9XHJcbiAgbXlDb250YWN0Q2FyZCB7XHJcbiAgICAke1NoYXJlZENvbnRhY3RDYXJkRmllbGRzfVxyXG4gIH1cclxuICBzaGFyZWRTY2VuYXJpb3Mge1xyXG4gICAgZWRnZXMge1xyXG4gICAgICBub2RlIHtcclxuICAgICAgICBpZFxyXG4gICAgICB9XHJcbiAgICB9XHJcbiAgfVxyXG4gIHNoYXJlZEl0ZW1zIHtcclxuICAgIGRpcmVjdG9yaWVzIHtcclxuICAgICAgZWRnZXMge1xyXG4gICAgICAgIG5vZGUge1xyXG4gICAgICAgICAgaWRcclxuICAgICAgICB9XHJcbiAgICAgIH1cclxuICAgIH1cclxuICB9XHJcbiAgY3VycmVudFVzZXJTaGFyZWRLZXkge1xyXG4gICAgdXNlclNoYXJlZEtleSB7XHJcbiAgICAgIGtleUV4Y2hhbmdlIHtcclxuICAgICAgICAke0tleUV4Y2hhbmdlRmllbGRzfVxyXG4gICAgICB9XHJcbiAgICAgICR7VXNlclNoYXJlZEtleUZpZWxkc31cclxuICAgIH1cclxuICB9YDtcclxuXHJcbmV4cG9ydCBjb25zdCBHZXRUcnVzdGVkUGFydGllc1F1ZXJ5ID0gZ3FsYFxyXG5xdWVyeSBHZXRUcnVzdGVkUGFydGllc1F1ZXJ5IHtcclxuICB0cHMge1xyXG4gICAgZWRnZXMge1xyXG4gICAgICBub2RlIHtcclxuICAgICAgICAke1RydXN0ZWRQYXJ0eVByb3BlcnRpZXN9XHJcbiAgICAgIH1cclxuICAgIH1cclxuICB9XHJcbiAgJHtLZXlHcmFwaEZpZWxkfVxyXG59YDtcclxuXHJcbmV4cG9ydCBjb25zdCBHZXRBbGxUcnVzdGVkUGFydGllc1F1ZXJ5ID0gZ3FsYFxyXG5xdWVyeSBHZXRBbGxUcnVzdGVkUGFydGllc1F1ZXJ5KCR1c2VySWQ6IElELCAkaXNFeHBpcmVkOiBCb29sZWFuLCAkaW52aXRlU3RhdGU6IFN0cmluZywgJHNlbnRJbnZpdGVTdGF0ZTogU3RyaW5nKSB7XHJcbiAgdHBzIHtcclxuICAgIGVkZ2VzIHtcclxuICAgICAgbm9kZSB7XHJcbiAgICAgICAgJHtUcnVzdGVkUGFydHlQcm9wZXJ0aWVzfVxyXG4gICAgICB9XHJcbiAgICB9XHJcbiAgfVxyXG4gIGludml0ZXM6IGtleUV4Y2hhbmdlcyhcclxuICAgIHJlc3BvbmRlcjogJHVzZXJJZFxyXG4gICAgaXNFeHBpcmVkOiAkaXNFeHBpcmVkXHJcbiAgICBzdGF0ZTogJGludml0ZVN0YXRlXHJcbiAgICBvcmRlckJ5OiBcInN0YXRlLC1jcmVhdGVkXCJcclxuICApIHtcclxuICAgIGVkZ2VzIHtcclxuICAgICAgbm9kZSB7XHJcbiAgICAgICAgJHtLZXlFeGNoYW5nZUZpZWxkc31cclxuICAgICAgfVxyXG4gICAgfVxyXG4gIH1cclxuICBzZW50SW52aXRlczoga2V5RXhjaGFuZ2VzKFxyXG4gICAgaW5pdGlhdG9yOiAkdXNlcklkXHJcbiAgICBpc0V4cGlyZWQ6ICRpc0V4cGlyZWRcclxuICAgIHN0YXRlOiAkc2VudEludml0ZVN0YXRlXHJcbiAgICBvcmRlckJ5OiBcInN0YXRlLC1jcmVhdGVkXCJcclxuICApIHtcclxuICAgIGVkZ2VzIHtcclxuICAgICAgbm9kZSB7XHJcbiAgICAgICAgJHtLZXlFeGNoYW5nZUZpZWxkc31cclxuICAgICAgfVxyXG4gICAgfVxyXG4gIH1cclxuICAke0tleUdyYXBoRmllbGR9XHJcbn1gO1xyXG5cclxuZXhwb3J0IGNvbnN0IEdldFRydXN0ZWRQYXJ0eVF1ZXJ5ID0gZ3FsYFxyXG5xdWVyeSBHZXRUcnVzdGVkUGFydHlRdWVyeSgkcGFydHlJZDogTHJSZWxheUlkSW5wdXQhKSB7XHJcbiAgdHAoaWQ6ICRwYXJ0eUlkKSB7XHJcbiAgICAke1RydXN0ZWRQYXJ0eVByb3BlcnRpZXN9XHJcbiAgfVxyXG4gICR7S2V5R3JhcGhGaWVsZH1cclxufWA7XHJcblxyXG5leHBvcnQgY29uc3QgRGVjbGluZVRydXN0ZWRQYXJ0eUludml0YXRpb25NdXRhdGlvbiA9IGdxbGBcclxuICBtdXRhdGlvbiBEZWNsaW5lS2V5RXhjaGFuZ2UoJGlucHV0OiBEZWNsaW5lS2V5RXhjaGFuZ2VJbnB1dCEpIHtcclxuICAgIGRlY2xpbmVLZXlFeGNoYW5nZShpbnB1dDogJGlucHV0KSB7XHJcbiAgICAgIGtleUV4Y2hhbmdlIHtcclxuICAgICAgICBpZFxyXG4gICAgICB9XHJcbiAgICB9XHJcbiAgfVxyXG5gO1xyXG5cclxuZXhwb3J0IGNvbnN0IENhbmNlbFRydXN0ZWRQYXJ0eUludml0YXRpb25NdXRhdGlvbiA9IGdxbGBcclxuICBtdXRhdGlvbiBDYW5jZWxLZXlFeGNoYW5nZSgkaW5wdXQ6IENhbmNlbEtleUV4Y2hhbmdlSW5wdXQhKSB7XHJcbiAgICBjYW5jZWxLZXlFeGNoYW5nZShpbnB1dDogJGlucHV0KSB7XHJcbiAgICAgIGtleUV4Y2hhbmdlIHtcclxuICAgICAgICBpZFxyXG4gICAgICB9XHJcbiAgICB9XHJcbiAgfVxyXG5gO1xyXG5cclxuZXhwb3J0IGNvbnN0IERlbGV0ZVRydXN0ZWRQYXJ0eU11dGF0aW9uID0gZ3FsYFxyXG4gIG11dGF0aW9uIERlbGV0ZVRwTXV0YXRpb24oJGlucHV0OiBEZWxldGVUcElucHV0ISkge1xyXG4gICAgZGVsZXRlVHAoaW5wdXQ6ICRpbnB1dCkge1xyXG4gICAgICBpZFxyXG4gICAgfVxyXG4gIH1cclxuYDtcclxuXHJcbmV4cG9ydCBjb25zdCBTaGFyZUNhdGVnb3J5TXV0YXRpb24gPSBncWxgXHJcbiAgbXV0YXRpb24gU2hhcmVEaXJlY3RvcnkoJGlucHV0OiBTaGFyZURpcmVjdG9yeUlucHV0ISkge1xyXG4gICAgc2hhcmVEaXJlY3RvcnkoaW5wdXQ6ICRpbnB1dCkge1xyXG4gICAgICB0cERpcmVjdG9yeSB7XHJcbiAgICAgICAgaXRlbSB7XHJcbiAgICAgICAgICBwbGFpbk1ldGFcclxuICAgICAgICB9XHJcbiAgICAgIH1cclxuICAgIH1cclxuICB9XHJcbmA7XHJcblxyXG5leHBvcnQgY29uc3QgVW5zaGFyZUNhdGVnb3J5TXV0YXRpb24gPSBncWxgXHJcbiAgbXV0YXRpb24gVW5zaGFyZURpcmVjdG9yeSgkaW5wdXQ6IFVuc2hhcmVEaXJlY3RvcnlJbnB1dCEpIHtcclxuICAgIHVuc2hhcmVEaXJlY3RvcnkoaW5wdXQ6ICRpbnB1dCkge1xyXG4gICAgICB0cERpcmVjdG9yeSB7XHJcbiAgICAgICAgaXRlbSB7XHJcbiAgICAgICAgICBwbGFpbk1ldGFcclxuICAgICAgICB9XHJcbiAgICAgIH1cclxuICAgIH1cclxuICB9XHJcbmA7XHJcbiJdfQ==