@lifeready/core 0.6.0-beta.1

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

@@ -0,0 +1,333 @@
+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, } from '../_common/exceptions';
+import { RecoveryStatus, } from './auth.types';
+import { PasswordService } from './password.service';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { 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 { 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 * 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";
+export const initialiseAuth = (authService) => {
+    return () => authService.initialise();
+};
+export class LifeReadyAuthService {
+    constructor(config, auth, keyFactory, keyService, profileService, keyGraphService, passwordService, idleService, lrGraphQL, tpPasswordResetProcessorService, persistService) {
+        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.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) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+            }
+        });
+    }
+    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);
+                    }
+                });
+            });
+        });
+    }
+}
+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)); }, 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 }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"life-ready-auth.service.js","sourceRoot":"C:/Projects/test/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} 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 { TpPasswordResetUserQuery } 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 { 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\n\r\nexport const initialiseAuth = (authService: LifeReadyAuthService) => {\r\n  return () => authService.initialise();\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\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  ) {}\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  ): Promise<LoginResult> {\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 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"]}