@lifeready/core 0.6.0-beta.1

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

@@ -0,0 +1,266 @@
+import { __awaiter, __decorate } from "tslib";
+import { Hub } from '@aws-amplify/core';
+import { Inject, Injectable, Injector, NgZone } from '@angular/core';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { LR_CONFIG } from '../life-ready.config';
+import * as slip from '../cryptography/slip39.service';
+import { JWK } from 'node-jose';
+import { LrBadStateException, LrException } from '../_common/exceptions';
+import { CompleteTpPasswordResetRequestMutation, CreateTpAssemblyKeyChallengeMutation, PreCompleteTpPasswordResetRequestMutation, } from './tp-password-reset.gql';
+import { PasswordService } from '../auth/password.service';
+import { HttpClient } from '@angular/common/http';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { TpPasswordResetService, } from './tp-password-reset.service';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { TpClaimState } from '../api/types';
+import { LrMutation, LrService } from '../api/lr-graphql';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import * as i0 from "@angular/core";
+import * as i1 from "../life-ready.config";
+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";
+import * as i6 from "../auth/password.service";
+import * as i7 from "@angular/common/http";
+import * as i8 from "@aws-amplify/auth/lib-esm/Auth";
+import * as i9 from "../auth/life-ready-auth.service";
+let TpPasswordResetUserService = class TpPasswordResetUserService extends LrService {
+    constructor(ngZone, injector, config, keyFactory, encryptionService, keyGraphService, slip39Service, passwordService, http, auth, lrAuth) {
+        super(injector);
+        this.ngZone = ngZone;
+        this.injector = injector;
+        this.config = config;
+        this.keyFactory = keyFactory;
+        this.encryptionService = encryptionService;
+        this.keyGraphService = keyGraphService;
+        this.slip39Service = slip39Service;
+        this.passwordService = passwordService;
+        this.http = http;
+        this.auth = auth;
+        this.lrAuth = lrAuth;
+        this.CLIENT_NONCE_LENGTH = 32;
+    }
+    verifyEmailContact(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                email,
+            };
+            return this.http
+                .post(`${this.config.authUrl}tp/password-reset/verify-contact/`, params)
+                .toPromise();
+        });
+    }
+    verifyContactRespond(claimId, claimCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { token } = yield this.http
+                .post(`${this.config.authUrl}cove/respond/`, {
+                claim_id: claimId,
+                v_code: claimCode,
+            })
+                .toPromise();
+            return token;
+        });
+    }
+    requestReset(password, claimId, claimToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Generate the key materials
+            const passKeyBundle = yield this.passwordService.createPassKeyBundle(password);
+            const masterKey = yield this.keyFactory.createKey();
+            const wrappedMasterKey = yield this.encryptionService.encrypt(passKeyBundle.passKey, masterKey.toJSON(true));
+            // Ephemeral PKC key
+            const prk = yield this.keyFactory.createPkcKey();
+            const masterKeyWrappedPrk = yield this.encryptionService.encrypt(masterKey, prk.toJSON(true));
+            // API call to setup reset request
+            const requestResetResult = yield this.http
+                .post(`${this.config.authUrl}tp/password-reset/request/`, {
+                claimId,
+                claimToken,
+                pass_key_params: passKeyBundle.passKeyParams,
+                pass_idp_params: passKeyBundle.passIdpParams,
+                pass_idp_verifier_pbk: passKeyBundle.passIdpVerifier.toJSON(),
+                wrapped_pass_idp_verifier_prk: passKeyBundle.wrappedPassIdpVerifierPrk,
+                wrapped_master_key: wrappedMasterKey,
+                pbk: prk.toJSON(),
+                master_key_wrapped_prk: masterKeyWrappedPrk,
+            })
+                .toPromise();
+            console.log(requestResetResult);
+            console.log('Using new password: ', this.passwordService.getPassIdpString(passKeyBundle.passIdp));
+            // API call to create user on cognito
+            const signUpResult = yield this.auth.signUp({
+                username: requestResetResult.reset_username,
+                password: this.passwordService.getPassIdpString(passKeyBundle.passIdp),
+                clientMetadata: {
+                    tp_password_reset_request: JSON.stringify({
+                        id: requestResetResult.id,
+                        associate_reset_user_token: requestResetResult.associate_reset_user_token,
+                    }),
+                },
+            });
+            console.log('requestRest done: ', signUpResult);
+            return {
+                requestResetResult,
+                signUpResult,
+            };
+        });
+    }
+    getResetUser(reload = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!reload && this.resetUser) {
+                return this.resetUser;
+            }
+            this.resetUser = yield this.lrAuth.loadResetUser();
+            return this.resetUser;
+        });
+    }
+    recoverAssemblyKey(resetUser) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Recover the assembly key.
+            let assemblyKeyParams;
+            const prk = yield this.keyGraphService.getKey(resetUser.pxk.id);
+            const shares = yield Promise.all(resetUser.approvals.map((approval) => __awaiter(this, void 0, void 0, function* () {
+                const partialAssemblyKey = yield this.encryptionService.decrypt(prk, approval.receiverCipherPartialAssemblyKey);
+                if (assemblyKeyParams) {
+                    if (JSON.stringify(assemblyKeyParams) !==
+                        JSON.stringify(partialAssemblyKey.assemblyKeyParams)) {
+                        throw new LrBadStateException('The assembly key parameters are different between the approvals.');
+                    }
+                }
+                else {
+                    assemblyKeyParams = partialAssemblyKey.assemblyKeyParams;
+                }
+                return partialAssemblyKey.slip39.share.mnemonics;
+            })));
+            console.log('recoverAssemblyKey()', shares);
+            const rawAssemblyKey = yield this.slip39Service.recoverSecret(shares, TpPasswordResetService.SLIP39_PASSPHRASE);
+            return JWK.asKey(Object.assign(Object.assign({}, assemblyKeyParams), { k: rawAssemblyKey }));
+        });
+    }
+    completeRequest(newPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resetUser = yield this.getResetUser(true);
+            if (resetUser.state !== TpClaimState.APPROVED) {
+                throw new LrBadStateException('Password reset request has not been approved.');
+            }
+            // --------------------------------------------------------------
+            // Prepare all materials to ensure there are no errors.
+            // --------------------------------------------------------------
+            const assemblyKey = yield this.recoverAssemblyKey(resetUser);
+            const { rootKey } = yield this.encryptionService.decrypt(assemblyKey, resetUser.assemblyCipherData);
+            console.log(rootKey);
+            // Making sure it's a valid key.
+            const rootKeyJwk = yield JWK.asKey(rootKey);
+            const masterKey = yield this.keyGraphService.getKey(resetUser.masterKey.id);
+            const masterKeyWrappedRootKey = yield this.encryptionService.encryptToString(masterKey.jwk, rootKeyJwk.toJSON(true));
+            // The new password
+            const newPassIdpResult = yield this.keyFactory.derivePassIdp(Object.assign({ password: newPassword }, resetUser.passKey.passIdpParams));
+            const newIdpPassword = this.passwordService.getPassIdpString(newPassIdpResult.jwk);
+            // --------------------------------------------------------------
+            // Get assembly key challenge
+            // --------------------------------------------------------------
+            const challenge = (yield this.mutate(new LrMutation({
+                mutation: CreateTpAssemblyKeyChallengeMutation,
+                variables: {
+                    input: {},
+                },
+            }), {
+                includeKeyGraph: false,
+            })).createTpAssemblyKeyChallenge.challenge;
+            console.log(challenge);
+            // Sign the challenge
+            // Generate a client side nonce that's no in the server's control.
+            challenge.clientNonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);
+            console.log(challenge);
+            const assemblyKeyVerifierPrk = yield this.encryptionService.decrypt(assemblyKey, resetUser.wrappedAssemblyKeyVerifierPrk);
+            const signedChallenge = yield this.encryptionService.sign(assemblyKeyVerifierPrk, challenge);
+            // --------------------------------------------------------------
+            // Change password for the original user
+            // --------------------------------------------------------------
+            const tempIdpPassword = (yield this.mutate(new LrMutation({
+                mutation: PreCompleteTpPasswordResetRequestMutation,
+                variables: {
+                    input: {
+                        signedChallenge: JSON.stringify(signedChallenge),
+                    },
+                },
+            }), {
+                includeKeyGraph: false,
+            })).preCompleteTpPasswordResetRequest.idpPassword;
+            // --------------------------------------------------------------
+            // Login as the original user using new temporary password
+            // --------------------------------------------------------------
+            // At this point, the original account's password has been changed
+            // to a temporary password. It is no longer possible for the user
+            // to use the original password to login. Any successful login
+            // can only be using the temporary password. So it's safe to assume
+            // that we want to "complete" the password reset.
+            // The maybe 2FA so we listen for the auth event from Amplify.
+            const retPromise = new Promise((resolve) => {
+                const listener = (data) => __awaiter(this, void 0, void 0, function* () {
+                    if (data.payload.event !== 'signIn') {
+                        return;
+                    }
+                    Hub.remove('auth', listener);
+                    console.log(data.payload);
+                    yield this.auth.signIn(resetUser.username, newIdpPassword);
+                    // Switch over to the new set of keys
+                    yield this.mutate(new LrMutation({
+                        mutation: CompleteTpPasswordResetRequestMutation,
+                        variables: {
+                            input: {
+                                masterKeyWrappedRootKey,
+                                masterKeyId: masterKey.id,
+                            },
+                        },
+                    }));
+                    resolve();
+                });
+                Hub.listen('auth', listener);
+            });
+            // Signin as the original user. Password has been reset to temporary one. It should return
+            // with NEW_PASSWORD_REQUIRED
+            let user = yield this.auth.signIn(resetUser.username, tempIdpPassword, {
+                noProxy: 'true',
+            });
+            if (user.challengeName !== 'NEW_PASSWORD_REQUIRED') {
+                throw new LrException({
+                    message: 'Internal error. Expecting Cognito to have done a password reset after call to PreCompleteTpPasswordResetRequestMutation.',
+                });
+            }
+            // Set new password on Idp
+            // the awsFetch() function passes NEW_PASSWORD_REQUIRED directly to AWS without
+            // going through the proxy.
+            user = yield this.auth.completeNewPassword(user, newIdpPassword, {});
+            return retPromise;
+        });
+    }
+};
+TpPasswordResetUserService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TpPasswordResetUserService_Factory() { return new TpPasswordResetUserService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.KeyFactoryService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i4.KeyGraphService), i0.ɵɵinject(i5.Slip39Service), i0.ɵɵinject(i6.PasswordService), i0.ɵɵinject(i7.HttpClient), i0.ɵɵinject(i8.AuthClass), i0.ɵɵinject(i9.LifeReadyAuthService)); }, token: TpPasswordResetUserService, providedIn: "root" });
+TpPasswordResetUserService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+TpPasswordResetUserService.ctorParameters = () => [
+    { type: NgZone },
+    { type: Injector },
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: KeyFactoryService },
+    { type: EncryptionService },
+    { type: KeyGraphService },
+    { type: slip.Slip39Service },
+    { type: PasswordService },
+    { type: HttpClient },
+    { type: AuthClass },
+    { type: LifeReadyAuthService }
+];
+TpPasswordResetUserService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], TpPasswordResetUserService);
+export { TpPasswordResetUserService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tp-password-reset-user.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/trusted-parties/tp-password-reset-user.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAmB,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,IAAI,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EACL,sCAAsC,EACtC,oCAAoC,EACpC,yCAAyC,GAC1C,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC3D,OAAO,EAEL,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,EAAE,YAAY,EAA2B,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;;;;;;;;;;;IAQtD,0BAA0B,SAA1B,0BAA2B,SAAQ,SAAS;IAIvD,YACU,MAAc,EACd,QAAkB,EACC,MAAuB,EAC1C,UAA6B,EAC7B,iBAAoC,EACpC,eAAgC,EAChC,aAAiC,EACjC,eAAgC,EAChC,IAAgB,EAChB,IAAe,EACf,MAA4B;QAEpC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAZR,WAAM,GAAN,MAAM,CAAQ;QACd,aAAQ,GAAR,QAAQ,CAAU;QACC,WAAM,GAAN,MAAM,CAAiB;QAC1C,eAAU,GAAV,UAAU,CAAmB;QAC7B,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,oBAAe,GAAf,eAAe,CAAiB;QAChC,kBAAa,GAAb,aAAa,CAAoB;QACjC,oBAAe,GAAf,eAAe,CAAiB;QAChC,SAAI,GAAJ,IAAI,CAAY;QAChB,SAAI,GAAJ,IAAI,CAAW;QACf,WAAM,GAAN,MAAM,CAAsB;QAdrB,wBAAmB,GAAG,EAAE,CAAC;IAiB1C,CAAC;IAEK,kBAAkB,CAAC,KAAK;;YAC5B,MAAM,MAAM,GAAG;gBACb,KAAK;aACN,CAAC;YACF,OAAO,IAAI,CAAC,IAAI;iBACb,IAAI,CACH,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,mCAAmC,EACzD,MAAM,CACP;iBACA,SAAS,EAAE,CAAC;QACjB,CAAC;KAAA;IAEK,oBAAoB,CACxB,OAAe,EACf,SAAiB;;YAEjB,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI;iBAC9B,IAAI,CAAY,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,eAAe,EAAE;gBACtD,QAAQ,EAAE,OAAO;gBACjB,MAAM,EAAE,SAAS;aAClB,CAAC;iBACD,SAAS,EAAE,CAAC;YACf,OAAO,KAAK,CAAC;QACf,CAAC;KAAA;IAEK,YAAY,CAChB,QAAgB,EAChB,OAAe,EACf,UAAkB;;YAKlB,6BAA6B;YAC7B,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAClE,QAAQ,CACT,CAAC;YAEF,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YACpD,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAC3D,aAAa,CAAC,OAAO,EACrB,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CACvB,CAAC;YAEF,oBAAoB;YACpB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAC;YACjD,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAC9D,SAAS,EACT,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CACjB,CAAC;YAEF,kCAAkC;YAClC,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,IAAI;iBACvC,IAAI,CACH,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,4BAA4B,EAClD;gBACE,OAAO;gBACP,UAAU;gBACV,eAAe,EAAE,aAAa,CAAC,aAAa;gBAC5C,eAAe,EAAE,aAAa,CAAC,aAAa;gBAC5C,qBAAqB,EAAE,aAAa,CAAC,eAAe,CAAC,MAAM,EAAE;gBAC7D,6BAA6B,EAC3B,aAAa,CAAC,yBAAyB;gBACzC,kBAAkB,EAAE,gBAAgB;gBACpC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE;gBACjB,sBAAsB,EAAE,mBAAmB;aAC5C,CACF;iBACA,SAAS,EAAE,CAAC;YAEf,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;YAChC,OAAO,CAAC,GAAG,CACT,sBAAsB,EACtB,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,aAAa,CAAC,OAAO,CAAC,CAC7D,CAAC;YAEF,qCAAqC;YACrC,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;gBAC1C,QAAQ,EAAE,kBAAkB,CAAC,cAAc;gBAC3C,QAAQ,EAAE,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,aAAa,CAAC,OAAO,CAAC;gBACtE,cAAc,EAAE;oBACd,yBAAyB,EAAE,IAAI,CAAC,SAAS,CAAC;wBACxC,EAAE,EAAE,kBAAkB,CAAC,EAAE;wBACzB,0BAA0B,EACxB,kBAAkB,CAAC,0BAA0B;qBAChD,CAAC;iBACH;aACF,CAAC,CAAC;YAEH,OAAO,CAAC,GAAG,CAAC,oBAAoB,EAAE,YAAY,CAAC,CAAC;YAEhD,OAAO;gBACL,kBAAkB;gBAClB,YAAY;aACb,CAAC;QACJ,CAAC;KAAA;IAEK,YAAY,CAChB,SAAkB,KAAK;;YAEvB,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,EAAE;gBAC7B,OAAO,IAAI,CAAC,SAAS,CAAC;aACvB;YACD,IAAI,CAAC,SAAS,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;YACnD,OAAO,IAAI,CAAC,SAAS,CAAC;QACxB,CAAC;KAAA;IAEa,kBAAkB,CAC9B,SAAkC;;YAElC,4BAA4B;YAC5B,IAAI,iBAAyB,CAAC;YAE9B,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAEhE,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAC9B,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,CAAO,QAAQ,EAAE,EAAE;gBACzC,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAC7D,GAAG,EACH,QAAQ,CAAC,gCAAgC,CAC1C,CAAC;gBAEF,IAAI,iBAAiB,EAAE;oBACrB,IACE,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC;wBACjC,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,EACpD;wBACA,MAAM,IAAI,mBAAmB,CAC3B,kEAAkE,CACnE,CAAC;qBACH;iBACF;qBAAM;oBACL,iBAAiB,GAAG,kBAAkB,CAAC,iBAAiB,CAAC;iBAC1D;gBACD,OAAO,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC;YACnD,CAAC,CAAA,CAAC,CACH,CAAC;YAEF,OAAO,CAAC,GAAG,CAAC,sBAAsB,EAAE,MAAM,CAAC,CAAC;YAE5C,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,aAAa,CAC3D,MAAM,EACN,sBAAsB,CAAC,iBAAiB,CACzC,CAAC;YAEF,OAAO,GAAG,CAAC,KAAK,iCACX,iBAAiB,KACpB,CAAC,EAAE,cAAc,IACjB,CAAC;QACL,CAAC;KAAA;IAEK,eAAe,CAAC,WAAmB;;YACvC,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;YAChD,IAAI,SAAS,CAAC,KAAK,KAAK,YAAY,CAAC,QAAQ,EAAE;gBAC7C,MAAM,IAAI,mBAAmB,CAC3B,+CAA+C,CAChD,CAAC;aACH;YAED,iEAAiE;YACjE,uDAAuD;YACvD,iEAAiE;YACjE,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;YAE7D,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CACtD,WAAW,EACX,SAAS,CAAC,kBAAkB,CAC7B,CAAC;YACF,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAErB,gCAAgC;YAChC,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAE5C,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;YAE5E,MAAM,uBAAuB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAC1E,SAAS,CAAC,GAAG,EACb,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CACxB,CAAC;YAEF,mBAAmB;YACnB,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,iBAC1D,QAAQ,EAAE,WAAW,IAClB,SAAS,CAAC,OAAO,CAAC,aAAa,EAClC,CAAC;YAEH,MAAM,cAAc,GAAG,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAC1D,gBAAgB,CAAC,GAAG,CACrB,CAAC;YAEF,iEAAiE;YACjE,6BAA6B;YAC7B,iEAAiE;YACjE,MAAM,SAAS,GAAG,CAChB,MAAM,IAAI,CAAC,MAAM,CACf,IAAI,UAAU,CAAC;gBACb,QAAQ,EAAE,oCAAoC;gBAC9C,SAAS,EAAE;oBACT,KAAK,EAAE,EAAE;iBACV;aACF,CAAC,EACF;gBACE,eAAe,EAAE,KAAK;aACvB,CACF,CACF,CAAC,4BAA4B,CAAC,SAAS,CAAC;YAEzC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAEvB,qBAAqB;YACrB,kEAAkE;YAClE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,CAClD,IAAI,CAAC,mBAAmB,CACzB,CAAC;YACF,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAEvB,MAAM,sBAAsB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CACjE,WAAW,EACX,SAAS,CAAC,6BAA6B,CACxC,CAAC;YACF,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,IAAI,CACvD,sBAAsB,EACtB,SAAS,CACV,CAAC;YAEF,iEAAiE;YACjE,wCAAwC;YACxC,iEAAiE;YACjE,MAAM,eAAe,GAAG,CACtB,MAAM,IAAI,CAAC,MAAM,CACf,IAAI,UAAU,CAAC;gBACb,QAAQ,EAAE,yCAAyC;gBACnD,SAAS,EAAE;oBACT,KAAK,EAAE;wBACL,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC;qBACjD;iBACF;aACF,CAAC,EACF;gBACE,eAAe,EAAE,KAAK;aACvB,CACF,CACF,CAAC,iCAAiC,CAAC,WAAW,CAAC;YAEhD,iEAAiE;YACjE,0DAA0D;YAC1D,iEAAiE;YACjE,kEAAkE;YAClE,iEAAiE;YACjE,8DAA8D;YAC9D,mEAAmE;YACnE,iDAAiD;YAEjD,8DAA8D;YAC9D,MAAM,UAAU,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;gBAC/C,MAAM,QAAQ,GAAG,CAAO,IAAI,EAAE,EAAE;oBAC9B,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,KAAK,QAAQ,EAAE;wBACnC,OAAO;qBACR;oBAED,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;oBAE7B,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;oBAE1B,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;oBAE3D,qCAAqC;oBACrC,MAAM,IAAI,CAAC,MAAM,CACf,IAAI,UAAU,CAAC;wBACb,QAAQ,EAAE,sCAAsC;wBAChD,SAAS,EAAE;4BACT,KAAK,EAAE;gCACL,uBAAuB;gCACvB,WAAW,EAAE,SAAS,CAAC,EAAE;6BAC1B;yBACF;qBACF,CAAC,CACH,CAAC;oBAEF,OAAO,EAAE,CAAC;gBACZ,CAAC,CAAA,CAAC;gBAEF,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YAC/B,CAAC,CAAC,CAAC;YAEH,0FAA0F;YAC1F,6BAA6B;YAC7B,IAAI,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,eAAe,EAAE;gBACrE,OAAO,EAAE,MAAM;aAChB,CAAC,CAAC;YAEH,IAAI,IAAI,CAAC,aAAa,KAAK,uBAAuB,EAAE;gBAClD,MAAM,IAAI,WAAW,CAAC;oBACpB,OAAO,EACL,0HAA0H;iBAC7H,CAAC,CAAC;aACJ;YAED,0BAA0B;YAC1B,+EAA+E;YAC/E,2BAA2B;YAC3B,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,CAAC,CAAC;YAErE,OAAO,UAAU,CAAC;QACpB,CAAC;KAAA;CACF,CAAA;;;YAxUA,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YA/BsC,MAAM;YAAhB,QAAQ;4CAuChC,MAAM,SAAC,SAAS;YAlBZ,iBAAiB;YApBjB,iBAAiB;YACjB,eAAe;YAEZ,IAAI,CAuCgB,aAAa;YA/BpC,eAAe;YACf,UAAU;YACV,SAAS;YAMT,oBAAoB;;AAYhB,0BAA0B;IANtC,iBAAiB,CAAC;QACjB,UAAU,EAAE,QAAQ;KACrB,CAAC;GAIW,0BAA0B,CAqUtC;SArUY,0BAA0B","sourcesContent":["import { Hub } from '@aws-amplify/core';\r\nimport { Inject, Injectable, Injector, NgZone } from '@angular/core';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\r\nimport * as slip from '../cryptography/slip39.service';\r\nimport { JWK } from 'node-jose';\r\nimport { LrBadStateException, LrException } from '../_common/exceptions';\r\nimport {\r\n  CompleteTpPasswordResetRequestMutation,\r\n  CreateTpAssemblyKeyChallengeMutation,\r\n  PreCompleteTpPasswordResetRequestMutation,\r\n} from './tp-password-reset.gql';\r\nimport { PasswordService } from '../auth/password.service';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\r\nimport {\r\n  RequestResetResult,\r\n  TpPasswordResetService,\r\n} from './tp-password-reset.service';\r\nimport { ISignUpResult } from 'amazon-cognito-identity-js';\r\nimport { LifeReadyAuthService } from '../auth/life-ready-auth.service';\r\nimport { KeyFactoryService } from '../cryptography/key-factory.service';\r\nimport { TpClaimState, TpPasswordResetUserNode } from '../api/types';\r\nimport { LrMutation, LrService } from '../api/lr-graphql';\r\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\r\n\r\n@RunOutsideAngular({\r\n  ngZoneName: 'ngZone',\r\n})\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class TpPasswordResetUserService extends LrService {\r\n  private readonly CLIENT_NONCE_LENGTH = 32;\r\n  private resetUser: TpPasswordResetUserNode;\r\n\r\n  constructor(\r\n    private ngZone: NgZone,\r\n    private injector: Injector,\r\n    @Inject(LR_CONFIG) private config: LifeReadyConfig,\r\n    private keyFactory: KeyFactoryService,\r\n    private encryptionService: EncryptionService,\r\n    private keyGraphService: KeyGraphService,\r\n    private slip39Service: slip.Slip39Service,\r\n    private passwordService: PasswordService,\r\n    private http: HttpClient,\r\n    private auth: AuthClass,\r\n    private lrAuth: LifeReadyAuthService\r\n  ) {\r\n    super(injector);\r\n  }\r\n\r\n  async verifyEmailContact(email): Promise<{ claimId: string }> {\r\n    const params = {\r\n      email,\r\n    };\r\n    return this.http\r\n      .post<any>(\r\n        `${this.config.authUrl}tp/password-reset/verify-contact/`,\r\n        params\r\n      )\r\n      .toPromise();\r\n  }\r\n\r\n  async verifyContactRespond(\r\n    claimId: string,\r\n    claimCode: string\r\n  ): Promise<string> {\r\n    const { token } = await this.http\r\n      .post<{ token }>(`${this.config.authUrl}cove/respond/`, {\r\n        claim_id: claimId,\r\n        v_code: claimCode,\r\n      })\r\n      .toPromise();\r\n    return token;\r\n  }\r\n\r\n  async requestReset(\r\n    password: string,\r\n    claimId: string,\r\n    claimToken: string\r\n  ): Promise<{\r\n    requestResetResult: RequestResetResult;\r\n    signUpResult: ISignUpResult;\r\n  }> {\r\n    // Generate the key materials\r\n    const passKeyBundle = await this.passwordService.createPassKeyBundle(\r\n      password\r\n    );\r\n\r\n    const masterKey = await this.keyFactory.createKey();\r\n    const wrappedMasterKey = await this.encryptionService.encrypt(\r\n      passKeyBundle.passKey,\r\n      masterKey.toJSON(true)\r\n    );\r\n\r\n    // Ephemeral PKC key\r\n    const prk = await this.keyFactory.createPkcKey();\r\n    const masterKeyWrappedPrk = await this.encryptionService.encrypt(\r\n      masterKey,\r\n      prk.toJSON(true)\r\n    );\r\n\r\n    // API call to setup reset request\r\n    const requestResetResult = await this.http\r\n      .post<RequestResetResult>(\r\n        `${this.config.authUrl}tp/password-reset/request/`,\r\n        {\r\n          claimId,\r\n          claimToken,\r\n          pass_key_params: passKeyBundle.passKeyParams,\r\n          pass_idp_params: passKeyBundle.passIdpParams,\r\n          pass_idp_verifier_pbk: passKeyBundle.passIdpVerifier.toJSON(), // public key\r\n          wrapped_pass_idp_verifier_prk:\r\n            passKeyBundle.wrappedPassIdpVerifierPrk,\r\n          wrapped_master_key: wrappedMasterKey,\r\n          pbk: prk.toJSON(), // ephemeral public key\r\n          master_key_wrapped_prk: masterKeyWrappedPrk,\r\n        }\r\n      )\r\n      .toPromise();\r\n\r\n    console.log(requestResetResult);\r\n    console.log(\r\n      'Using new password: ',\r\n      this.passwordService.getPassIdpString(passKeyBundle.passIdp)\r\n    );\r\n\r\n    // API call to create user on cognito\r\n    const signUpResult = await this.auth.signUp({\r\n      username: requestResetResult.reset_username,\r\n      password: this.passwordService.getPassIdpString(passKeyBundle.passIdp),\r\n      clientMetadata: {\r\n        tp_password_reset_request: JSON.stringify({\r\n          id: requestResetResult.id,\r\n          associate_reset_user_token:\r\n            requestResetResult.associate_reset_user_token,\r\n        }),\r\n      },\r\n    });\r\n\r\n    console.log('requestRest done: ', signUpResult);\r\n\r\n    return {\r\n      requestResetResult,\r\n      signUpResult,\r\n    };\r\n  }\r\n\r\n  async getResetUser(\r\n    reload: boolean = false\r\n  ): Promise<TpPasswordResetUserNode> {\r\n    if (!reload && this.resetUser) {\r\n      return this.resetUser;\r\n    }\r\n    this.resetUser = await this.lrAuth.loadResetUser();\r\n    return this.resetUser;\r\n  }\r\n\r\n  private async recoverAssemblyKey(\r\n    resetUser: TpPasswordResetUserNode\r\n  ): Promise<JWK.Key> {\r\n    // Recover the assembly key.\r\n    let assemblyKeyParams: object;\r\n\r\n    const prk = await this.keyGraphService.getKey(resetUser.pxk.id);\r\n\r\n    const shares = await Promise.all(\r\n      resetUser.approvals.map(async (approval) => {\r\n        const partialAssemblyKey = await this.encryptionService.decrypt(\r\n          prk,\r\n          approval.receiverCipherPartialAssemblyKey\r\n        );\r\n\r\n        if (assemblyKeyParams) {\r\n          if (\r\n            JSON.stringify(assemblyKeyParams) !==\r\n            JSON.stringify(partialAssemblyKey.assemblyKeyParams)\r\n          ) {\r\n            throw new LrBadStateException(\r\n              'The assembly key parameters are different between the approvals.'\r\n            );\r\n          }\r\n        } else {\r\n          assemblyKeyParams = partialAssemblyKey.assemblyKeyParams;\r\n        }\r\n        return partialAssemblyKey.slip39.share.mnemonics;\r\n      })\r\n    );\r\n\r\n    console.log('recoverAssemblyKey()', shares);\r\n\r\n    const rawAssemblyKey = await this.slip39Service.recoverSecret(\r\n      shares,\r\n      TpPasswordResetService.SLIP39_PASSPHRASE\r\n    );\r\n\r\n    return JWK.asKey({\r\n      ...assemblyKeyParams,\r\n      k: rawAssemblyKey,\r\n    });\r\n  }\r\n\r\n  async completeRequest(newPassword: string): Promise<void> {\r\n    const resetUser = await this.getResetUser(true);\r\n    if (resetUser.state !== TpClaimState.APPROVED) {\r\n      throw new LrBadStateException(\r\n        'Password reset request has not been approved.'\r\n      );\r\n    }\r\n\r\n    // --------------------------------------------------------------\r\n    // Prepare all materials to ensure there are no errors.\r\n    // --------------------------------------------------------------\r\n    const assemblyKey = await this.recoverAssemblyKey(resetUser);\r\n\r\n    const { rootKey } = await this.encryptionService.decrypt(\r\n      assemblyKey,\r\n      resetUser.assemblyCipherData\r\n    );\r\n    console.log(rootKey);\r\n\r\n    // Making sure it's a valid key.\r\n    const rootKeyJwk = await JWK.asKey(rootKey);\r\n\r\n    const masterKey = await this.keyGraphService.getKey(resetUser.masterKey.id);\r\n\r\n    const masterKeyWrappedRootKey = await this.encryptionService.encryptToString(\r\n      masterKey.jwk,\r\n      rootKeyJwk.toJSON(true)\r\n    );\r\n\r\n    // The new password\r\n    const newPassIdpResult = await this.keyFactory.derivePassIdp({\r\n      password: newPassword,\r\n      ...resetUser.passKey.passIdpParams,\r\n    });\r\n\r\n    const newIdpPassword = this.passwordService.getPassIdpString(\r\n      newPassIdpResult.jwk\r\n    );\r\n\r\n    // --------------------------------------------------------------\r\n    // Get assembly key challenge\r\n    // --------------------------------------------------------------\r\n    const challenge = (\r\n      await this.mutate(\r\n        new LrMutation({\r\n          mutation: CreateTpAssemblyKeyChallengeMutation,\r\n          variables: {\r\n            input: {},\r\n          },\r\n        }),\r\n        {\r\n          includeKeyGraph: false,\r\n        }\r\n      )\r\n    ).createTpAssemblyKeyChallenge.challenge;\r\n\r\n    console.log(challenge);\r\n\r\n    // Sign the challenge\r\n    // Generate a client side nonce that's no in the server's control.\r\n    challenge.clientNonce = this.keyFactory.randomString(\r\n      this.CLIENT_NONCE_LENGTH\r\n    );\r\n    console.log(challenge);\r\n\r\n    const assemblyKeyVerifierPrk = await this.encryptionService.decrypt(\r\n      assemblyKey,\r\n      resetUser.wrappedAssemblyKeyVerifierPrk\r\n    );\r\n    const signedChallenge = await this.encryptionService.sign(\r\n      assemblyKeyVerifierPrk,\r\n      challenge\r\n    );\r\n\r\n    // --------------------------------------------------------------\r\n    // Change password for the original user\r\n    // --------------------------------------------------------------\r\n    const tempIdpPassword = (\r\n      await this.mutate(\r\n        new LrMutation({\r\n          mutation: PreCompleteTpPasswordResetRequestMutation,\r\n          variables: {\r\n            input: {\r\n              signedChallenge: JSON.stringify(signedChallenge),\r\n            },\r\n          },\r\n        }),\r\n        {\r\n          includeKeyGraph: false,\r\n        }\r\n      )\r\n    ).preCompleteTpPasswordResetRequest.idpPassword;\r\n\r\n    // --------------------------------------------------------------\r\n    // Login as the original user using new temporary password\r\n    // --------------------------------------------------------------\r\n    // At this point, the original account's password has been changed\r\n    // to a temporary password. It is no longer possible for the user\r\n    // to use the original password to login. Any successful login\r\n    // can only be using the temporary password. So it's safe to assume\r\n    // that we want to \"complete\" the password reset.\r\n\r\n    // The maybe 2FA so we listen for the auth event from Amplify.\r\n    const retPromise = new Promise<void>((resolve) => {\r\n      const listener = async (data) => {\r\n        if (data.payload.event !== 'signIn') {\r\n          return;\r\n        }\r\n\r\n        Hub.remove('auth', listener);\r\n\r\n        console.log(data.payload);\r\n\r\n        await this.auth.signIn(resetUser.username, newIdpPassword);\r\n\r\n        // Switch over to the new set of keys\r\n        await this.mutate(\r\n          new LrMutation({\r\n            mutation: CompleteTpPasswordResetRequestMutation,\r\n            variables: {\r\n              input: {\r\n                masterKeyWrappedRootKey,\r\n                masterKeyId: masterKey.id,\r\n              },\r\n            },\r\n          })\r\n        );\r\n\r\n        resolve();\r\n      };\r\n\r\n      Hub.listen('auth', listener);\r\n    });\r\n\r\n    // Signin as the original user. Password has been reset to temporary one. It should return\r\n    // with NEW_PASSWORD_REQUIRED\r\n    let user = await this.auth.signIn(resetUser.username, tempIdpPassword, {\r\n      noProxy: 'true',\r\n    });\r\n\r\n    if (user.challengeName !== 'NEW_PASSWORD_REQUIRED') {\r\n      throw new LrException({\r\n        message:\r\n          'Internal error. Expecting Cognito to have done a password reset after call to PreCompleteTpPasswordResetRequestMutation.',\r\n      });\r\n    }\r\n\r\n    // Set new password on Idp\r\n    // the awsFetch() function passes NEW_PASSWORD_REQUIRED directly to AWS without\r\n    // going through the proxy.\r\n    user = await this.auth.completeNewPassword(user, newIdpPassword, {});\r\n\r\n    return retPromise;\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,232 @@
+import { gqlTyped } from '../_common/ast';
+const SharedTpPasswordResetFragment = gqlTyped `
+fragment SharedTpPasswordResetFragment on SharedTpPasswordResetNode {
+  id
+  tp {
+    id
+    other {
+      username
+    }
+  }
+  assembly {
+    asApprovers {
+      edges {
+        node {
+          id
+          sharedKey {
+            id
+          }
+          sharedCipherData
+        }
+      }
+    }
+  }
+  sharedRequest {
+    id
+    pxk {
+      id
+      pbk
+    }
+    claim {
+      id
+      state
+      asClaimApprovers {
+        edges {
+          node {
+            id
+            state
+            sharedKey {
+              id
+            }
+            sharedCipherApprovalData
+            sharedCipherPartialAssemblyKey
+            receiverApprovals {
+              edges {
+                node {
+                  id
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+export const SharedTpPasswordResetsQuery = gqlTyped `
+query SharedTpPasswordResetsQuery {
+  sharedTpPasswordResets {
+    edges {
+      node {
+        ...SharedTpPasswordResetFragment
+      }
+    }
+  }
+}
+${SharedTpPasswordResetFragment}
+`;
+export const SharedTpPasswordResetQuery = gqlTyped `
+query SharedTpPasswordResetQuery($id: LrRelayIdInput!) {
+  sharedTpPasswordReset(id: $id) {
+    ...SharedTpPasswordResetFragment
+  }
+}
+${SharedTpPasswordResetFragment}
+`;
+export const CancelTpPasswordResetRequestMutation = gqlTyped `
+mutation CancelTpPasswordResetRequestMutation {
+  cancelTpPasswordResetRequest(input: {}) {
+    id
+  }
+}`;
+export const CreateTpAssemblyKeyChallengeMutation = gqlTyped `
+mutation CreateTpAssemblyKeyChallengeMutation(
+  $input: CreateTpAssemblyKeyChallengeInput!
+) {
+  createTpAssemblyKeyChallenge(input: $input) {
+    challenge
+  }
+}`;
+export const PreCompleteTpPasswordResetRequestMutation = gqlTyped `
+mutation PreCompleteTpPasswordResetRequestMutation(
+  $input: PreCompleteTpPasswordResetRequestInput!
+) {
+  preCompleteTpPasswordResetRequest(input: $input) {
+    idpPassword
+  }
+}`;
+export const CompleteTpPasswordResetRequestMutation = gqlTyped `
+mutation CompleteTpPasswordResetRequestMutation(
+  $input: CompleteTpPasswordResetRequestInput!
+) {
+  completeTpPasswordResetRequest(input: $input) {
+    id
+  }
+}`;
+export const ApproveTpPasswordResetRequestMutation = gqlTyped `
+mutation ApproveTpPasswordResetRequestMutation(
+  $input: ApproveTpPasswordResetRequestInput!
+) {
+  approveTpPasswordResetRequest(input: $input) {
+    claimApprover {
+      id
+    }
+  }
+}`;
+export const RejectTpPasswordResetRequestMutation = gqlTyped `
+mutation RejectTpPasswordResetRequestMutation(
+  $input: RejectTpPasswordResetRequestInput!
+) {
+  rejectTpPasswordResetRequest(input: $input) {
+    claimApprover {
+      id
+    }
+  }
+}`;
+export const TpPasswordResetUserQuery = gqlTyped `
+query TpPasswordResetUserQuery {
+  tpPasswordResetUser {
+    username
+    resetUsername
+    state
+    passKey {
+      id
+      passKeyParams
+      passIdpParams
+    }
+    masterKey {
+      id
+    }
+    pxk {
+      id
+    }
+    sessionEncryptionKey
+    assembly {
+      singleReject
+      quorum
+      subAssemblies {
+        singleReject
+        quorum
+        approvers {
+          name
+          email
+          state
+        }
+      }
+    }
+    approvals {
+      id
+      modified
+      approverEmail
+      receiverCipher
+      receiverCipherPartialAssemblyKey
+    }
+    assemblyCipherData
+    wrappedAssemblyKeyVerifierPrk
+  }
+}`;
+export const TpPasswordResetQuery = gqlTyped `
+query TpPasswordResetQuery {
+  tpPasswordReset {
+    id
+    applied
+    assembly {
+      singleReject
+      quorum
+      subjectKey {
+        id
+      }
+      assemblyKey {
+        id
+      }
+      assemblyCipherData
+      subAssemblies {
+        edges {
+          node {
+            id
+            singleReject
+            quorum
+            subjectCipherData
+            approvers {
+              edges {
+                node {
+                  id
+                  tp {
+                    id
+                  }
+                  sharedKey {
+                    id
+                  }
+                  sharedCipherData
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+export const CreateTpPasswordResetMutation = gqlTyped `
+mutation CreateTpPasswordResetMutation($input: CreateTpPasswordResetInput!) {
+  createTpPasswordReset(input: $input) {
+    tpPasswordReset {
+      id
+    }
+  }
+}`;
+export const DeleteTpPasswordResetMutation = gqlTyped `
+mutation DeleteTpPasswordResetMutation {
+  deleteTpPasswordReset(input: {}) {
+    id
+  }
+}`;
+export const UpdateTpPasswordResetMutation = gqlTyped `
+mutation UpdateTpPasswordResetMutation($input: UpdateTpPasswordResetInput!) {
+  updateTpPasswordReset(input: $input) {
+    tpPasswordReset {
+      id
+    }
+  }
+}`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tp-password-reset.gql.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/trusted-parties/tp-password-reset.gql.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AA+D1C,MAAM,6BAA6B,GAAG,QAAQ,CAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDjF,CAAC;AASH,MAAM,CAAC,MAAM,2BAA2B,GAAG,QAAQ,CAAmC;;;;;;;;;;EAUpF,6BAA6B;CAC9B,CAAC;AAKF,MAAM,CAAC,MAAM,0BAA0B,GAAG,QAAQ,CAAkC;;;;;;EAMlF,6BAA6B;CAC9B,CAAC;AAOF,MAAM,CAAC,MAAM,oCAAoC,GAAG,QAAQ,CAA4C;;;;;EAKtG,CAAC;AAOH,MAAM,CAAC,MAAM,oCAAoC,GAAG,QAAQ,CAA4C;;;;;;;EAOtG,CAAC;AAOH,MAAM,CAAC,MAAM,yCAAyC,GAAG,QAAQ,CAAiD;;;;;;;EAOhH,CAAC;AAOH,MAAM,CAAC,MAAM,sCAAsC,GAAG,QAAQ,CAA8C;;;;;;;EAO1G,CAAC;AASH,MAAM,CAAC,MAAM,qCAAqC,GAAG,QAAQ,CAA6C;;;;;;;;;EASxG,CAAC;AASH,MAAM,CAAC,MAAM,oCAAoC,GAAG,QAAQ,CAA4C;;;;;;;;;EAStG,CAAC;AA2CH,MAAM,CAAC,MAAM,wBAAwB,GAAG,QAAQ,CAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyC9E,CAAC;AA4CH,MAAM,CAAC,MAAM,oBAAoB,GAAG,QAAQ,CAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCtE,CAAC;AASH,MAAM,CAAC,MAAM,6BAA6B,GAAG,QAAQ,CAAqC;;;;;;;EAOxF,CAAC;AAOH,MAAM,CAAC,MAAM,6BAA6B,GAAG,QAAQ,CAAqC;;;;;EAKxF,CAAC;AASH,MAAM,CAAC,MAAM,6BAA6B,GAAG,QAAQ,CAAqC;;;;;;;EAOxF,CAAC","sourcesContent":["import { GenericScalar, ID } from '../api/types';\r\nimport { gqlTyped } from '../_common/ast';\r\nimport {\r\n  TpClaimState,\r\n  TpClaimApproverState,\r\n} from '../api/types/lr-graphql.types';\r\nimport { DateTime } from '../api/types/graphql.types';\r\n\r\nexport interface SharedTpPasswordResetFragmentResult {\r\n  id: ID;\r\n  tp: {\r\n    id: ID;\r\n    other: {\r\n      username: string;\r\n    };\r\n  };\r\n  assembly: {\r\n    asApprovers: {\r\n      edges: {\r\n        node: {\r\n          id: ID;\r\n          sharedKey: {\r\n            id: ID;\r\n          };\r\n          sharedCipherData: string;\r\n          sharedCipherDataClearJson: any;\r\n        };\r\n      }[];\r\n    };\r\n  };\r\n  sharedRequest: {\r\n    id: ID;\r\n    pxk: {\r\n      id: ID;\r\n      pbk: string;\r\n    };\r\n    claim: {\r\n      id: ID;\r\n      state: TpClaimState;\r\n      asClaimApprovers: {\r\n        edges: {\r\n          node: {\r\n            id: ID;\r\n            state: TpClaimApproverState;\r\n            sharedKey: {\r\n              id: ID;\r\n            };\r\n            sharedCipherApprovalData: string;\r\n            sharedCipherApprovalDataClearJson: any;\r\n            sharedCipherPartialAssemblyKey: string;\r\n            sharedCipherPartialAssemblyKeyClearJson: any;\r\n            receiverApprovals: {\r\n              edges: {\r\n                node: {\r\n                  id: ID;\r\n                };\r\n              }[];\r\n            };\r\n          };\r\n        }[];\r\n      };\r\n    };\r\n  };\r\n}\r\nconst SharedTpPasswordResetFragment = gqlTyped<SharedTpPasswordResetFragmentResult>`\r\nfragment SharedTpPasswordResetFragment on SharedTpPasswordResetNode {\r\n  id\r\n  tp {\r\n    id\r\n    other {\r\n      username\r\n    }\r\n  }\r\n  assembly {\r\n    asApprovers {\r\n      edges {\r\n        node {\r\n          id\r\n          sharedKey {\r\n            id\r\n          }\r\n          sharedCipherData\r\n        }\r\n      }\r\n    }\r\n  }\r\n  sharedRequest {\r\n    id\r\n    pxk {\r\n      id\r\n      pbk\r\n    }\r\n    claim {\r\n      id\r\n      state\r\n      asClaimApprovers {\r\n        edges {\r\n          node {\r\n            id\r\n            state\r\n            sharedKey {\r\n              id\r\n            }\r\n            sharedCipherApprovalData\r\n            sharedCipherPartialAssemblyKey\r\n            receiverApprovals {\r\n              edges {\r\n                node {\r\n                  id\r\n                }\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n}`;\r\n\r\nexport interface SharedTpPasswordResetsQueryResult {\r\n  sharedTpPasswordResets: {\r\n    edges: {\r\n      node: SharedTpPasswordResetFragmentResult;\r\n    }[];\r\n  };\r\n}\r\nexport const SharedTpPasswordResetsQuery = gqlTyped<SharedTpPasswordResetsQueryResult>`\r\nquery SharedTpPasswordResetsQuery {\r\n  sharedTpPasswordResets {\r\n    edges {\r\n      node {\r\n        ...SharedTpPasswordResetFragment\r\n      }\r\n    }\r\n  }\r\n}\r\n${SharedTpPasswordResetFragment}\r\n`;\r\n\r\nexport interface SharedTpPasswordResetQueryResult {\r\n  sharedTpPasswordReset: SharedTpPasswordResetFragmentResult;\r\n}\r\nexport const SharedTpPasswordResetQuery = gqlTyped<SharedTpPasswordResetQueryResult>`\r\nquery SharedTpPasswordResetQuery($id: LrRelayIdInput!) {\r\n  sharedTpPasswordReset(id: $id) {\r\n    ...SharedTpPasswordResetFragment\r\n  }\r\n}\r\n${SharedTpPasswordResetFragment}\r\n`;\r\n\r\nexport interface CancelTpPasswordResetRequestMutationResult {\r\n  cancelTpPasswordResetRequest: {\r\n    id: ID;\r\n  };\r\n}\r\nexport const CancelTpPasswordResetRequestMutation = gqlTyped<CancelTpPasswordResetRequestMutationResult>`\r\nmutation CancelTpPasswordResetRequestMutation {\r\n  cancelTpPasswordResetRequest(input: {}) {\r\n    id\r\n  }\r\n}`;\r\n\r\nexport interface CreateTpAssemblyKeyChallengeMutationResult {\r\n  createTpAssemblyKeyChallenge: {\r\n    challenge: any;\r\n  };\r\n}\r\nexport const CreateTpAssemblyKeyChallengeMutation = gqlTyped<CreateTpAssemblyKeyChallengeMutationResult>`\r\nmutation CreateTpAssemblyKeyChallengeMutation(\r\n  $input: CreateTpAssemblyKeyChallengeInput!\r\n) {\r\n  createTpAssemblyKeyChallenge(input: $input) {\r\n    challenge\r\n  }\r\n}`;\r\n\r\nexport interface PreCompleteTpPasswordResetRequestMutationResult {\r\n  preCompleteTpPasswordResetRequest: {\r\n    idpPassword: string;\r\n  };\r\n}\r\nexport const PreCompleteTpPasswordResetRequestMutation = gqlTyped<PreCompleteTpPasswordResetRequestMutationResult>`\r\nmutation PreCompleteTpPasswordResetRequestMutation(\r\n  $input: PreCompleteTpPasswordResetRequestInput!\r\n) {\r\n  preCompleteTpPasswordResetRequest(input: $input) {\r\n    idpPassword\r\n  }\r\n}`;\r\n\r\nexport interface CompleteTpPasswordResetRequestMutationResult {\r\n  completeTpPasswordResetRequest: {\r\n    id: ID;\r\n  };\r\n}\r\nexport const CompleteTpPasswordResetRequestMutation = gqlTyped<CompleteTpPasswordResetRequestMutationResult>`\r\nmutation CompleteTpPasswordResetRequestMutation(\r\n  $input: CompleteTpPasswordResetRequestInput!\r\n) {\r\n  completeTpPasswordResetRequest(input: $input) {\r\n    id\r\n  }\r\n}`;\r\n\r\nexport interface ApproveTpPasswordResetRequestMutationResult {\r\n  approveTpPasswordResetRequest: {\r\n    claimApprover: {\r\n      id: ID;\r\n    };\r\n  };\r\n}\r\nexport const ApproveTpPasswordResetRequestMutation = gqlTyped<ApproveTpPasswordResetRequestMutationResult>`\r\nmutation ApproveTpPasswordResetRequestMutation(\r\n  $input: ApproveTpPasswordResetRequestInput!\r\n) {\r\n  approveTpPasswordResetRequest(input: $input) {\r\n    claimApprover {\r\n      id\r\n    }\r\n  }\r\n}`;\r\n\r\nexport interface RejectTpPasswordResetRequestMutationResult {\r\n  rejectTpPasswordResetRequest: {\r\n    claimApprover: {\r\n      id: ID;\r\n    };\r\n  };\r\n}\r\nexport const RejectTpPasswordResetRequestMutation = gqlTyped<RejectTpPasswordResetRequestMutationResult>`\r\nmutation RejectTpPasswordResetRequestMutation(\r\n  $input: RejectTpPasswordResetRequestInput!\r\n) {\r\n  rejectTpPasswordResetRequest(input: $input) {\r\n    claimApprover {\r\n      id\r\n    }\r\n  }\r\n}`;\r\n\r\nexport interface TpPasswordResetUserQueryResult {\r\n  tpPasswordResetUser: {\r\n    username: string;\r\n    resetUsername: string;\r\n    state: TpClaimState;\r\n    passKey: {\r\n      id: ID;\r\n      passKeyParams: GenericScalar;\r\n      passIdpParams: GenericScalar;\r\n    };\r\n    masterKey: {\r\n      id: ID;\r\n    };\r\n    pxk: {\r\n      id: ID;\r\n    };\r\n    sessionEncryptionKey: string;\r\n    assembly: {\r\n      singleReject: boolean;\r\n      quorum: number;\r\n      subAssemblies: {\r\n        singleReject: boolean;\r\n        quorum: number;\r\n        approvers: {\r\n          name: string;\r\n          email: string;\r\n          state: TpClaimApproverState;\r\n        }[];\r\n      }[];\r\n    };\r\n    approvals: {\r\n      id: ID;\r\n      modified: DateTime;\r\n      approverEmail: string;\r\n      receiverCipher: string;\r\n      receiverCipherPartialAssemblyKey: string;\r\n    }[];\r\n    assemblyCipherData: string;\r\n    wrappedAssemblyKeyVerifierPrk: string;\r\n  };\r\n}\r\nexport const TpPasswordResetUserQuery = gqlTyped<TpPasswordResetUserQueryResult>`\r\nquery TpPasswordResetUserQuery {\r\n  tpPasswordResetUser {\r\n    username\r\n    resetUsername\r\n    state\r\n    passKey {\r\n      id\r\n      passKeyParams\r\n      passIdpParams\r\n    }\r\n    masterKey {\r\n      id\r\n    }\r\n    pxk {\r\n      id\r\n    }\r\n    sessionEncryptionKey\r\n    assembly {\r\n      singleReject\r\n      quorum\r\n      subAssemblies {\r\n        singleReject\r\n        quorum\r\n        approvers {\r\n          name\r\n          email\r\n          state\r\n        }\r\n      }\r\n    }\r\n    approvals {\r\n      id\r\n      modified\r\n      approverEmail\r\n      receiverCipher\r\n      receiverCipherPartialAssemblyKey\r\n    }\r\n    assemblyCipherData\r\n    wrappedAssemblyKeyVerifierPrk\r\n  }\r\n}`;\r\n\r\nexport interface TpPasswordResetQueryResult {\r\n  tpPasswordReset: {\r\n    id: ID;\r\n    applied: boolean;\r\n    assembly: {\r\n      singleReject: boolean;\r\n      quorum: number;\r\n      subjectKey: {\r\n        id: ID;\r\n      };\r\n      assemblyKey: {\r\n        id: ID;\r\n      };\r\n      assemblyCipherData: string;\r\n      subAssemblies: {\r\n        edges: {\r\n          node: {\r\n            id: ID;\r\n            singleReject: boolean;\r\n            quorum: number;\r\n            subjectCipherData: string;\r\n            subjectCipherDataClearJson: any;\r\n            approvers: {\r\n              edges: {\r\n                node: {\r\n                  id: ID;\r\n                  tp: {\r\n                    id: ID;\r\n                  };\r\n                  sharedKey: {\r\n                    id: ID;\r\n                  };\r\n                  sharedCipherData: string;\r\n                };\r\n              }[];\r\n            };\r\n          };\r\n        }[];\r\n      };\r\n    };\r\n  };\r\n}\r\nexport const TpPasswordResetQuery = gqlTyped<TpPasswordResetQueryResult>`\r\nquery TpPasswordResetQuery {\r\n  tpPasswordReset {\r\n    id\r\n    applied\r\n    assembly {\r\n      singleReject\r\n      quorum\r\n      subjectKey {\r\n        id\r\n      }\r\n      assemblyKey {\r\n        id\r\n      }\r\n      assemblyCipherData\r\n      subAssemblies {\r\n        edges {\r\n          node {\r\n            id\r\n            singleReject\r\n            quorum\r\n            subjectCipherData\r\n            approvers {\r\n              edges {\r\n                node {\r\n                  id\r\n                  tp {\r\n                    id\r\n                  }\r\n                  sharedKey {\r\n                    id\r\n                  }\r\n                  sharedCipherData\r\n                }\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n}`;\r\n\r\nexport interface CreateTpPasswordResetMutationResult {\r\n  createTpPasswordReset: {\r\n    tpPasswordReset: {\r\n      id: ID;\r\n    };\r\n  };\r\n}\r\nexport const CreateTpPasswordResetMutation = gqlTyped<CreateTpPasswordResetMutationResult>`\r\nmutation CreateTpPasswordResetMutation($input: CreateTpPasswordResetInput!) {\r\n  createTpPasswordReset(input: $input) {\r\n    tpPasswordReset {\r\n      id\r\n    }\r\n  }\r\n}`;\r\n\r\nexport interface DeleteTpPasswordResetMutationResult {\r\n  deleteTpPasswordReset: {\r\n    id: ID;\r\n  };\r\n}\r\nexport const DeleteTpPasswordResetMutation = gqlTyped<DeleteTpPasswordResetMutationResult>`\r\nmutation DeleteTpPasswordResetMutation {\r\n  deleteTpPasswordReset(input: {}) {\r\n    id\r\n  }\r\n}`;\r\n\r\nexport interface UpdateTpPasswordResetMutationResult {\r\n  updateTpPasswordReset: {\r\n    tpPasswordReset: {\r\n      id: ID;\r\n    };\r\n  };\r\n}\r\nexport const UpdateTpPasswordResetMutation = gqlTyped<UpdateTpPasswordResetMutationResult>`\r\nmutation UpdateTpPasswordResetMutation($input: UpdateTpPasswordResetInput!) {\r\n  updateTpPasswordReset(input: $input) {\r\n    tpPasswordReset {\r\n      id\r\n    }\r\n  }\r\n}`;\r\n"]}