@lifeready/core 5.0.9 → 5.0.10

package/esm2015/lib/auth2/auth2.service.js

@@ -0,0 +1,591 @@
+var Auth2Service_1;
+import { __awaiter, __decorate } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable, Injector, isDevMode, NgZone } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { Hub } from '@aws-amplify/core';
+import { JWK } from 'node-jose';
+import { LrGraphQLService, LrMutation, LrService } from '../api/lr-graphql';
+import { TpClaimState } from '../api/types';
+import { SetSessionEncryptionKeyMutation } from '../auth/auth.gql';
+import { EncryptionService } from '../encryption/encryption.service';
+import { IdleService } from '../idle/idle.service';
+import { KeyFactoryService } from '../key/key-factory.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyService } from '../key/key.service';
+import { KC_CONFIG } from '../life-ready.config';
+import { PasswordService } from '../password/password.service';
+import { PersistService } from '../persist/persist.service';
+import { TP_PASSWORD_RESET_CLIENT_NONCE_LENGTH, TP_PASSWORD_RESET_USERNAME_SUFFIX, } from '../tp-password-reset/tp-password-reset.constants';
+import { TpPasswordResetAssemblyController } from '../tp-password-reset/tp-password-reset.controller';
+import { CompleteTpPasswordResetRequestMutation, CreateTpAssemblyKeyChallengeMutation, PreCompleteTpPasswordResetRequestMutation, } from '../tp-password-reset/tp-password-reset.gql';
+import { KcBadRequestException, KcBadStateException, KcConcurrentAccessException, KcInternalErrorException, } from '../_common/exceptions';
+import { KeyContainer } from '../_common/key';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { CurrentUserQuery, } from './auth2.gql.private';
+import { CognitoChallengeName, PasswordChangeStatus, RecoveryStatus, } from './auth2.types';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@aws-amplify/auth/lib-esm/Auth";
+import * as i3 from "../api/lr-graphql/lr-graphql.service";
+import * as i4 from "../key/key.service";
+import * as i5 from "../key/key-graph.service";
+import * as i6 from "../key/key-factory.service";
+import * as i7 from "../password/password.service";
+import * as i8 from "../idle/idle.service";
+import * as i9 from "../persist/persist.service";
+import * as i10 from "../encryption/encryption.service";
+import * as i11 from "../tp-password-reset/tp-password-reset.controller";
+import * as i12 from "../life-ready.config";
+let Auth2Service = Auth2Service_1 = class Auth2Service extends LrService {
+    constructor(ngZone, injector, http, cognito, api, keyService, keyGraphService, keyFactoryService, passwordService, idleService, persistService, encryptionService, assemblyController, kcConfig) {
+        super(injector);
+        this.ngZone = ngZone;
+        this.injector = injector;
+        this.http = http;
+        this.cognito = cognito;
+        this.api = api;
+        this.keyService = keyService;
+        this.keyGraphService = keyGraphService;
+        this.keyFactoryService = keyFactoryService;
+        this.passwordService = passwordService;
+        this.idleService = idleService;
+        this.persistService = persistService;
+        this.encryptionService = encryptionService;
+        this.assemblyController = assemblyController;
+        this.kcConfig = kcConfig;
+        // Could use rxjs observables here. But trying to have kc-client use as little angular
+        // features as possible. Rxjs is not used anywhere else in kc-client.
+        this.logoutListeners = new Set();
+        // Stores the password for use after mfa verification to decrypt masterKey.
+        this.password = null;
+        if (!isDevMode()) {
+            if (this.kcConfig.debug != null) {
+                throw new KcBadRequestException('In production mode, "KcConfig.debug" must be set to null');
+            }
+        }
+    }
+    importPassword(plainPassword) {
+        return this.keyFactoryService.importPassword(plainPassword);
+    }
+    logout() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            // Notify all listeners to clean up.
+            yield Promise.all([...this.logoutListeners].map((callback) => callback()));
+            this.user = null;
+            this.keyService.purgeKeys();
+            this.keyGraphService.purgeKeys();
+            // Sign out on both cognito and kc-server
+            yield Promise.all([this.cognito.signOut(), this.kcLogout()]);
+            if ((_a = this.kcConfig.debug) === null || _a === void 0 ? void 0 : _a.username) {
+                this.kcConfig.debug.username = null;
+            }
+        });
+    }
+    addLogoutListener(callback) {
+        this.logoutListeners.add(callback);
+    }
+    removeLogoutListener(callback) {
+        this.logoutListeners.delete(callback);
+    }
+    login(emailOrPhone, password, { tpPasswordResetAutoComplete = true } = {}) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            let loginResult = yield this.loginImpl(emailOrPhone, password);
+            // Save the password for use after meeting challenge.
+            if (loginResult.challenge) {
+                this.password = new KeyContainer(password, Auth2Service_1.CHALLENGE_TIMEOUT);
+                return loginResult;
+            }
+            if (tpPasswordResetAutoComplete &&
+                ((_a = loginResult.user.resetUser) === null || _a === void 0 ? void 0 : _a.state) === TpClaimState.APPROVED) {
+                yield this.completeResetRequest(password);
+                loginResult = yield this.loginImpl(emailOrPhone, password);
+            }
+            return loginResult;
+        });
+    }
+    verifyLogin(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { challenge, code, rememberMe } = options;
+            const VALID_CHALLENGE_NAMES = [
+                CognitoChallengeName.SMS_MFA,
+                CognitoChallengeName.SOFTWARE_TOKEN_MFA,
+            ];
+            if (!VALID_CHALLENGE_NAMES.includes(challenge.cognitoUser.challengeName)) {
+                throw new KcBadRequestException(`challengeName must be one of ${VALID_CHALLENGE_NAMES}`);
+            }
+            // TODO: this.auth.confirmSignIn() could return another challenge.
+            const cognitoUser = yield this.cognito.confirmSignIn(challenge.cognitoUser, code, challenge.cognitoUser.challengeName);
+            yield this.handlePostAuth(challenge.recoveryStatus);
+            const user = yield this.loadUser(cognitoUser, this.password.pop());
+            // This is not strictly necessary since the this.password.pop() already clears the
+            // password inside the container. But doesn't hurt either.
+            this.password = null;
+            if (rememberMe) {
+                cognitoUser.setDeviceStatusRemembered({
+                    onSuccess: () => {
+                        return;
+                    },
+                    onFailure: (e) => console.error(e),
+                });
+            }
+            return {
+                user,
+            };
+        });
+    }
+    getUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.user) {
+                return this.user;
+            }
+            const cognitoUser = yield this.cognito.currentAuthenticatedUser();
+            return this.loadUser(cognitoUser);
+        });
+    }
+    refreshAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cognitoUser = yield this.cognito.currentAuthenticatedUser();
+            const refreshToken = cognitoUser.getSignInUserSession().getRefreshToken();
+            console.log('Token refresh...');
+            return new Promise((resolve, reject) => {
+                cognitoUser.refreshSession(refreshToken, (err) => {
+                    if (err) {
+                        console.error('Error refreshing token: ', err);
+                        reject(err);
+                    }
+                    else {
+                        console.log('Token refresh complete');
+                        resolve(0);
+                    }
+                });
+            });
+        });
+    }
+    // ----------------------------------------------------------------------------------------------------
+    // Helpers
+    // ----------------------------------------------------------------------------------------------------
+    fetchCurrentUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.api.query({
+                query: CurrentUserQuery,
+                processorOptions: {
+                    hasKeys: false,
+                },
+            })).currentUser;
+        });
+    }
+    fetchResetUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.api.query({
+                query: CurrentUserQuery,
+                processorOptions: {
+                    hasKeys: false,
+                },
+            })).tpPasswordResetUser;
+        });
+    }
+    kcLogout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.http
+                .post(`${this.kcConfig.authUrl}auth/sign-out/`, null, {
+                withCredentials: true,
+                responseType: 'text',
+            })
+                .toPromise();
+        });
+    }
+    fetchPassIdpParams(emailOrPhone) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http
+                .get(`${this.kcConfig.authUrl}users/pass-idp-params/?login_name=${encodeURIComponent(emailOrPhone)}`)
+                .toPromise();
+        });
+    }
+    loginImpl(emailOrPhone, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.logout();
+            const loginIdpResult = yield this.loginIdp(emailOrPhone, password);
+            // Can't get the user yet because we still ned to meet MFA challenges
+            if ([
+                CognitoChallengeName.SMS_MFA,
+                CognitoChallengeName.SOFTWARE_TOKEN_MFA,
+            ].includes(loginIdpResult.cognitoUser.challengeName)) {
+                return {
+                    challenge: {
+                        cognitoUser: loginIdpResult.cognitoUser,
+                        recoveryStatus: loginIdpResult.recoveryStatus,
+                    },
+                };
+            }
+            yield this.handlePostAuth(loginIdpResult.recoveryStatus);
+            // There should be no MFA on the TP reset user.
+            const user = yield this.loadUser(loginIdpResult.cognitoUser, password);
+            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.fetchPassIdpParams(emailOrPhone);
+            if (passIdpApiResult.passwordChangeStatus === PasswordChangeStatus.IN_PROGRESS) {
+                throw new KcConcurrentAccessException('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 = {
+                        cognitoUser: yield this.loginIdpImpl(emailOrPhone, password, passIdpApiResult.newPassIdpParams),
+                        recoveryStatus: 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 = {
+                        cognitoUser: yield this.loginIdpImpl(emailOrPhone, password, passIdpApiResult.currentPassIdpParams),
+                        recoveryStatus: 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 KcBadRequestException('The password change request was interrupted, please try to login with both your new and old password')
+                        : error;
+                }
+            }
+            // Try again 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 user = {
+                        cognitoUser: yield this.loginIdpImpl(reset.resetUsername, password, reset.passIdpParams),
+                        recoveryStatus: RecoveryStatus.NONE,
+                    };
+                    return user;
+                }
+                catch (err) {
+                    // continue, try again as regular user.
+                }
+            }
+            // Login as regular user
+            const user = {
+                cognitoUser: yield this.loginIdpImpl(emailOrPhone, password, passIdpApiResult.currentPassIdpParams),
+                recoveryStatus: RecoveryStatus.NONE,
+            };
+            return user;
+        });
+    }
+    loginIdpImpl(emailOrPhone, password, passIdpParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const passIdpResult = yield this.keyFactoryService.derivePassIdp(Object.assign({ password }, passIdpParams));
+            // Use the derived password to signin with cognito
+            return this.cognito.signIn(emailOrPhone, this.passwordService.getPassIdpString(passIdpResult.jwk));
+        });
+    }
+    handlePostAuth(recoveryStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.handlePasswordRecovery(recoveryStatus);
+            yield this.handleSessionEncryptionKey();
+        });
+    }
+    handlePasswordRecovery(recoveryStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (recoveryStatus !== RecoveryStatus.NONE) {
+                yield this.passwordService.changePasswordComplete({
+                    useNewPassword: recoveryStatus === RecoveryStatus.NEW_PASSWORD,
+                });
+            }
+        });
+    }
+    handleSessionEncryptionKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.kcConfig.disableSessionEncryptionKey) {
+                if (!isDevMode()) {
+                    const msg = 'You should not set disableSessionEncryptionKey=True in mode prod. It defaults to false.';
+                    console.error(msg);
+                    throw new KcInternalErrorException(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.keyFactoryService.createKey();
+                yield this.lrGraphQL.lrMutate(new LrMutation({
+                    mutation: SetSessionEncryptionKeyMutation,
+                    variables: {
+                        input: {
+                            sessionEncryptionKey: JSON.stringify(sessionEncryptionKey.toJSON(true)),
+                        },
+                    },
+                }), {
+                    includeKeyGraph: false,
+                });
+                this.persistService.setServerSessionEncryptionKey(sessionEncryptionKey);
+            }
+        });
+    }
+    getCognitoUserAttribute(attributeName, userAttributes) {
+        const userAttribute = userAttributes.find((x) => x.getName() === attributeName);
+        return userAttribute ? userAttribute.getValue() : null;
+    }
+    loadUserKeys(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { userKeys, password, sessionEncryptionKey } = options;
+            if (sessionEncryptionKey) {
+                this.persistService.setServerSessionEncryptionKey(yield JWK.asKey(sessionEncryptionKey));
+            }
+            // password is not needed if the master key is already persisted.
+            if (password) {
+                const passKey = (yield this.keyFactoryService.derivePassKey(Object.assign({ password }, userKeys.passKey.passKeyParams))).jwk;
+                yield this.idleService.persistMasterKey(yield this.keyGraphService.unwrapWithPassKey(userKeys.passKey.id, passKey, userKeys.masterKey.id));
+            }
+            yield this.keyGraphService.populateKeys(userKeys);
+        });
+    }
+    loadUser(cognitoUser, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (cognitoUser.getUsername().endsWith(TP_PASSWORD_RESET_USERNAME_SUFFIX)) {
+                this.user = yield this.loadResetUser(cognitoUser, password);
+            }
+            else {
+                this.user = yield this.loadRegularUser(cognitoUser, password);
+            }
+            yield this.idleService.start(); // Run idleService whenever user is logged in.
+            return this.user;
+        });
+    }
+    loadRegularUser(cognitoUser, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentUser = yield this.fetchCurrentUser();
+            yield this.loadUserKeys({
+                userKeys: currentUser.currentUserKey,
+                password,
+                sessionEncryptionKey: currentUser.sessionEncryptionKey,
+            });
+            const { username } = currentUser;
+            const userAttributes = yield this.cognito.userAttributes(cognitoUser);
+            return {
+                username,
+                sub: this.getCognitoUserAttribute('sub', userAttributes),
+                loginEmail: this.getCognitoUserAttribute('email', userAttributes),
+                resetUser: null,
+            };
+        });
+    }
+    loadResetUser(cognitoUser, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resetUser = yield this.fetchResetUser();
+            this.loadUserKeys({
+                userKeys: {
+                    passKey: {
+                        id: resetUser.passKey.id,
+                    },
+                    masterKey: {
+                        id: resetUser.masterKey.id,
+                    },
+                },
+                password,
+                sessionEncryptionKey: resetUser.sessionEncryptionKey,
+            });
+            const { username } = resetUser;
+            const userAttributes = yield this.cognito.userAttributes(cognitoUser);
+            return {
+                username,
+                sub: this.getCognitoUserAttribute('sub', userAttributes),
+                loginEmail: this.getCognitoUserAttribute('email', userAttributes),
+                resetUser: {
+                    state: resetUser.state,
+                },
+            };
+        });
+    }
+    recoverAssemblyKey(resetUser) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prk = yield this.keyGraphService.getKey(resetUser.pxk.id);
+            const partials = yield Promise.all(resetUser.approvals
+                .filter((approval) => !!approval.receiverCipherPartialAssemblyKey)
+                .map((approval) => this.encryptionService.decrypt(prk, approval.receiverCipherPartialAssemblyKey)));
+            return this.assemblyController.recoverAssemblyKey(partials);
+        });
+    }
+    completeResetRequest(newPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resetUser = yield this.fetchResetUser();
+            if (resetUser.state !== TpClaimState.APPROVED) {
+                throw new KcBadStateException('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);
+            // 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.keyFactoryService.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;
+            // Sign the challenge
+            // Generate a client side nonce that's no in the server's control.
+            challenge.clientNonce = this.keyFactoryService.randomString(TP_PASSWORD_RESET_CLIENT_NONCE_LENGTH);
+            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.
+            // There 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);
+                    yield this.cognito.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.cognito.signIn(resetUser.username, tempIdpPassword, {
+                noProxy: 'true',
+            });
+            if (user.challengeName !== 'NEW_PASSWORD_REQUIRED') {
+                throw new KcInternalErrorException('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.cognito.completeNewPassword(user, newIdpPassword, {});
+            return retPromise;
+        });
+    }
+    // ------------------------------------------------------
+    // Debug utilities
+    // ------------------------------------------------------
+    debugLogin(username, password) {
+        // This will fail if debug is null. But when debug is null, this function
+        // should not be called.
+        this.kcConfig.debug.username = username;
+        return this.debugLoadUser(password);
+    }
+    debugLoadUser(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentUser = yield this.fetchCurrentUser();
+            const { username, currentUserKey } = currentUser;
+            // Debug mode can not deal with session encryption key yet.
+            // NO SESSION ENCRYPTION KEY.
+            const passKey = (yield this.keyFactoryService.derivePassKey(Object.assign({ password }, currentUserKey.passKey.passKeyParams))).jwk;
+            const masterKey = yield this.keyGraphService.unwrapWithPassKey(currentUserKey.passKey.id, passKey, currentUserKey.masterKey.id);
+            yield this.idleService.persistMasterKey(masterKey);
+            yield this.keyGraphService.populateKeys(currentUserKey);
+            this.user = {
+                username,
+                resetUser: null,
+                sub: 'DEBUG_MODE',
+                loginEmail: 'DEBUG_MODE',
+            };
+            return this.user;
+        });
+    }
+    /**
+     * Clears the caches user. So we can simulate a page refresh and test getUser().
+     */
+    debugClearUser() {
+        this.user = null;
+    }
+};
+Auth2Service.CHALLENGE_TIMEOUT = 1000 * 60 * 5;
+Auth2Service.ɵprov = i0.ɵɵdefineInjectable({ factory: function Auth2Service_Factory() { return new Auth2Service(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.AuthClass), i0.ɵɵinject(i3.LrGraphQLService), i0.ɵɵinject(i4.KeyService), i0.ɵɵinject(i5.KeyGraphService), i0.ɵɵinject(i6.KeyFactoryService), i0.ɵɵinject(i7.PasswordService), i0.ɵɵinject(i8.IdleService), i0.ɵɵinject(i9.PersistService), i0.ɵɵinject(i10.EncryptionService), i0.ɵɵinject(i11.TpPasswordResetAssemblyController), i0.ɵɵinject(i12.KC_CONFIG)); }, token: Auth2Service, providedIn: "root" });
+Auth2Service.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+Auth2Service.ctorParameters = () => [
+    { type: NgZone },
+    { type: Injector },
+    { type: HttpClient },
+    { type: AuthClass },
+    { type: LrGraphQLService },
+    { type: KeyService },
+    { type: KeyGraphService },
+    { type: KeyFactoryService },
+    { type: PasswordService },
+    { type: IdleService },
+    { type: PersistService },
+    { type: EncryptionService },
+    { type: TpPasswordResetAssemblyController },
+    { type: undefined, decorators: [{ type: Inject, args: [KC_CONFIG,] }] }
+];
+Auth2Service = Auth2Service_1 = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], Auth2Service);
+export { Auth2Service };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth2.service.js","sourceRoot":"","sources":["../../../../../../projects/core/src/lib/auth2/auth2.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Inject, Injectable, Injector, isDevMode, NgZone } from '@angular/core';\nimport { CognitoUser } from '@aws-amplify/auth';\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\nimport { Hub } from '@aws-amplify/core';\nimport { CognitoUserAttribute } from 'amazon-cognito-identity-js';\nimport { JWK } from 'node-jose';\nimport { LrGraphQLService, LrMutation, LrService } from '../api/lr-graphql';\nimport { TpClaimState } from '../api/types';\nimport { SetSessionEncryptionKeyMutation } from '../auth/auth.gql';\nimport { EncryptionService } from '../encryption/encryption.service';\nimport { IdleService } from '../idle/idle.service';\nimport { KeyFactoryService } from '../key/key-factory.service';\nimport { KeyGraphService } from '../key/key-graph.service';\nimport { KeyService, UserKeys } from '../key/key.service';\nimport { PassIdpParams } from '../key/key.types';\nimport { KcConfig, KC_CONFIG } from '../life-ready.config';\nimport { PasswordService } from '../password/password.service';\nimport { PersistService } from '../persist/persist.service';\nimport {\n  TP_PASSWORD_RESET_CLIENT_NONCE_LENGTH,\n  TP_PASSWORD_RESET_USERNAME_SUFFIX,\n} from '../tp-password-reset/tp-password-reset.constants';\nimport { TpPasswordResetAssemblyController } from '../tp-password-reset/tp-password-reset.controller';\nimport {\n  CompleteTpPasswordResetRequestMutation,\n  CreateTpAssemblyKeyChallengeMutation,\n  PreCompleteTpPasswordResetRequestMutation,\n} from '../tp-password-reset/tp-password-reset.gql';\nimport {\n  KcBadRequestException,\n  KcBadStateException,\n  KcConcurrentAccessException,\n  KcInternalErrorException,\n} from '../_common/exceptions';\nimport { KeyContainer } from '../_common/key';\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\nimport {\n  CurrentUserQuery,\n  CurrentUserQueryResult,\n  ResetUserQueryResult,\n} from './auth2.gql.private';\nimport {\n  AuthUser,\n  CognitoChallengeName,\n  LoginChallenge,\n  LoginOptions,\n  LoginResult,\n  LogoutListener,\n  LrCognitoUser,\n  PassIdpResult,\n  PasswordChangeStatus,\n  RecoveryStatus,\n} from './auth2.types';\n\n@RunOutsideAngular({\n  ngZoneName: 'ngZone',\n})\n@Injectable({\n  providedIn: 'root',\n})\nexport class Auth2Service extends LrService {\n  static CHALLENGE_TIMEOUT = 1000 * 60 * 5;\n\n  // Could use rxjs observables here. But trying to have kc-client use as little angular\n  // features as possible. Rxjs is not used anywhere else in kc-client.\n  private logoutListeners = new Set<LogoutListener>();\n  private user: AuthUser;\n  // Stores the password for use after mfa verification to decrypt masterKey.\n  private password: KeyContainer = null;\n\n  constructor(\n    private ngZone: NgZone,\n    private injector: Injector,\n    private http: HttpClient,\n    private cognito: AuthClass,\n    private api: LrGraphQLService,\n    private keyService: KeyService,\n    private keyGraphService: KeyGraphService,\n    private keyFactoryService: KeyFactoryService,\n    private passwordService: PasswordService,\n    private idleService: IdleService,\n    private persistService: PersistService,\n    private encryptionService: EncryptionService,\n    private assemblyController: TpPasswordResetAssemblyController,\n    @Inject(KC_CONFIG) private kcConfig: KcConfig\n  ) {\n    super(injector);\n    if (!isDevMode()) {\n      if (this.kcConfig.debug != null) {\n        throw new KcBadRequestException(\n          'In production mode, \"KcConfig.debug\" must be set to null'\n        );\n      }\n    }\n  }\n\n  importPassword(plainPassword: string): Promise<CryptoKey> {\n    return this.keyFactoryService.importPassword(plainPassword);\n  }\n\n  async logout(): Promise<void> {\n    // Notify all listeners to clean up.\n    await Promise.all([...this.logoutListeners].map((callback) => callback()));\n\n    this.user = null;\n    this.keyService.purgeKeys();\n    this.keyGraphService.purgeKeys();\n\n    // Sign out on both cognito and kc-server\n    await Promise.all([this.cognito.signOut(), this.kcLogout()]);\n\n    if (this.kcConfig.debug?.username) {\n      this.kcConfig.debug.username = null;\n    }\n  }\n\n  addLogoutListener(callback: LogoutListener) {\n    this.logoutListeners.add(callback);\n  }\n\n  removeLogoutListener(callback: LogoutListener) {\n    this.logoutListeners.delete(callback);\n  }\n\n  async login(\n    emailOrPhone: string,\n    password: CryptoKey,\n    { tpPasswordResetAutoComplete = true }: LoginOptions = {}\n  ): Promise<LoginResult> {\n    let loginResult: LoginResult = await this.loginImpl(emailOrPhone, password);\n\n    // Save the password for use after meeting challenge.\n    if (loginResult.challenge) {\n      this.password = new KeyContainer(\n        password,\n        Auth2Service.CHALLENGE_TIMEOUT\n      );\n\n      return loginResult;\n    }\n\n    if (\n      tpPasswordResetAutoComplete &&\n      loginResult.user.resetUser?.state === TpClaimState.APPROVED\n    ) {\n      await this.completeResetRequest(password);\n      loginResult = await this.loginImpl(emailOrPhone, password);\n    }\n\n    return loginResult;\n  }\n\n  async verifyLogin(options: {\n    challenge: LoginChallenge;\n    code: string;\n    rememberMe: boolean;\n  }): Promise<LoginResult> {\n    const { challenge, code, rememberMe } = options;\n\n    const VALID_CHALLENGE_NAMES = [\n      CognitoChallengeName.SMS_MFA,\n      CognitoChallengeName.SOFTWARE_TOKEN_MFA,\n    ];\n\n    if (!VALID_CHALLENGE_NAMES.includes(challenge.cognitoUser.challengeName)) {\n      throw new KcBadRequestException(\n        `challengeName must be one of ${VALID_CHALLENGE_NAMES}`\n      );\n    }\n\n    // TODO: this.auth.confirmSignIn() could return another challenge.\n    const cognitoUser = await this.cognito.confirmSignIn(\n      challenge.cognitoUser,\n      code,\n      challenge.cognitoUser.challengeName as\n        | CognitoChallengeName.SMS_MFA\n        | CognitoChallengeName.SOFTWARE_TOKEN_MFA\n    );\n\n    await this.handlePostAuth(challenge.recoveryStatus);\n\n    const user = await this.loadUser(cognitoUser, this.password.pop());\n\n    // This is not strictly necessary since the this.password.pop() already clears the\n    // password inside the container. But doesn't hurt either.\n    this.password = null;\n\n    if (rememberMe) {\n      cognitoUser.setDeviceStatusRemembered({\n        onSuccess: () => {\n          return;\n        },\n        onFailure: (e) => console.error(e),\n      });\n    }\n\n    return {\n      user,\n    };\n  }\n\n  async getUser(): Promise<AuthUser> {\n    if (this.user) {\n      return this.user;\n    }\n\n    const cognitoUser = await this.cognito.currentAuthenticatedUser();\n\n    return this.loadUser(cognitoUser);\n  }\n\n  async refreshAccessToken() {\n    const cognitoUser: CognitoUser =\n      await this.cognito.currentAuthenticatedUser();\n    const refreshToken = cognitoUser.getSignInUserSession().getRefreshToken();\n\n    console.log('Token refresh...');\n    return new Promise((resolve, reject) => {\n      cognitoUser.refreshSession(refreshToken, (err) => {\n        if (err) {\n          console.error('Error refreshing token: ', err);\n          reject(err);\n        } else {\n          console.log('Token refresh complete');\n          resolve(0);\n        }\n      });\n    });\n  }\n\n  // ----------------------------------------------------------------------------------------------------\n  // Helpers\n  // ----------------------------------------------------------------------------------------------------\n\n  private async fetchCurrentUser() {\n    return (\n      await this.api.query<CurrentUserQueryResult>({\n        query: CurrentUserQuery,\n        processorOptions: {\n          hasKeys: false, // Don't try to decrypt anything because keys have not been setup yet\n        },\n      })\n    ).currentUser;\n  }\n\n  private async fetchResetUser() {\n    return (\n      await this.api.query<ResetUserQueryResult>({\n        query: CurrentUserQuery,\n        processorOptions: {\n          hasKeys: false, // Don't try to decrypt anything because keys have not been setup yet\n        },\n      })\n    ).tpPasswordResetUser;\n  }\n\n  private async kcLogout(): Promise<void> {\n    await this.http\n      .post(`${this.kcConfig.authUrl}auth/sign-out/`, null, {\n        withCredentials: true,\n        responseType: 'text',\n      })\n      .toPromise();\n  }\n\n  private async fetchPassIdpParams(\n    emailOrPhone: string\n  ): Promise<PassIdpResult> {\n    return await this.http\n      .get<PassIdpResult>(\n        `${\n          this.kcConfig.authUrl\n        }users/pass-idp-params/?login_name=${encodeURIComponent(emailOrPhone)}`\n      )\n      .toPromise();\n  }\n\n  private async loginImpl(\n    emailOrPhone: string,\n    password: CryptoKey\n  ): Promise<LoginResult> {\n    await this.logout();\n    const loginIdpResult = await this.loginIdp(emailOrPhone, password);\n\n    // Can't get the user yet because we still ned to meet MFA challenges\n    if (\n      [\n        CognitoChallengeName.SMS_MFA,\n        CognitoChallengeName.SOFTWARE_TOKEN_MFA,\n      ].includes(loginIdpResult.cognitoUser.challengeName)\n    ) {\n      return {\n        challenge: {\n          cognitoUser: loginIdpResult.cognitoUser,\n          recoveryStatus: loginIdpResult.recoveryStatus,\n        },\n      };\n    }\n\n    await this.handlePostAuth(loginIdpResult.recoveryStatus);\n\n    // There should be no MFA on the TP reset user.\n    const user = await this.loadUser(loginIdpResult.cognitoUser, password);\n\n    return {\n      user,\n    };\n  }\n\n  private async loginIdp(\n    emailOrPhone: string,\n    password: CryptoKey\n  ): Promise<LoginChallenge> {\n    // Download the salt needed to derive the PassIdp\n    const passIdpApiResult = await this.fetchPassIdpParams(emailOrPhone);\n\n    if (\n      passIdpApiResult.passwordChangeStatus === PasswordChangeStatus.IN_PROGRESS\n    ) {\n      throw new KcConcurrentAccessException('A password change is in progress');\n    }\n\n    if (\n      passIdpApiResult.passwordChangeStatus === PasswordChangeStatus.RECOVERY\n    ) {\n      console.log('In recovery mode.');\n\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.\n      try {\n        const user: LoginChallenge = {\n          cognitoUser: await this.loginIdpImpl(\n            emailOrPhone,\n            password,\n            passIdpApiResult.newPassIdpParams\n          ),\n          recoveryStatus: RecoveryStatus.NEW_PASSWORD,\n        };\n        // New password worked. Let's set to the current password\n\n        // --Potential Failure Point 1--\n        // if changePasswordComplete() doesn't get called, then it should remain\n\n        console.log('New password works!');\n\n        return user;\n      } catch (error) {\n        // Just bubble up any other type of error.\n        if (error.code !== 'NotAuthorizedException') {\n          throw error;\n        }\n        // pass, try again assuming it's the old password\n      }\n\n      // Now assume it's the previous password. Any exception is allowed to bubble up.\n      try {\n        const user: LoginChallenge = {\n          cognitoUser: await this.loginIdpImpl(\n            emailOrPhone,\n            password,\n            passIdpApiResult.currentPassIdpParams\n          ),\n          recoveryStatus: RecoveryStatus.OLD_PASSWORD,\n        };\n        // Old password worked.\n        console.log('Old password works!');\n\n        return user;\n      } catch (error) {\n        // Just bubble up any other type of error.\n        throw error.code === 'NotAuthorizedException'\n          ? new KcBadRequestException(\n              'The password change request was interrupted, please try to login with both your new and old password'\n            )\n          : error;\n      }\n    }\n\n    // Try again as the TP password reset account\n    if (passIdpApiResult.tpPasswordReset) {\n      try {\n        // TP password reset is in process. We need to try the password against both\n        // original account and the new reset account.\n        const reset = passIdpApiResult.tpPasswordReset;\n        const user: LoginChallenge = {\n          cognitoUser: await this.loginIdpImpl(\n            reset.resetUsername,\n            password,\n            reset.passIdpParams\n          ),\n          recoveryStatus: RecoveryStatus.NONE,\n        };\n\n        return user;\n      } catch (err) {\n        // continue, try again as regular user.\n      }\n    }\n\n    // Login as regular user\n    const user: LoginChallenge = {\n      cognitoUser: await this.loginIdpImpl(\n        emailOrPhone,\n        password,\n        passIdpApiResult.currentPassIdpParams\n      ),\n      recoveryStatus: RecoveryStatus.NONE,\n    };\n\n    return user;\n  }\n\n  private async loginIdpImpl(\n    emailOrPhone: string,\n    password: CryptoKey,\n    passIdpParams: PassIdpParams\n  ): Promise<LrCognitoUser> {\n    const passIdpResult = await this.keyFactoryService.derivePassIdp({\n      password,\n      ...passIdpParams,\n    });\n\n    // Use the derived password to signin with cognito\n    return this.cognito.signIn(\n      emailOrPhone,\n      this.passwordService.getPassIdpString(passIdpResult.jwk)\n    );\n  }\n\n  private async handlePostAuth(recoveryStatus: RecoveryStatus) {\n    await this.handlePasswordRecovery(recoveryStatus);\n    await this.handleSessionEncryptionKey();\n  }\n\n  private async handlePasswordRecovery(recoveryStatus: RecoveryStatus) {\n    if (recoveryStatus !== RecoveryStatus.NONE) {\n      await this.passwordService.changePasswordComplete({\n        useNewPassword: recoveryStatus === RecoveryStatus.NEW_PASSWORD,\n      });\n    }\n  }\n\n  private async handleSessionEncryptionKey() {\n    if (this.kcConfig.disableSessionEncryptionKey) {\n      if (!isDevMode()) {\n        const msg =\n          'You should not set disableSessionEncryptionKey=True in mode prod. It defaults to false.';\n        console.error(msg);\n        throw new KcInternalErrorException(msg);\n      } else {\n        console.warn(\n          'You have set disableSessionEncryptionKey=True. Make sure not to do this in prod mode.'\n        );\n      }\n    } else {\n      // Set the session key to a new encryption key for this session\n      const sessionEncryptionKey = await this.keyFactoryService.createKey();\n      await this.lrGraphQL.lrMutate(\n        new LrMutation({\n          mutation: SetSessionEncryptionKeyMutation,\n          variables: {\n            input: {\n              sessionEncryptionKey: JSON.stringify(\n                sessionEncryptionKey.toJSON(true)\n              ),\n            },\n          },\n        }),\n        {\n          includeKeyGraph: false,\n        }\n      );\n\n      this.persistService.setServerSessionEncryptionKey(sessionEncryptionKey);\n    }\n  }\n\n  private getCognitoUserAttribute(\n    attributeName: string,\n    userAttributes: CognitoUserAttribute[]\n  ) {\n    const userAttribute = userAttributes.find(\n      (x) => x.getName() === attributeName\n    );\n\n    return userAttribute ? userAttribute.getValue() : null;\n  }\n\n  private async loadUserKeys(options: {\n    userKeys: UserKeys;\n    password?: CryptoKey;\n    sessionEncryptionKey?: string;\n  }) {\n    const { userKeys, password, sessionEncryptionKey } = options;\n\n    if (sessionEncryptionKey) {\n      this.persistService.setServerSessionEncryptionKey(\n        await JWK.asKey(sessionEncryptionKey)\n      );\n    }\n\n    // password is not needed if the master key is already persisted.\n    if (password) {\n      const passKey = (\n        await this.keyFactoryService.derivePassKey({\n          password,\n          ...userKeys.passKey.passKeyParams,\n        })\n      ).jwk;\n\n      await this.idleService.persistMasterKey(\n        await this.keyGraphService.unwrapWithPassKey(\n          userKeys.passKey.id,\n          passKey,\n          userKeys.masterKey.id\n        )\n      );\n    }\n\n    await this.keyGraphService.populateKeys(userKeys);\n  }\n\n  private async loadUser(\n    cognitoUser: CognitoUser,\n    password?: CryptoKey\n  ): Promise<AuthUser> {\n    if (cognitoUser.getUsername().endsWith(TP_PASSWORD_RESET_USERNAME_SUFFIX)) {\n      this.user = await this.loadResetUser(cognitoUser, password);\n    } else {\n      this.user = await this.loadRegularUser(cognitoUser, password);\n    }\n\n    await this.idleService.start(); // Run idleService whenever user is logged in.\n\n    return this.user;\n  }\n\n  private async loadRegularUser(\n    cognitoUser: CognitoUser,\n    password?: CryptoKey\n  ): Promise<AuthUser> {\n    const currentUser = await this.fetchCurrentUser();\n\n    await this.loadUserKeys({\n      userKeys: currentUser.currentUserKey,\n      password,\n      sessionEncryptionKey: currentUser.sessionEncryptionKey,\n    });\n\n    const { username } = currentUser;\n    const userAttributes = await this.cognito.userAttributes(cognitoUser);\n\n    return {\n      username,\n      sub: this.getCognitoUserAttribute('sub', userAttributes),\n      loginEmail: this.getCognitoUserAttribute('email', userAttributes),\n      resetUser: null,\n    };\n  }\n\n  private async loadResetUser(\n    cognitoUser: CognitoUser,\n    password?: CryptoKey\n  ): Promise<AuthUser> {\n    const resetUser = await this.fetchResetUser();\n\n    this.loadUserKeys({\n      userKeys: {\n        passKey: {\n          id: resetUser.passKey.id,\n        },\n        masterKey: {\n          id: resetUser.masterKey.id,\n        },\n      },\n      password,\n      sessionEncryptionKey: resetUser.sessionEncryptionKey,\n    });\n\n    const { username } = resetUser;\n    const userAttributes = await this.cognito.userAttributes(cognitoUser);\n\n    return {\n      username,\n      sub: this.getCognitoUserAttribute('sub', userAttributes),\n      loginEmail: this.getCognitoUserAttribute('email', userAttributes),\n      resetUser: {\n        state: resetUser.state,\n      },\n    };\n  }\n\n  private async recoverAssemblyKey(\n    resetUser: ResetUserQueryResult['tpPasswordResetUser']\n  ): Promise<JWK.Key> {\n    const prk = await this.keyGraphService.getKey(resetUser.pxk.id);\n\n    const partials = await Promise.all(\n      resetUser.approvals\n        .filter((approval) => !!approval.receiverCipherPartialAssemblyKey)\n        .map((approval) =>\n          this.encryptionService.decrypt(\n            prk,\n            approval.receiverCipherPartialAssemblyKey\n          )\n        )\n    );\n\n    return this.assemblyController.recoverAssemblyKey(partials);\n  }\n\n  async completeResetRequest(newPassword: CryptoKey): Promise<void> {\n    const resetUser = await this.fetchResetUser();\n\n    if (resetUser.state !== TpClaimState.APPROVED) {\n      throw new KcBadStateException(\n        'Password reset request has not been approved.'\n      );\n    }\n\n    // --------------------------------------------------------------\n    // Prepare all materials to ensure there are no errors.\n    // --------------------------------------------------------------\n    const assemblyKey = await this.recoverAssemblyKey(resetUser);\n\n    const { rootKey } = await this.encryptionService.decrypt(\n      assemblyKey,\n      resetUser.assemblyCipherData\n    );\n\n    // Making sure it's a valid key.\n    const rootKeyJwk = await JWK.asKey(rootKey);\n\n    const masterKey = await this.keyGraphService.getKey(resetUser.masterKey.id);\n\n    const masterKeyWrappedRootKey =\n      await this.encryptionService.encryptToString(\n        masterKey.jwk,\n        rootKeyJwk.toJSON(true)\n      );\n\n    // The new password\n    const newPassIdpResult = await this.keyFactoryService.derivePassIdp({\n      password: newPassword,\n      ...resetUser.passKey.passIdpParams,\n    });\n\n    const newIdpPassword = this.passwordService.getPassIdpString(\n      newPassIdpResult.jwk\n    );\n\n    // --------------------------------------------------------------\n    // Get assembly key challenge\n    // --------------------------------------------------------------\n    const challenge = (\n      await this.lrGraphQL.lrMutate(\n        new LrMutation({\n          mutation: CreateTpAssemblyKeyChallengeMutation,\n          variables: {\n            input: {},\n          },\n        }),\n        {\n          includeKeyGraph: false,\n        }\n      )\n    ).createTpAssemblyKeyChallenge.challenge;\n\n    // Sign the challenge\n    // Generate a client side nonce that's no in the server's control.\n    challenge.clientNonce = this.keyFactoryService.randomString(\n      TP_PASSWORD_RESET_CLIENT_NONCE_LENGTH\n    );\n\n    const assemblyKeyVerifierPrk = await this.encryptionService.decrypt(\n      assemblyKey,\n      resetUser.wrappedAssemblyKeyVerifierPrk\n    );\n    const signedChallenge = await this.encryptionService.sign(\n      assemblyKeyVerifierPrk,\n      challenge\n    );\n\n    // --------------------------------------------------------------\n    // Change password for the original user\n    // --------------------------------------------------------------\n    const tempIdpPassword = (\n      await this.lrGraphQL.lrMutate(\n        new LrMutation({\n          mutation: PreCompleteTpPasswordResetRequestMutation,\n          variables: {\n            input: {\n              signedChallenge: JSON.stringify(signedChallenge),\n            },\n          },\n        }),\n        {\n          includeKeyGraph: false,\n        }\n      )\n    ).preCompleteTpPasswordResetRequest.idpPassword;\n\n    // --------------------------------------------------------------\n    // Login as the original user using new temporary password\n    // --------------------------------------------------------------\n    // At this point, the original account's password has been changed\n    // to a temporary password. It is no longer possible for the user\n    // to use the original password to login. Any successful login\n    // can only be using the temporary password. So it's safe to assume\n    // that we want to \"complete\" the password reset.\n\n    // There maybe 2FA so we listen for the auth event from Amplify.\n    const retPromise = new Promise<void>((resolve) => {\n      const listener = async (data) => {\n        if (data.payload.event !== 'signIn') {\n          return;\n        }\n\n        Hub.remove('auth', listener);\n\n        await this.cognito.signIn(resetUser.username, newIdpPassword);\n\n        // Switch over to the new set of keys\n        await this.lrGraphQL.lrMutate(\n          new LrMutation({\n            mutation: CompleteTpPasswordResetRequestMutation,\n            variables: {\n              input: {\n                masterKeyWrappedRootKey,\n                masterKeyId: masterKey.id,\n              },\n            },\n          })\n        );\n\n        resolve();\n      };\n\n      Hub.listen('auth', listener);\n    });\n\n    // Signin as the original user. Password has been reset to temporary one. It should return\n    // with NEW_PASSWORD_REQUIRED\n    let user = await this.cognito.signIn(resetUser.username, tempIdpPassword, {\n      noProxy: 'true',\n    });\n\n    if (user.challengeName !== 'NEW_PASSWORD_REQUIRED') {\n      throw new KcInternalErrorException(\n        'Expecting Cognito to have done a password reset after call to PreCompleteTpPasswordResetRequestMutation.'\n      );\n    }\n\n    // Set new password on Idp\n    // the awsFetch() function passes NEW_PASSWORD_REQUIRED directly to AWS without\n    // going through the proxy.\n    user = await this.cognito.completeNewPassword(user, newIdpPassword, {});\n\n    return retPromise;\n  }\n\n  // ------------------------------------------------------\n  // Debug utilities\n  // ------------------------------------------------------\n  debugLogin(username: string, password: CryptoKey): Promise<AuthUser> {\n    // This will fail if debug is null. But when debug is null, this function\n    // should not be called.\n    this.kcConfig.debug.username = username;\n\n    return this.debugLoadUser(password);\n  }\n\n  private async debugLoadUser(password: CryptoKey): Promise<AuthUser> {\n    const currentUser = await this.fetchCurrentUser();\n\n    const { username, currentUserKey } = currentUser;\n\n    // Debug mode can not deal with session encryption key yet.\n    // NO SESSION ENCRYPTION KEY.\n\n    const passKey = (\n      await this.keyFactoryService.derivePassKey({\n        password,\n        ...currentUserKey.passKey.passKeyParams,\n      })\n    ).jwk;\n\n    const masterKey = await this.keyGraphService.unwrapWithPassKey(\n      currentUserKey.passKey.id,\n      passKey,\n      currentUserKey.masterKey.id\n    );\n\n    await this.idleService.persistMasterKey(masterKey);\n\n    await this.keyGraphService.populateKeys(currentUserKey);\n\n    this.user = {\n      username,\n      resetUser: null,\n      sub: 'DEBUG_MODE',\n      loginEmail: 'DEBUG_MODE',\n    };\n\n    return this.user;\n  }\n\n  /**\n   * Clears the caches user. So we can simulate a page refresh and test getUser().\n   */\n  debugClearUser() {\n    this.user = null;\n  }\n}\n"]}