@lifeready/core 1.0.1 → 1.0.3

package/esm2015/lib/auth/life-ready-auth.service.js

@@ -0,0 +1,500 @@
+import { __awaiter } from "tslib";
+import { Inject, Injectable, isDevMode } from '@angular/core';
+import { Hub } from '@aws-amplify/core';
+import { ReplaySubject } from 'rxjs';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyService } from '../cryptography/key.service';
+import { ProfileService } from '../users/profile.service';
+import { PasswordChangeStatus } from '../users/profile.types';
+import { LrConcurrentAccessException, LrBadRequestException, LrBadStateException, LrException, } from '../_common/exceptions';
+import { RecoveryStatus, } from './auth.types';
+import { PasswordService } from './password.service';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { CompleteTpPasswordResetRequestMutation, CreateTpAssemblyKeyChallengeMutation, PreCompleteTpPasswordResetRequestMutation, TpPasswordResetUserQuery, } from '../trusted-parties/tp-password-reset.gql';
+import { IdleService } from './idle.service';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { LrGraphQLService, LrMutation } from '../api/lr-graphql';
+import { TpClaimState } from '../api/types';
+import { TpPasswordResetProcessorService } from '../api/query-processor/tp-password-reset-processor.service';
+import { SetSessionEncryptionKeyMutation } from './auth.gql';
+import { PersistService } from '../api/persist.service';
+import { JWK } from 'node-jose';
+import { LR_CONFIG } from '../life-ready.config';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { Slip39Service } from '../cryptography/slip39.service';
+import { TP_PASSWORD_RESET_CLIENT_NONCE_LENGTH, TP_PASSWORD_RESET_SLIP39_PASSPHRASE, TP_PASSWORD_RESET_USERNAME_SUFFIX, } from '../trusted-parties/tp-password-reset.constants';
+import * as i0 from "@angular/core";
+import * as i1 from "../life-ready.config";
+import * as i2 from "@aws-amplify/auth/lib-esm/Auth";
+import * as i3 from "../cryptography/key-factory.service";
+import * as i4 from "../cryptography/key.service";
+import * as i5 from "../users/profile.service";
+import * as i6 from "../cryptography/key-graph.service";
+import * as i7 from "./password.service";
+import * as i8 from "./idle.service";
+import * as i9 from "../api/lr-graphql/lr-graphql.service";
+import * as i10 from "../api/query-processor/tp-password-reset-processor.service";
+import * as i11 from "../api/persist.service";
+import * as i12 from "../cryptography/encryption.service";
+import * as i13 from "../cryptography/slip39.service";
+export const initialiseAuth = (authService) => {
+    return () => authService.initialise();
+};
+export class LifeReadyAuthService {
+    constructor(config, auth, keyFactory, keyService, profileService, keyGraphService, passwordService, idleService, lrGraphQL, tpPasswordResetProcessorService, persistService, encryptionService, slip39Service) {
+        this.config = config;
+        this.auth = auth;
+        this.keyFactory = keyFactory;
+        this.keyService = keyService;
+        this.profileService = profileService;
+        this.keyGraphService = keyGraphService;
+        this.passwordService = passwordService;
+        this.idleService = idleService;
+        this.lrGraphQL = lrGraphQL;
+        this.tpPasswordResetProcessorService = tpPasswordResetProcessorService;
+        this.persistService = persistService;
+        this.encryptionService = encryptionService;
+        this.slip39Service = slip39Service;
+        this.hubSubject = new ReplaySubject(1);
+    }
+    initialise() {
+        return __awaiter(this, void 0, void 0, function* () {
+            Hub.listen('auth', (data) => this.hubSubject.next(data.payload));
+        });
+    }
+    loginIdpImpl(emailOrPhone, password, passIdpParams, recoveryStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const passIdpResult = yield this.keyFactory.derivePassIdp(Object.assign({ password }, passIdpParams));
+            // Use the derived password to signin with cognito
+            const user = yield this.auth.signIn(emailOrPhone, this.passwordService.getPassIdpString(passIdpResult.jwk));
+            user.recoveryStatus = recoveryStatus;
+            return user;
+        });
+    }
+    loginIdp(emailOrPhone, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Download the salt needed to derive the PassIdp
+            const passIdpApiResult = yield this.profileService.getPassIdpParams(emailOrPhone);
+            if (passIdpApiResult.passwordChangeStatus === PasswordChangeStatus.InProgress) {
+                throw new LrConcurrentAccessException('A password change is in progress');
+            }
+            if (passIdpApiResult.passwordChangeStatus === PasswordChangeStatus.Recovery) {
+                console.log('In recovery mode.');
+                // Let's say we don't know if the password is the new one or the old one. We just have to try both.
+                try {
+                    const user = yield this.loginIdpImpl(emailOrPhone, password, passIdpApiResult.newPassIdpParams, RecoveryStatus.NEW_PASSWORD);
+                    // New password worked. Let's set to the current password
+                    // --Potential Failure Point 1--
+                    // if changePasswordComplete() doesn't get called, then it should remain
+                    console.log('New password works!');
+                    return user;
+                }
+                catch (error) {
+                    // Just bubble up any other type of error.
+                    if (error.code !== 'NotAuthorizedException') {
+                        throw error;
+                    }
+                    // pass, try again assuming it's the old password
+                }
+                // Now assume it's the previous password. Any exception is allowed to bubble up.
+                try {
+                    const user = yield this.loginIdpImpl(emailOrPhone, password, passIdpApiResult.currentPassIdpParams, RecoveryStatus.OLD_PASSWORD);
+                    // Old password worked.
+                    console.log('Old password works!');
+                    return user;
+                }
+                catch (error) {
+                    // Just bubble up any other type of error.
+                    throw error.code === 'NotAuthorizedException'
+                        ? new LrBadRequestException('The password change request was interrupted, please try to login with both your new and old password')
+                        : error;
+                }
+            }
+            // Try against as the TP password reset account
+            if (passIdpApiResult.tpPasswordReset) {
+                try {
+                    // TP password reset is in process. We need to try the password against both
+                    // original account and the new reset account.
+                    const reset = passIdpApiResult.tpPasswordReset;
+                    const ret = yield this.loginIdpImpl(reset.resetUsername, password, reset.passIdpParams, RecoveryStatus.NONE);
+                    ret.isTpPasswordResetUser = true;
+                    return ret;
+                }
+                catch (err) {
+                    // continue, try again as regular user.
+                }
+            }
+            // Login as regular user
+            return yield this.loginIdpImpl(emailOrPhone, password, passIdpApiResult.currentPassIdpParams, RecoveryStatus.NONE);
+        });
+    }
+    handleSessionEncryptionKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.config.disableSessionEncryptionKey) {
+                if (!isDevMode()) {
+                    const msg = 'You should not set disableSessionEncryptionKey=True in mode prod. It defaults to false.';
+                    console.error(msg);
+                    throw new Error(msg);
+                }
+                else {
+                    console.warn('You have set disableSessionEncryptionKey=True. Make sure not to do this in prod mode.');
+                }
+            }
+            else {
+                // Set the session key to a new encryption key for this session
+                const sessionEncryptionKey = yield this.keyFactory.createKey();
+                yield this.lrGraphQL.lrMutate(new LrMutation({
+                    mutation: SetSessionEncryptionKeyMutation,
+                    variables: {
+                        input: {
+                            sessionEncryptionKey: JSON.stringify(sessionEncryptionKey.toJSON(true)),
+                        },
+                    },
+                }), {
+                    includeKeyGraph: false,
+                });
+                this.persistService.setServerSessionEncryptionKey(sessionEncryptionKey);
+            }
+        });
+    }
+    handlePostAuth(cognitoUser) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.handlePasswordRecovery(cognitoUser);
+            yield this.handleSessionEncryptionKey();
+        });
+    }
+    login(emailOrPhone, password, { tpPasswordResetAutoComplete = true } = {}) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            let loginResult = yield this.loginImpl(emailOrPhone, password);
+            if (tpPasswordResetAutoComplete &&
+                ((_a = loginResult.resetUser) === null || _a === void 0 ? void 0 : _a.state) === TpClaimState.APPROVED) {
+                yield this.completeRequest(password);
+                loginResult = yield this.loginImpl(emailOrPhone, password);
+            }
+            return loginResult;
+        });
+    }
+    loginImpl(emailOrPhone, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.logout();
+            const cognitoUser = yield this.loginIdp(emailOrPhone, password);
+            // todo: Meet MFA challenges.
+            if (['SMS_MFA', 'SOFTWARE_TOKEN_MFA'].includes(cognitoUser.challengeName)) {
+                return { hasChallenge: true, challenge: cognitoUser };
+            }
+            yield this.handlePostAuth(cognitoUser);
+            if (cognitoUser.isTpPasswordResetUser) {
+                // Assuming there is no MFA on the TP reset user.
+                const resetUser = yield this.loadResetUser(password);
+                return { hasChallenge: false, resetUser };
+            }
+            else {
+                const user = yield this.loadUser(cognitoUser, password);
+                yield this.idleService.start(); // Run idleService whenever user is logged in.
+                return { hasChallenge: false, user };
+            }
+        });
+    }
+    // TODO <AZ> We need to handle the isTpPasswordResetUser=True case here after MFA as well.
+    verifyLogin(challenge, password, rememberMe, code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.auth.confirmSignIn(challenge, code, challenge.challengeName);
+            // TODO: this.auth.confirmSignIn() could return another challenge.
+            const cognitoUser = yield this.auth.currentAuthenticatedUser();
+            yield this.handlePostAuth(challenge);
+            const user = yield this.loadUser(cognitoUser, password);
+            if (rememberMe) {
+                cognitoUser.setDeviceStatusRemembered({
+                    onSuccess: () => { },
+                    onFailure: (e) => console.error(e),
+                });
+            }
+            return user;
+        });
+    }
+    handlePasswordRecovery(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (user.recoveryStatus !== RecoveryStatus.NONE) {
+                const jwtToken = user
+                    .getSignInUserSession()
+                    .getAccessToken()
+                    .getJwtToken();
+                yield this.passwordService.changePasswordComplete(jwtToken, user.recoveryStatus === RecoveryStatus.NEW_PASSWORD);
+            }
+        });
+    }
+    getUserOrResetUser(reload = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cognitoUser = yield this.auth.currentAuthenticatedUser();
+            if (cognitoUser.getUsername().endsWith(TP_PASSWORD_RESET_USERNAME_SUFFIX)) {
+                return this.getResetUser(reload);
+            }
+            else {
+                return this.getUser(reload);
+            }
+        });
+    }
+    getResetUser(reload = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!reload && this.currentResetUser) {
+                return this.currentResetUser;
+            }
+            this.currentResetUser = yield this.loadResetUser();
+            yield this.idleService.start(); // Run idleService whenever user is logged in.
+            return this.currentResetUser;
+        });
+    }
+    getUser(reload = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!reload && this.currentUser) {
+                return this.currentUser;
+            }
+            this.currentUser = yield this.loadUser(yield this.auth.currentAuthenticatedUser());
+            console.log('Starting idle service.');
+            yield this.idleService.start(); // Run idleService whenever user is logged in.
+            return this.currentUser;
+        });
+    }
+    mapTPVaultAccess(features) {
+        const tpVaultFeature = features === null || features === void 0 ? void 0 : features.tpVault;
+        return ((tpVaultFeature === null || tpVaultFeature === void 0 ? void 0 : tpVaultFeature.length) > 0 &&
+            tpVaultFeature.some((feature) => feature.toUpperCase() === 'ACCESS'));
+    }
+    loadUser(cognitoUser, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { currentUser, contactCard, userPlans, } = yield this.profileService.getCurrentUser();
+            if (currentUser.sessionEncryptionKey) {
+                this.persistService.setServerSessionEncryptionKey(yield JWK.asKey(currentUser.sessionEncryptionKey));
+            }
+            const userAttributes = yield this.auth.userAttributes(cognitoUser);
+            if (password) {
+                const passKey = (yield this.keyFactory.derivePassKey(Object.assign({ password }, currentUser.currentUserKey.passKey.passKeyParams))).jwk;
+                yield this.idleService.persistMasterKey(yield this.keyGraphService.unwrapWithPassKey(currentUser.currentUserKey.passKey.id, passKey, currentUser.currentUserKey.masterKey.id));
+            }
+            yield this.keyGraphService.populateKeys(currentUser.currentUserKey);
+            return {
+                id: currentUser.id,
+                sub: this.getUserAttribute('sub', userAttributes),
+                username: currentUser.username,
+                currentUserKey: currentUser.currentUserKey,
+                getAccessJwtToken: () => cognitoUser.getSignInUserSession().getAccessToken().getJwtToken(),
+                email: this.getUserAttribute('email', userAttributes),
+                emailVerified: this.getUserAttribute('email_verified', userAttributes) === 'true',
+                phone: this.getUserAttribute('phone_number', userAttributes),
+                phoneVerified: this.getUserAttribute('phone_number_verified', userAttributes) ===
+                    'true',
+                contactCard: Object.assign({}, (yield this.profileService.decryptContactCard(contactCard))),
+                userDelete: currentUser.userDelete,
+                userPlans,
+                hasTPVaultAccess: this.mapTPVaultAccess(currentUser.features),
+                features: currentUser.features,
+                sessionEncryptionKey: currentUser.sessionEncryptionKey,
+            };
+        });
+    }
+    watchAuth() {
+        return this.hubSubject;
+    }
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.currentUser = null;
+            this.keyService.purgeKeys();
+            this.keyGraphService.purgeKeys();
+            yield Promise.all([this.auth.signOut(), this.profileService.signOut()]);
+        });
+    }
+    getUserAttribute(attributeName, userAttributes) {
+        const userAttribute = userAttributes.find((x) => x.getName() === attributeName);
+        return userAttribute ? userAttribute.getValue() : null;
+    }
+    loadResetUser(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tpPasswordResetUser: resetUser } = yield this.lrGraphQL.query({
+                query: TpPasswordResetUserQuery,
+            });
+            if (resetUser.sessionEncryptionKey) {
+                this.persistService.setServerSessionEncryptionKey(yield JWK.asKey(resetUser.sessionEncryptionKey));
+            }
+            // Update the keys
+            if (password) {
+                const passKey = (yield this.keyFactory.derivePassKey(Object.assign({ password }, resetUser.passKey.passKeyParams))).jwk;
+                yield this.idleService.persistMasterKey(yield this.keyGraphService.unwrapWithPassKey(resetUser.passKey.id, passKey, resetUser.masterKey.id));
+            }
+            this.keyService.populateKeys({
+                passKey: {
+                    id: resetUser.passKey.id,
+                },
+                masterKey: {
+                    id: resetUser.masterKey.id,
+                },
+            });
+            const userAttributes = yield this.auth.userAttributes(yield this.auth.currentAuthenticatedUser());
+            const sub = this.getUserAttribute('sub', userAttributes);
+            return Object.assign(Object.assign({}, (yield this.tpPasswordResetProcessorService.processTpPasswordResetUserNode(resetUser))), { sub });
+        });
+    }
+    refreshAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cognitoUser = yield this.auth.currentAuthenticatedUser();
+            const refreshToken = cognitoUser.getSignInUserSession().getRefreshToken();
+            return new Promise((resolve, reject) => {
+                cognitoUser.refreshSession(refreshToken, (err, data) => {
+                    if (err) {
+                        console.error('Error refreshing token: ', err);
+                        reject(err);
+                    }
+                    else {
+                        console.log('Token refresh complete: ', data);
+                        resolve(0);
+                    }
+                });
+            });
+        });
+    }
+    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.lrGraphQL.lrMutate(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(TP_PASSWORD_RESET_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.lrGraphQL.lrMutate(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.lrGraphQL.lrMutate(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;
+        });
+    }
+    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
+                .filter((approval) => !!approval.receiverCipherPartialAssemblyKey)
+                .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, TP_PASSWORD_RESET_SLIP39_PASSPHRASE);
+            return JWK.asKey(Object.assign(Object.assign({}, assemblyKeyParams), { k: rawAssemblyKey }));
+        });
+    }
+}
+LifeReadyAuthService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LifeReadyAuthService_Factory() { return new LifeReadyAuthService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.AuthClass), i0.ɵɵinject(i3.KeyFactoryService), i0.ɵɵinject(i4.KeyService), i0.ɵɵinject(i5.ProfileService), i0.ɵɵinject(i6.KeyGraphService), i0.ɵɵinject(i7.PasswordService), i0.ɵɵinject(i8.IdleService), i0.ɵɵinject(i9.LrGraphQLService), i0.ɵɵinject(i10.TpPasswordResetProcessorService), i0.ɵɵinject(i11.PersistService), i0.ɵɵinject(i12.EncryptionService), i0.ɵɵinject(i13.Slip39Service)); }, token: LifeReadyAuthService, providedIn: "root" });
+LifeReadyAuthService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+LifeReadyAuthService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: AuthClass },
+    { type: KeyFactoryService },
+    { type: KeyService },
+    { type: ProfileService },
+    { type: KeyGraphService },
+    { type: PasswordService },
+    { type: IdleService },
+    { type: LrGraphQLService },
+    { type: TpPasswordResetProcessorService },
+    { type: PersistService },
+    { type: EncryptionService },
+    { type: Slip39Service }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"life-ready-auth.service.js","sourceRoot":"C:/Projects/newrepo/kc-client/projects/core/src/","sources":["lib/auth/life-ready-auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, isDevMode } from '@angular/core';\r\nimport { CognitoUser } from '@aws-amplify/auth';\r\nimport { Hub } from '@aws-amplify/core';\r\nimport { CognitoUserAttribute } from 'amazon-cognito-identity-js';\r\nimport { Observable, ReplaySubject } from 'rxjs';\r\nimport { PassIdpParams } from '../cryptography/cryptography.types';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { KeyService } from '../cryptography/key.service';\r\nimport { ProfileService } from '../users/profile.service';\r\nimport { PasswordChangeStatus } from '../users/profile.types';\r\nimport {\r\n  LrConcurrentAccessException,\r\n  LrBadRequestException,\r\n  LrBadStateException,\r\n  LrException,\r\n} from '../_common/exceptions';\r\nimport {\r\n  CognitoChallengeUser,\r\n  CurrentUser,\r\n  TpPasswordResetUser,\r\n  LoginResult,\r\n  RecoveryStatus,\r\n} from './auth.types';\r\nimport { PasswordService } from './password.service';\r\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\r\nimport {\r\n  CompleteTpPasswordResetRequestMutation,\r\n  CreateTpAssemblyKeyChallengeMutation,\r\n  PreCompleteTpPasswordResetRequestMutation,\r\n  TpPasswordResetUserQuery,\r\n} from '../trusted-parties/tp-password-reset.gql';\r\nimport { IdleService } from './idle.service';\r\nimport { KeyFactoryService } from '../cryptography/key-factory.service';\r\nimport { LrGraphQLService, LrMutation } from '../api/lr-graphql';\r\nimport { TpClaimState, TpPasswordResetUserNode } from '../api/types';\r\nimport { TpPasswordResetProcessorService } from '../api/query-processor/tp-password-reset-processor.service';\r\nimport { SetSessionEncryptionKeyMutation } from './auth.gql';\r\nimport { PersistService } from '../api/persist.service';\r\nimport { JWK } from 'node-jose';\r\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { Slip39Service } from '../cryptography/slip39.service';\r\nimport {\r\n  TP_PASSWORD_RESET_CLIENT_NONCE_LENGTH,\r\n  TP_PASSWORD_RESET_SLIP39_PASSPHRASE,\r\n  TP_PASSWORD_RESET_USERNAME_SUFFIX,\r\n} from '../trusted-parties/tp-password-reset.constants';\r\n\r\nexport const initialiseAuth = (authService: LifeReadyAuthService) => {\r\n  return () => authService.initialise();\r\n};\r\n\r\nexport interface LoginOptions {\r\n  tpPasswordResetAutoComplete?: boolean;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class LifeReadyAuthService {\r\n  private hubSubject: ReplaySubject<any> = new ReplaySubject<any>(1);\r\n  private currentUser: CurrentUser;\r\n  private currentResetUser: TpPasswordResetUser;\r\n\r\n  constructor(\r\n    @Inject(LR_CONFIG) private config: LifeReadyConfig,\r\n    private auth: AuthClass,\r\n    private keyFactory: KeyFactoryService,\r\n    private keyService: KeyService,\r\n    private profileService: ProfileService,\r\n    private keyGraphService: KeyGraphService,\r\n    private passwordService: PasswordService,\r\n    private idleService: IdleService,\r\n    private lrGraphQL: LrGraphQLService,\r\n    private tpPasswordResetProcessorService: TpPasswordResetProcessorService,\r\n    private persistService: PersistService,\r\n    private encryptionService: EncryptionService,\r\n    private slip39Service: Slip39Service\r\n  ) {}\r\n\r\n  public async initialise() {\r\n    Hub.listen('auth', (data) => this.hubSubject.next(data.payload));\r\n  }\r\n\r\n  private async loginIdpImpl(\r\n    emailOrPhone: string,\r\n    password: string,\r\n    passIdpParams: PassIdpParams,\r\n    recoveryStatus: RecoveryStatus\r\n  ): Promise<CognitoChallengeUser> {\r\n    const passIdpResult = await this.keyFactory.derivePassIdp({\r\n      password,\r\n      ...passIdpParams,\r\n    });\r\n    // Use the derived password to signin with cognito\r\n    const user = await this.auth.signIn(\r\n      emailOrPhone,\r\n      this.passwordService.getPassIdpString(passIdpResult.jwk)\r\n    );\r\n\r\n    user.recoveryStatus = recoveryStatus;\r\n\r\n    return user;\r\n  }\r\n\r\n  private async loginIdp(\r\n    emailOrPhone: string,\r\n    password: string\r\n  ): Promise<CognitoChallengeUser> {\r\n    // Download the salt needed to derive the PassIdp\r\n    const passIdpApiResult = await this.profileService.getPassIdpParams(\r\n      emailOrPhone\r\n    );\r\n\r\n    if (\r\n      passIdpApiResult.passwordChangeStatus === PasswordChangeStatus.InProgress\r\n    ) {\r\n      throw new LrConcurrentAccessException('A password change is in progress');\r\n    }\r\n\r\n    if (\r\n      passIdpApiResult.passwordChangeStatus === PasswordChangeStatus.Recovery\r\n    ) {\r\n      console.log('In recovery mode.');\r\n      // Let's say we don't know if the password is the new one or the old one. We just have to try both.\r\n      try {\r\n        const user = await this.loginIdpImpl(\r\n          emailOrPhone,\r\n          password,\r\n          passIdpApiResult.newPassIdpParams,\r\n          RecoveryStatus.NEW_PASSWORD\r\n        );\r\n        // New password worked. Let's set to the current password\r\n\r\n        // --Potential Failure Point 1--\r\n        // if changePasswordComplete() doesn't get called, then it should remain\r\n\r\n        console.log('New password works!');\r\n\r\n        return user;\r\n      } catch (error) {\r\n        // Just bubble up any other type of error.\r\n        if (error.code !== 'NotAuthorizedException') {\r\n          throw error;\r\n        }\r\n        // pass, try again assuming it's the old password\r\n      }\r\n\r\n      // Now assume it's the previous password. Any exception is allowed to bubble up.\r\n      try {\r\n        const user = await this.loginIdpImpl(\r\n          emailOrPhone,\r\n          password,\r\n          passIdpApiResult.currentPassIdpParams,\r\n          RecoveryStatus.OLD_PASSWORD\r\n        );\r\n        // Old password worked.\r\n        console.log('Old password works!');\r\n\r\n        return user;\r\n      } catch (error) {\r\n        // Just bubble up any other type of error.\r\n        throw error.code === 'NotAuthorizedException'\r\n          ? new LrBadRequestException(\r\n              'The password change request was interrupted, please try to login with both your new and old password'\r\n            )\r\n          : error;\r\n      }\r\n    }\r\n\r\n    // Try against as the TP password reset account\r\n    if (passIdpApiResult.tpPasswordReset) {\r\n      try {\r\n        // TP password reset is in process. We need to try the password against both\r\n        // original account and the new reset account.\r\n        const reset = passIdpApiResult.tpPasswordReset;\r\n        const ret = await this.loginIdpImpl(\r\n          reset.resetUsername,\r\n          password,\r\n          reset.passIdpParams,\r\n          RecoveryStatus.NONE\r\n        );\r\n        ret.isTpPasswordResetUser = true;\r\n\r\n        return ret;\r\n      } catch (err) {\r\n        // continue, try again as regular user.\r\n      }\r\n    }\r\n\r\n    // Login as regular user\r\n    return await this.loginIdpImpl(\r\n      emailOrPhone,\r\n      password,\r\n      passIdpApiResult.currentPassIdpParams,\r\n      RecoveryStatus.NONE\r\n    );\r\n  }\r\n\r\n  protected async handleSessionEncryptionKey() {\r\n    if (this.config.disableSessionEncryptionKey) {\r\n      if (!isDevMode()) {\r\n        const msg =\r\n          'You should not set disableSessionEncryptionKey=True in mode prod. It defaults to false.';\r\n        console.error(msg);\r\n        throw new Error(msg);\r\n      } else {\r\n        console.warn(\r\n          'You have set disableSessionEncryptionKey=True. Make sure not to do this in prod mode.'\r\n        );\r\n      }\r\n    } else {\r\n      // Set the session key to a new encryption key for this session\r\n      const sessionEncryptionKey = await this.keyFactory.createKey();\r\n      await this.lrGraphQL.lrMutate(\r\n        new LrMutation({\r\n          mutation: SetSessionEncryptionKeyMutation,\r\n          variables: {\r\n            input: {\r\n              sessionEncryptionKey: JSON.stringify(\r\n                sessionEncryptionKey.toJSON(true)\r\n              ),\r\n            },\r\n          },\r\n        }),\r\n        {\r\n          includeKeyGraph: false,\r\n        }\r\n      );\r\n\r\n      this.persistService.setServerSessionEncryptionKey(sessionEncryptionKey);\r\n    }\r\n  }\r\n\r\n  protected async handlePostAuth(cognitoUser: CognitoChallengeUser) {\r\n    await this.handlePasswordRecovery(cognitoUser);\r\n    await this.handleSessionEncryptionKey();\r\n  }\r\n\r\n  public async login(\r\n    emailOrPhone: string,\r\n    password: string,\r\n    { tpPasswordResetAutoComplete = true }: LoginOptions = {}\r\n  ) {\r\n    let loginResult = await this.loginImpl(emailOrPhone, password);\r\n\r\n    if (\r\n      tpPasswordResetAutoComplete &&\r\n      loginResult.resetUser?.state === TpClaimState.APPROVED\r\n    ) {\r\n      await this.completeRequest(password);\r\n      loginResult = await this.loginImpl(emailOrPhone, password);\r\n    }\r\n\r\n    return loginResult;\r\n  }\r\n\r\n  public async loginImpl(\r\n    emailOrPhone: string,\r\n    password: string\r\n  ): Promise<LoginResult> {\r\n    await this.logout();\r\n    const cognitoUser = await this.loginIdp(emailOrPhone, password);\r\n\r\n    // todo: Meet MFA challenges.\r\n    if (['SMS_MFA', 'SOFTWARE_TOKEN_MFA'].includes(cognitoUser.challengeName)) {\r\n      return { hasChallenge: true, challenge: cognitoUser };\r\n    }\r\n\r\n    await this.handlePostAuth(cognitoUser);\r\n\r\n    if (cognitoUser.isTpPasswordResetUser) {\r\n      // Assuming there is no MFA on the TP reset user.\r\n      const resetUser = await this.loadResetUser(password);\r\n      return { hasChallenge: false, resetUser };\r\n    } else {\r\n      const user = await this.loadUser(cognitoUser, password);\r\n      await this.idleService.start(); // Run idleService whenever user is logged in.\r\n      return { hasChallenge: false, user };\r\n    }\r\n  }\r\n\r\n  // TODO <AZ> We need to handle the isTpPasswordResetUser=True case here after MFA as well.\r\n  public async verifyLogin(\r\n    challenge: CognitoChallengeUser,\r\n    password: string,\r\n    rememberMe: boolean,\r\n    code: string\r\n  ): Promise<CurrentUser> {\r\n    await this.auth.confirmSignIn(challenge, code, challenge.challengeName);\r\n\r\n    // TODO: this.auth.confirmSignIn() could return another challenge.\r\n\r\n    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();\r\n\r\n    await this.handlePostAuth(challenge);\r\n\r\n    const user = await this.loadUser(cognitoUser, password);\r\n\r\n    if (rememberMe) {\r\n      cognitoUser.setDeviceStatusRemembered({\r\n        onSuccess: () => {},\r\n        onFailure: (e) => console.error(e),\r\n      });\r\n    }\r\n\r\n    return user;\r\n  }\r\n\r\n  async handlePasswordRecovery(user: CognitoChallengeUser) {\r\n    if (user.recoveryStatus !== RecoveryStatus.NONE) {\r\n      const jwtToken = user\r\n        .getSignInUserSession()\r\n        .getAccessToken()\r\n        .getJwtToken();\r\n      await this.passwordService.changePasswordComplete(\r\n        jwtToken,\r\n        user.recoveryStatus === RecoveryStatus.NEW_PASSWORD\r\n      );\r\n    }\r\n  }\r\n\r\n  async getUserOrResetUser(\r\n    reload: boolean = false\r\n  ): Promise<CurrentUser | TpPasswordResetUser> {\r\n    const cognitoUser = await this.auth.currentAuthenticatedUser();\r\n\r\n    if (cognitoUser.getUsername().endsWith(TP_PASSWORD_RESET_USERNAME_SUFFIX)) {\r\n      return this.getResetUser(reload);\r\n    } else {\r\n      return this.getUser(reload);\r\n    }\r\n  }\r\n\r\n  async getResetUser(reload: boolean = false): Promise<TpPasswordResetUser> {\r\n    if (!reload && this.currentResetUser) {\r\n      return this.currentResetUser;\r\n    }\r\n\r\n    this.currentResetUser = await this.loadResetUser();\r\n\r\n    await this.idleService.start(); // Run idleService whenever user is logged in.\r\n\r\n    return this.currentResetUser;\r\n  }\r\n\r\n  async getUser(reload: boolean = false): Promise<CurrentUser> {\r\n    if (!reload && this.currentUser) {\r\n      return this.currentUser;\r\n    }\r\n    this.currentUser = await this.loadUser(\r\n      await this.auth.currentAuthenticatedUser()\r\n    );\r\n    console.log('Starting idle service.');\r\n    await this.idleService.start(); // Run idleService whenever user is logged in.\r\n    return this.currentUser;\r\n  }\r\n\r\n  private mapTPVaultAccess(features?: any): boolean {\r\n    const tpVaultFeature = features?.tpVault;\r\n    return (\r\n      tpVaultFeature?.length > 0 &&\r\n      tpVaultFeature.some((feature) => feature.toUpperCase() === 'ACCESS')\r\n    );\r\n  }\r\n\r\n  private async loadUser(\r\n    cognitoUser: CognitoUser,\r\n    password?: string\r\n  ): Promise<CurrentUser> {\r\n    const {\r\n      currentUser,\r\n      contactCard,\r\n      userPlans,\r\n    } = await this.profileService.getCurrentUser();\r\n\r\n    if (currentUser.sessionEncryptionKey) {\r\n      this.persistService.setServerSessionEncryptionKey(\r\n        await JWK.asKey(currentUser.sessionEncryptionKey)\r\n      );\r\n    }\r\n\r\n    const userAttributes = await this.auth.userAttributes(cognitoUser);\r\n\r\n    if (password) {\r\n      const passKey = (\r\n        await this.keyFactory.derivePassKey({\r\n          password,\r\n          ...currentUser.currentUserKey.passKey.passKeyParams,\r\n        })\r\n      ).jwk;\r\n\r\n      await this.idleService.persistMasterKey(\r\n        await this.keyGraphService.unwrapWithPassKey(\r\n          currentUser.currentUserKey.passKey.id,\r\n          passKey,\r\n          currentUser.currentUserKey.masterKey.id\r\n        )\r\n      );\r\n    }\r\n    await this.keyGraphService.populateKeys(currentUser.currentUserKey);\r\n\r\n    return {\r\n      id: currentUser.id,\r\n      sub: this.getUserAttribute('sub', userAttributes),\r\n      username: currentUser.username,\r\n      currentUserKey: currentUser.currentUserKey,\r\n      getAccessJwtToken: () =>\r\n        cognitoUser.getSignInUserSession().getAccessToken().getJwtToken(),\r\n      email: this.getUserAttribute('email', userAttributes),\r\n      emailVerified:\r\n        this.getUserAttribute('email_verified', userAttributes) === 'true',\r\n      phone: this.getUserAttribute('phone_number', userAttributes),\r\n      phoneVerified:\r\n        this.getUserAttribute('phone_number_verified', userAttributes) ===\r\n        'true',\r\n      contactCard: {\r\n        ...(await this.profileService.decryptContactCard(contactCard)),\r\n      },\r\n      userDelete: currentUser.userDelete,\r\n      userPlans,\r\n      hasTPVaultAccess: this.mapTPVaultAccess(currentUser.features),\r\n      features: currentUser.features,\r\n      sessionEncryptionKey: currentUser.sessionEncryptionKey,\r\n    };\r\n  }\r\n\r\n  public watchAuth(): Observable<any> {\r\n    return this.hubSubject;\r\n  }\r\n\r\n  public async logout(): Promise<void> {\r\n    this.currentUser = null;\r\n    this.keyService.purgeKeys();\r\n    this.keyGraphService.purgeKeys();\r\n\r\n    await Promise.all([this.auth.signOut(), this.profileService.signOut()]);\r\n  }\r\n\r\n  private getUserAttribute(\r\n    attributeName: string,\r\n    userAttributes: CognitoUserAttribute[]\r\n  ) {\r\n    const userAttribute = userAttributes.find(\r\n      (x) => x.getName() === attributeName\r\n    );\r\n\r\n    return userAttribute ? userAttribute.getValue() : null;\r\n  }\r\n\r\n  public async loadResetUser(password?: string): Promise<TpPasswordResetUser> {\r\n    const { tpPasswordResetUser: resetUser } = await this.lrGraphQL.query({\r\n      query: TpPasswordResetUserQuery,\r\n    });\r\n\r\n    if (resetUser.sessionEncryptionKey) {\r\n      this.persistService.setServerSessionEncryptionKey(\r\n        await JWK.asKey(resetUser.sessionEncryptionKey)\r\n      );\r\n    }\r\n\r\n    // Update the keys\r\n    if (password) {\r\n      const passKey = (\r\n        await this.keyFactory.derivePassKey({\r\n          password,\r\n          ...resetUser.passKey.passKeyParams,\r\n        })\r\n      ).jwk;\r\n\r\n      await this.idleService.persistMasterKey(\r\n        await this.keyGraphService.unwrapWithPassKey(\r\n          resetUser.passKey.id,\r\n          passKey,\r\n          resetUser.masterKey.id\r\n        )\r\n      );\r\n    }\r\n\r\n    this.keyService.populateKeys({\r\n      passKey: {\r\n        id: resetUser.passKey.id,\r\n      },\r\n      masterKey: {\r\n        id: resetUser.masterKey.id,\r\n      },\r\n    });\r\n\r\n    const userAttributes = await this.auth.userAttributes(\r\n      await this.auth.currentAuthenticatedUser()\r\n    );\r\n    const sub = this.getUserAttribute('sub', userAttributes);\r\n\r\n    return {\r\n      ...(await this.tpPasswordResetProcessorService.processTpPasswordResetUserNode(\r\n        resetUser\r\n      )),\r\n      sub,\r\n    };\r\n  }\r\n\r\n  public async refreshAccessToken() {\r\n    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();\r\n    const refreshToken = cognitoUser.getSignInUserSession().getRefreshToken();\r\n\r\n    return new Promise((resolve, reject) => {\r\n      cognitoUser.refreshSession(refreshToken, (err, data) => {\r\n        if (err) {\r\n          console.error('Error refreshing token: ', err);\r\n          reject(err);\r\n        } else {\r\n          console.log('Token refresh complete: ', data);\r\n          resolve(0);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  async completeRequest(newPassword: string): Promise<void> {\r\n    const resetUser = await this.getResetUser(true);\r\n\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.lrGraphQL.lrMutate(\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      TP_PASSWORD_RESET_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.lrGraphQL.lrMutate(\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.lrGraphQL.lrMutate(\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  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\r\n        .filter((approval) => !!approval.receiverCipherPartialAssemblyKey)\r\n        .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      TP_PASSWORD_RESET_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"]}