@lifeready/core 1.0.1 → 1.0.3

package/esm2015/lib/auth/password.service.js

@@ -0,0 +1,320 @@
+import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { ProfileService } from '../users/profile.service';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { LR_CONFIG } from '../life-ready.config';
+import { LrAuthException, LrBadArgumentException } from '../_common/exceptions';
+import { LrApolloService } from './../api/lr-apollo.service';
+import { PasswordChangeMutation, PasswordChangeRequestMutation, PasswordChangeConfigQuery, } from './auth.gql';
+import { WebCryptoService } from '../cryptography/web-crypto.service';
+import * as moment_ from 'moment';
+import { IdleService } from '../auth/idle.service';
+import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../life-ready.config";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../api/lr-apollo.service";
+import * as i4 from "@aws-amplify/auth/lib-esm/Auth";
+import * as i5 from "../users/profile.service";
+import * as i6 from "../cryptography/key-factory.service";
+import * as i7 from "../cryptography/encryption.service";
+import * as i8 from "../cryptography/key-graph.service";
+import * as i9 from "../cryptography/web-crypto.service";
+import * as i10 from "./idle.service";
+// "why?" you ask: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment
+const moment = moment_;
+export class PasswordCheck {
+}
+export class PasswordService {
+    constructor(config, http, apollo, auth, profileService, keyFactory, encryptionService, keyGraph, webCryptoService, idleService) {
+        this.config = config;
+        this.http = http;
+        this.apollo = apollo;
+        this.auth = auth;
+        this.profileService = profileService;
+        this.keyFactory = keyFactory;
+        this.encryptionService = encryptionService;
+        this.keyGraph = keyGraph;
+        this.webCryptoService = webCryptoService;
+        this.idleService = idleService;
+        this.CLIENT_NONCE_LENGTH = 32;
+    }
+    checkPassword(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { years } = this.passwordStrength(password);
+            return {
+                length: password.length,
+                timeToCrack: moment.duration({ years }),
+                passwordExposed: yield this.getExposureCount(password),
+            };
+        });
+    }
+    getExposureCount(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sha1Password = yield this.webCryptoService.stringDigest('SHA-1', password);
+            const first5sha1 = sha1Password.substring(0, 5);
+            const response = yield this.http
+                .get(`https://api.pwnedpasswords.com/range/${first5sha1}`, {
+                responseType: 'text',
+            })
+                .toPromise();
+            const results = new RegExp(`^(?:${sha1Password.substring(5)}:)(?<count>\\d+)$`, 'im').exec(response);
+            if (results) {
+                return +results.groups.count;
+            }
+            return 0;
+        });
+    }
+    getPassIdpString(passIdp) {
+        return passIdp.toJSON(true).k;
+    }
+    createPassKeyBundle(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const passIdpParams = yield this.keyFactory.createPassIdpParams();
+            const passIdp = (yield this.keyFactory.derivePassIdp(Object.assign({ password }, passIdpParams))).jwk;
+            const passKeyParams = yield this.keyFactory.createPassKeyParams();
+            const passKey = (yield this.keyFactory.derivePassKey(Object.assign({ password }, passKeyParams))).jwk;
+            const passIdpVerifier = yield this.keyFactory.createPkcSignKey();
+            const wrappedPassIdpVerifierPrk = yield this.encryptionService.encrypt(passKey, passIdpVerifier.toJSON(true));
+            // There are two formats that the private key can be represented in JWK:
+            // https://tools.ietf.org/html/rfc8017#page-9
+            // The second form is an optimization:
+            // https://crypto.stackexchange.com/questions/19413/what-are-dp-and-dq-in-encryption-by-rsa-in-c
+            return {
+                passKeyParams,
+                passKey,
+                passIdpParams,
+                passIdp,
+                passIdpVerifier,
+                wrappedPassIdpVerifierPrk,
+            };
+        });
+    }
+    /**
+     * We need to allow for interruption of the process at any point. Each API call can be considered
+     * atomic and either succeeds or fails.
+     *
+     * The LR server APIs use semaphore tokens for locking critical operations, so concurrent calls will
+     * fail.
+     *
+     * We assume the worst case for IdP API calls. So we use the semaphore token from LR to prevent
+     * concurrent calls to IdP APIs, but we have to assume that the IdP API calls will either succeed or
+     * fail within a reasonable amount of time.
+     *
+     * Each location where the server state changes can be a potential point of interruption.
+     * Potential points of interruption are marked with: --Potential Failure Point--
+     *
+     * Places for timeout:
+     * - Login age too old at call to: verifyPassword()
+     * - Login age too old at call to: changePasswordMutation()
+     * - Semaphore token expires at call to: changePasswordComplete()
+     *
+     * Tests:
+     * - Potential Failure Point 1: should be able to restart the process, user remains signed in.
+     * - Potential Failure Point 2: should enter recovery flow
+     * - Potential Failure Point 3: should enter recovery flow
+     * - Potential Failure Point 4: should enter recovery flow
+     *
+     */
+    isLoginRequired() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const changePasswordConfig = yield this.getChangePasswordConfig();
+            const authTime = moment(changePasswordConfig.authTime);
+            const serverTime = moment(changePasswordConfig.serverTime);
+            const duration = moment.duration(serverTime.diff(authTime));
+            const seconds = duration.asSeconds();
+            if (seconds > changePasswordConfig.maxAuthAgeSeconds) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        });
+    }
+    changePassword(password, newPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cognitoUser = yield this.auth.currentAuthenticatedUser();
+            // Validation
+            // todo: Add this back in
+            // Note the passIdp will always have a random salt, so will always be different to the current passIdp.
+            if (password === newPassword) {
+                throw new LrBadArgumentException('New password is the same as the current one.');
+            }
+            const { currentUser } = yield this.profileService.getCurrentUser();
+            const { passIdp, signedChallenge } = yield this.verifyPassword(password, currentUser);
+            // --Potential Failure Point 1--
+            // verifyPassword() asks for a current password challenge hence changes server state.
+            // Place break points here to test the failure scenarios.
+            // Generate the new passIdp
+            const newPassKey = yield this.createPassKeyBundle(newPassword);
+            // Re-encrypt master key with new key
+            const masterKey = yield this.keyGraph.getKey(currentUser.currentUserKey.masterKey.id);
+            const newWrappedMasterKey = yield this.encryptionService.encrypt(newPassKey.passKey, masterKey.jwk.toJSON(true));
+            // If the IdP change password failed, we need to go into recovery mode by forcing
+            // a login. We can't logout the user just yet since the IdP password change needs
+            // the user to be logged in. We _can_ removed any persisted session values for the IdP
+            // but that seems like too much trouble.
+            const { token, newPassKeyId } = yield this.changePasswordMutation(signedChallenge, currentUser.currentUserKey.masterKey.id, newWrappedMasterKey, newPassKey);
+            // --Potential Failure Point 2--
+            // changePasswordMutation() uploads new keys and obtains a semaphore lock to prevent any other
+            // clients from performing IdP password change.
+            // Now we can do the IdP password change.
+            // todo: Add this back in
+            yield this.auth.changePassword(cognitoUser, this.getPassIdpString(passIdp), this.getPassIdpString(newPassKey.passIdp));
+            // --Potential Failure Point 3--
+            // IdP password change
+            // Note that changePassword() could throw an exception for a number of reason. It could throw
+            // a network timeout for example. But we don't know if it's the response that timed out and
+            // the idp password change was actually carried out. So we have to be extra conservative and
+            // only act on a clear success. Otherwise we go into recover mode.
+            yield this.changePasswordComplete(cognitoUser.getSignInUserSession().getAccessToken().getJwtToken(), true, token);
+        });
+    }
+    changePasswordComplete(accessToken, useNewPassword, token = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.http
+                .post(`${this.config.authUrl}users/password-change-complete/`, Object.assign({ use_new_password: useNewPassword }, (token && { token })), {
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            })
+                .toPromise();
+        });
+    }
+    getVerifierPrK(passKey, wrappedPrK) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const prkJson = yield this.encryptionService.decrypt(passKey, wrappedPrK);
+                return KFS.asKey(prkJson);
+            }
+            catch (error) {
+                throw new LrAuthException('Wrong current password');
+            }
+        });
+    }
+    verifyPassword(password, currentUser) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get information from the server to prepare for password change.
+            const passwordRequest = yield this.apollo.mutate({
+                mutation: PasswordChangeRequestMutation,
+                variables: {},
+            });
+            // Get the old passKey so we can decrypt the old password verifier
+            const passKeyResult = yield this.keyFactory.derivePassKey(Object.assign({ password }, currentUser.currentUserKey.passKey.passKeyParams));
+            const verifierPrK = yield this.getVerifierPrK(passKeyResult.jwk, currentUser.currentUserKey.passKey.wrappedPassIdpVerifierPrk);
+            // Sign the server challenge to prove to the server we can decrypt the password verifier.
+            // Generate
+            const clientNonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);
+            const signedChallenge = yield this.encryptionService.sign(verifierPrK, {
+                serverNonce: passwordRequest.passwordChangeRequest.challenge.serverNonce,
+                clientNonce,
+            });
+            const passIdpResult = yield this.keyFactory.derivePassIdp(Object.assign({ password }, currentUser.currentUserKey.passKey.passIdpParams));
+            return {
+                passIdp: passIdpResult.jwk,
+                signedChallenge,
+            };
+        });
+    }
+    changePasswordMutation(signedChallenge, masterKeyId, newWrappedMasterKey, passKeyBundle) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.apollo.mutate({
+                mutation: PasswordChangeMutation,
+                variables: {
+                    input: {
+                        signedChallenge: JSON.stringify(signedChallenge),
+                        masterKeyId,
+                        newWrappedMasterKey: JSON.stringify(newWrappedMasterKey),
+                        newPassKey: {
+                            passIdpParams: JSON.stringify(passKeyBundle.passIdpParams),
+                            passIdpVerifierPbk: JSON.stringify(passKeyBundle.passIdpVerifier.toJSON()),
+                            wrappedPassIdpVerifierPrk: JSON.stringify(passKeyBundle.wrappedPassIdpVerifierPrk),
+                            passKeyParams: JSON.stringify(passKeyBundle.passKeyParams),
+                        },
+                    },
+                },
+            });
+            return {
+                token: response.passwordChange.token,
+                newPassKeyId: response.passwordChange.newPassKey.id,
+            };
+        });
+    }
+    getChangePasswordConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.apollo.query({
+                query: PasswordChangeConfigQuery,
+            });
+            const ret = res.passwordChangeConfig;
+            ret.authTime = new Date(ret.authTime);
+            ret.serverTime = new Date(ret.serverTime);
+            return ret;
+        });
+    }
+    passwordStrength(password) {
+        const upper = /[A-Z]/g;
+        const lower = /[a-z]/g;
+        const digit = /[0-9]/g;
+        const upperChoices = 26;
+        const lowerChoices = 26;
+        const digitChoices = 10;
+        const specialChoices = 30; // /[!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~]/g
+        function instanceCount(str, re) {
+            return ((str || '').match(re) || []).length;
+        }
+        const uppers = instanceCount(password, upper);
+        const lowers = instanceCount(password, lower);
+        const digits = instanceCount(password, digit);
+        const specials = password.length - uppers - lowers - digits;
+        let choices = 0;
+        if (uppers) {
+            choices += upperChoices;
+        }
+        if (lowers) {
+            choices += lowerChoices;
+        }
+        if (digits) {
+            choices += digitChoices;
+        }
+        if (specials) {
+            choices += specialChoices;
+        }
+        if (password.length === 0) {
+            return {
+                years: 0,
+                // bits of entropy
+                bits: 0,
+            };
+        }
+        const permutations = Math.pow(choices, password.length);
+        const years = (54000 * permutations) /
+            Math.pow(upperChoices + lowerChoices + digitChoices, 12);
+        return {
+            years,
+            // bits of entropy
+            bits: Math.round(Math.log2(permutations)),
+        };
+    }
+}
+PasswordService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PasswordService_Factory() { return new PasswordService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.LrApolloService), i0.ɵɵinject(i4.AuthClass), i0.ɵɵinject(i5.ProfileService), i0.ɵɵinject(i6.KeyFactoryService), i0.ɵɵinject(i7.EncryptionService), i0.ɵɵinject(i8.KeyGraphService), i0.ɵɵinject(i9.WebCryptoService), i0.ɵɵinject(i10.IdleService)); }, token: PasswordService, providedIn: "root" });
+PasswordService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+PasswordService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: HttpClient },
+    { type: LrApolloService },
+    { type: AuthClass },
+    { type: ProfileService },
+    { type: KFS },
+    { type: EncryptionService },
+    { type: KeyGraphService },
+    { type: WebCryptoService },
+    { type: IdleService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"password.service.js","sourceRoot":"C:/Projects/newrepo/kc-client/projects/core/src/","sources":["lib/auth/password.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Inject, Injectable } from '@angular/core';\r\nimport { CognitoUser } from '@aws-amplify/auth';\r\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\r\nimport { JWK, JWS } from 'node-jose';\r\nimport { ProfileService } from '../users/profile.service';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\r\nimport { LrAuthException, LrBadArgumentException } from '../_common/exceptions';\r\nimport { LrApolloService } from './../api/lr-apollo.service';\r\nimport {\r\n  PasswordChangeMutation,\r\n  PasswordChangeRequestMutation,\r\n  PasswordChangeConfigQuery,\r\n} from './auth.gql';\r\nimport { PassKeyBundle } from './auth.types';\r\nimport { WebCryptoService } from '../cryptography/web-crypto.service';\r\nimport { Duration } from 'moment';\r\nimport * as moment_ from 'moment';\r\nimport { ApiCurrentUser } from '../users/profile.types';\r\nimport { IdleService } from '../auth/idle.service';\r\nimport { KeyFactoryService as KFS } from '../cryptography/key-factory.service';\r\n\r\n// \"why?\" you ask: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment\r\nconst moment = moment_;\r\n\r\ninterface PasswordChangeRequestMutation {\r\n  passwordChangeRequest: {\r\n    challenge: {\r\n      serverNonce: string;\r\n    };\r\n  };\r\n}\r\n\r\ninterface PasswordChangeMutation {\r\n  passwordChange: {\r\n    token: string;\r\n    newPassKey: {\r\n      id: string;\r\n    };\r\n  };\r\n}\r\n\r\nexport interface PasswordChangeConfig {\r\n  maxAuthAgeSeconds: number;\r\n  authTime: string | Date;\r\n  serverTime: string | Date;\r\n}\r\n\r\nexport class PasswordCheck {\r\n  length?: number;\r\n  timeToCrack?: Duration;\r\n  passwordExposed?: number;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class PasswordService {\r\n  private readonly CLIENT_NONCE_LENGTH = 32;\r\n\r\n  constructor(\r\n    @Inject(LR_CONFIG) private config: LifeReadyConfig,\r\n    private http: HttpClient,\r\n    private apollo: LrApolloService,\r\n    private auth: AuthClass,\r\n    private profileService: ProfileService,\r\n    private keyFactory: KFS,\r\n    private encryptionService: EncryptionService,\r\n    private keyGraph: KeyGraphService,\r\n    private webCryptoService: WebCryptoService,\r\n    private idleService: IdleService\r\n  ) {}\r\n\r\n  public async checkPassword(password: string): Promise<PasswordCheck> {\r\n    const { years } = this.passwordStrength(password);\r\n\r\n    return {\r\n      length: password.length,\r\n      timeToCrack: moment.duration({ years }),\r\n      passwordExposed: await this.getExposureCount(password),\r\n    };\r\n  }\r\n\r\n  public async getExposureCount(password: string): Promise<number> {\r\n    const sha1Password = await this.webCryptoService.stringDigest(\r\n      'SHA-1',\r\n      password\r\n    );\r\n    const first5sha1 = sha1Password.substring(0, 5);\r\n\r\n    const response = await this.http\r\n      .get(`https://api.pwnedpasswords.com/range/${first5sha1}`, {\r\n        responseType: 'text',\r\n      })\r\n      .toPromise();\r\n\r\n    const results = new RegExp(\r\n      `^(?:${sha1Password.substring(5)}:)(?<count>\\\\d+)$`,\r\n      'im'\r\n    ).exec(response);\r\n\r\n    if (results) {\r\n      return +results.groups.count;\r\n    }\r\n    return 0;\r\n  }\r\n\r\n  public getPassIdpString(passIdp: JWK.Key) {\r\n    return (passIdp.toJSON(true) as any).k;\r\n  }\r\n\r\n  public async createPassKeyBundle(password: string): Promise<PassKeyBundle> {\r\n    const passIdpParams = await this.keyFactory.createPassIdpParams();\r\n    const passIdp = (\r\n      await this.keyFactory.derivePassIdp({\r\n        password,\r\n        ...passIdpParams,\r\n      })\r\n    ).jwk;\r\n\r\n    const passKeyParams = await this.keyFactory.createPassKeyParams();\r\n    const passKey = (\r\n      await this.keyFactory.derivePassKey({\r\n        password,\r\n        ...passKeyParams,\r\n      })\r\n    ).jwk;\r\n\r\n    const passIdpVerifier = await this.keyFactory.createPkcSignKey();\r\n\r\n    const wrappedPassIdpVerifierPrk = await this.encryptionService.encrypt(\r\n      passKey,\r\n      passIdpVerifier.toJSON(true)\r\n    );\r\n\r\n    // There are two formats that the private key can be represented in JWK:\r\n    // https://tools.ietf.org/html/rfc8017#page-9\r\n    // The second form is an optimization:\r\n    // https://crypto.stackexchange.com/questions/19413/what-are-dp-and-dq-in-encryption-by-rsa-in-c\r\n\r\n    return {\r\n      passKeyParams,\r\n      passKey,\r\n      passIdpParams,\r\n      passIdp,\r\n      passIdpVerifier,\r\n      wrappedPassIdpVerifierPrk,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * We need to allow for interruption of the process at any point. Each API call can be considered\r\n   * atomic and either succeeds or fails.\r\n   *\r\n   * The LR server APIs use semaphore tokens for locking critical operations, so concurrent calls will\r\n   * fail.\r\n   *\r\n   * We assume the worst case for IdP API calls. So we use the semaphore token from LR to prevent\r\n   * concurrent calls to IdP APIs, but we have to assume that the IdP API calls will either succeed or\r\n   * fail within a reasonable amount of time.\r\n   *\r\n   * Each location where the server state changes can be a potential point of interruption.\r\n   * Potential points of interruption are marked with: --Potential Failure Point--\r\n   *\r\n   * Places for timeout:\r\n   * - Login age too old at call to: verifyPassword()\r\n   * - Login age too old at call to: changePasswordMutation()\r\n   * - Semaphore token expires at call to: changePasswordComplete()\r\n   *\r\n   * Tests:\r\n   * - Potential Failure Point 1: should be able to restart the process, user remains signed in.\r\n   * - Potential Failure Point 2: should enter recovery flow\r\n   * - Potential Failure Point 3: should enter recovery flow\r\n   * - Potential Failure Point 4: should enter recovery flow\r\n   *\r\n   */\r\n\r\n  public async isLoginRequired(): Promise<boolean> {\r\n    const changePasswordConfig = await this.getChangePasswordConfig();\r\n    const authTime = moment(changePasswordConfig.authTime);\r\n    const serverTime = moment(changePasswordConfig.serverTime);\r\n    const duration = moment.duration(serverTime.diff(authTime));\r\n    const seconds = duration.asSeconds();\r\n    if (seconds > changePasswordConfig.maxAuthAgeSeconds) {\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  public async changePassword(password: string, newPassword: string) {\r\n    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();\r\n\r\n    // Validation\r\n    // todo: Add this back in\r\n    // Note the passIdp will always have a random salt, so will always be different to the current passIdp.\r\n    if (password === newPassword) {\r\n      throw new LrBadArgumentException(\r\n        'New password is the same as the current one.'\r\n      );\r\n    }\r\n\r\n    const { currentUser } = await this.profileService.getCurrentUser();\r\n\r\n    const { passIdp, signedChallenge } = await this.verifyPassword(\r\n      password,\r\n      currentUser\r\n    );\r\n\r\n    // --Potential Failure Point 1--\r\n    // verifyPassword() asks for a current password challenge hence changes server state.\r\n    // Place break points here to test the failure scenarios.\r\n\r\n    // Generate the new passIdp\r\n    const newPassKey = await this.createPassKeyBundle(newPassword);\r\n\r\n    // Re-encrypt master key with new key\r\n    const masterKey = await this.keyGraph.getKey(\r\n      currentUser.currentUserKey.masterKey.id\r\n    );\r\n    const newWrappedMasterKey = await this.encryptionService.encrypt(\r\n      newPassKey.passKey,\r\n      masterKey.jwk.toJSON(true)\r\n    );\r\n\r\n    // If the IdP change password failed, we need to go into recovery mode by forcing\r\n    // a login. We can't logout the user just yet since the IdP password change needs\r\n    // the user to be logged in. We _can_ removed any persisted session values for the IdP\r\n    // but that seems like too much trouble.\r\n\r\n    const { token, newPassKeyId } = await this.changePasswordMutation(\r\n      signedChallenge,\r\n      currentUser.currentUserKey.masterKey.id,\r\n      newWrappedMasterKey,\r\n      newPassKey\r\n    );\r\n\r\n    // --Potential Failure Point 2--\r\n    // changePasswordMutation() uploads new keys and obtains a semaphore lock to prevent any other\r\n    // clients from performing IdP password change.\r\n\r\n    // Now we can do the IdP password change.\r\n    // todo: Add this back in\r\n    await this.auth.changePassword(\r\n      cognitoUser,\r\n      this.getPassIdpString(passIdp),\r\n      this.getPassIdpString(newPassKey.passIdp)\r\n    );\r\n\r\n    // --Potential Failure Point 3--\r\n    // IdP password change\r\n\r\n    // Note that changePassword() could throw an exception for a number of reason. It could throw\r\n    // a network timeout for example. But we don't know if it's the response that timed out and\r\n    // the idp password change was actually carried out. So we have to be extra conservative and\r\n    // only act on a clear success. Otherwise we go into recover mode.\r\n    await this.changePasswordComplete(\r\n      cognitoUser.getSignInUserSession().getAccessToken().getJwtToken(),\r\n      true,\r\n      token\r\n    );\r\n  }\r\n\r\n  public async changePasswordComplete(\r\n    accessToken: string,\r\n    useNewPassword: boolean,\r\n    token: string = null\r\n  ): Promise<any> {\r\n    return this.http\r\n      .post(\r\n        `${this.config.authUrl}users/password-change-complete/`,\r\n        {\r\n          use_new_password: useNewPassword,\r\n          ...(token && { token }),\r\n        },\r\n        {\r\n          headers: {\r\n            Authorization: `Bearer ${accessToken}`,\r\n          },\r\n        }\r\n      )\r\n      .toPromise();\r\n  }\r\n\r\n  private async getVerifierPrK(\r\n    passKey: JWK.Key,\r\n    wrappedPrK: object\r\n  ): Promise<JWK.Key> {\r\n    try {\r\n      const prkJson = await this.encryptionService.decrypt(passKey, wrappedPrK);\r\n      return KFS.asKey(prkJson);\r\n    } catch (error) {\r\n      throw new LrAuthException('Wrong current password');\r\n    }\r\n  }\r\n\r\n  private async verifyPassword(\r\n    password: string,\r\n    currentUser: ApiCurrentUser\r\n  ): Promise<{ passIdp: JWK.Key; signedChallenge: JWS.CreateSignResult }> {\r\n    // Get information from the server to prepare for password change.\r\n    const passwordRequest = await this.apollo.mutate<PasswordChangeRequestMutation>(\r\n      {\r\n        mutation: PasswordChangeRequestMutation,\r\n        variables: {},\r\n      }\r\n    );\r\n\r\n    // Get the old passKey so we can decrypt the old password verifier\r\n    const passKeyResult = await this.keyFactory.derivePassKey({\r\n      password,\r\n      ...currentUser.currentUserKey.passKey.passKeyParams,\r\n    });\r\n\r\n    const verifierPrK = await this.getVerifierPrK(\r\n      passKeyResult.jwk,\r\n      currentUser.currentUserKey.passKey.wrappedPassIdpVerifierPrk\r\n    );\r\n\r\n    // Sign the server challenge to prove to the server we can decrypt the password verifier.\r\n    // Generate\r\n    const clientNonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);\r\n\r\n    const signedChallenge = await this.encryptionService.sign(verifierPrK, {\r\n      serverNonce: passwordRequest.passwordChangeRequest.challenge.serverNonce,\r\n      clientNonce,\r\n    });\r\n\r\n    const passIdpResult = await this.keyFactory.derivePassIdp({\r\n      password,\r\n      ...currentUser.currentUserKey.passKey.passIdpParams,\r\n    });\r\n\r\n    return {\r\n      passIdp: passIdpResult.jwk,\r\n      signedChallenge,\r\n    };\r\n  }\r\n\r\n  private async changePasswordMutation(\r\n    signedChallenge: JWS.CreateSignResult,\r\n    masterKeyId: string,\r\n    newWrappedMasterKey: object,\r\n    passKeyBundle: PassKeyBundle\r\n  ): Promise<{ token: string; newPassKeyId: string }> {\r\n    const response = await this.apollo.mutate<PasswordChangeMutation>({\r\n      mutation: PasswordChangeMutation,\r\n      variables: {\r\n        input: {\r\n          signedChallenge: JSON.stringify(signedChallenge),\r\n          masterKeyId,\r\n          newWrappedMasterKey: JSON.stringify(newWrappedMasterKey),\r\n          newPassKey: {\r\n            passIdpParams: JSON.stringify(passKeyBundle.passIdpParams),\r\n            passIdpVerifierPbk: JSON.stringify(\r\n              passKeyBundle.passIdpVerifier.toJSON()\r\n            ),\r\n            wrappedPassIdpVerifierPrk: JSON.stringify(\r\n              passKeyBundle.wrappedPassIdpVerifierPrk\r\n            ),\r\n            passKeyParams: JSON.stringify(passKeyBundle.passKeyParams),\r\n          },\r\n        },\r\n      },\r\n    });\r\n    return {\r\n      token: response.passwordChange.token,\r\n      newPassKeyId: response.passwordChange.newPassKey.id,\r\n    };\r\n  }\r\n\r\n  async getChangePasswordConfig(): Promise<PasswordChangeConfig> {\r\n    const res = await this.apollo.query<any>({\r\n      query: PasswordChangeConfigQuery,\r\n    });\r\n\r\n    const ret = res.passwordChangeConfig as PasswordChangeConfig;\r\n\r\n    ret.authTime = new Date(ret.authTime);\r\n    ret.serverTime = new Date(ret.serverTime);\r\n    return ret;\r\n  }\r\n\r\n  public passwordStrength(password): { years: number; bits: number } {\r\n    const upper = /[A-Z]/g;\r\n    const lower = /[a-z]/g;\r\n    const digit = /[0-9]/g;\r\n\r\n    const upperChoices = 26;\r\n    const lowerChoices = 26;\r\n    const digitChoices = 10;\r\n    const specialChoices = 30; // /[!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~]/g\r\n\r\n    function instanceCount(str, re) {\r\n      return ((str || '').match(re) || []).length;\r\n    }\r\n\r\n    const uppers = instanceCount(password, upper);\r\n    const lowers = instanceCount(password, lower);\r\n    const digits = instanceCount(password, digit);\r\n    const specials = password.length - uppers - lowers - digits;\r\n\r\n    let choices = 0;\r\n    if (uppers) {\r\n      choices += upperChoices;\r\n    }\r\n    if (lowers) {\r\n      choices += lowerChoices;\r\n    }\r\n    if (digits) {\r\n      choices += digitChoices;\r\n    }\r\n    if (specials) {\r\n      choices += specialChoices;\r\n    }\r\n\r\n    if (password.length === 0) {\r\n      return {\r\n        years: 0,\r\n        // bits of entropy\r\n        bits: 0,\r\n      };\r\n    }\r\n\r\n    const permutations = Math.pow(choices, password.length);\r\n\r\n    const years =\r\n      (54000 * permutations) /\r\n      Math.pow(upperChoices + lowerChoices + digitChoices, 12);\r\n    return {\r\n      years,\r\n      // bits of entropy\r\n      bits: Math.round(Math.log2(permutations)),\r\n    };\r\n  }\r\n}\r\n"]}

package/esm2015/lib/auth/register.service.js

@@ -0,0 +1,172 @@
+import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { LR_CONFIG } from '../life-ready.config';
+import { PasswordService } from './password.service';
+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 "@angular/common/http";
+import * as i4 from "../cryptography/key-factory.service";
+import * as i5 from "../cryptography/encryption.service";
+import * as i6 from "./password.service";
+export class RegisterService {
+    constructor(config, auth, http, keyFactory, encryptionService, passwordService) {
+        this.config = config;
+        this.auth = auth;
+        this.http = http;
+        this.keyFactory = keyFactory;
+        this.encryptionService = encryptionService;
+        this.passwordService = passwordService;
+    }
+    /**
+     * Request a verification code to be sent out to an email.
+     * @return Info needed to be submitted along with the verification code
+     */
+    verifyEmail(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { claim_id } = yield this.http
+                .post(`${this.config.authUrl}cove/claim/email/`, {
+                address: email,
+                context: 'signup',
+            })
+                .toPromise();
+            return claim_id;
+        });
+    }
+    verifyPhone(phoneNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { claim_id } = yield this.http
+                .post(`${this.config.authUrl}cove/claim/sms/`, {
+                address: phoneNumber,
+                context: 'signup',
+            })
+                .toPromise();
+            return claim_id;
+        });
+    }
+    confirmVerificationCode(verificationId, verificationCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { token } = yield this.http
+                .post(`${this.config.authUrl}cove/respond/`, {
+                claim_id: verificationId,
+                v_code: verificationCode,
+            })
+                .toPromise();
+            return token;
+        });
+    }
+    register(email, password, verificationId, verificationToken, verificationType = 'email') {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Generate the key material needed for PassIdp which will be the password used for Cognito.
+            const passKeyBundle = yield this.passwordService.createPassKeyBundle(password);
+            const masterKey = yield this.keyFactory.createKey();
+            const wrappedMasterKey = yield this.encryptionService.encrypt(passKeyBundle.passKey, masterKey.toJSON(true));
+            const rootKey = yield this.keyFactory.createKey();
+            const wrappedRootKey = yield this.encryptionService.encrypt(masterKey, rootKey.toJSON(true));
+            // Encryption PKC key
+            const prk = yield this.keyFactory.createPkcKey();
+            const wrappedPrk = yield this.encryptionService.encrypt(rootKey, prk.toJSON(true));
+            // Signing PKC key
+            const sigPrk = yield this.keyFactory.createPkcSignKey();
+            const wrappedSigPrk = yield this.encryptionService.encrypt(rootKey, sigPrk.toJSON(true));
+            // API call to setup profile
+            const user = yield this.http
+                .post(`${this.config.authUrl}users/`, {
+                claims: [
+                    {
+                        type: verificationType,
+                        token: verificationToken,
+                        claim_id: verificationId,
+                    },
+                ],
+                pass_idp_params: passKeyBundle.passIdpParams,
+                pass_idp_verifier_pbk: passKeyBundle.passIdpVerifier.toJSON(),
+                wrapped_pass_idp_verifier_prk: passKeyBundle.wrappedPassIdpVerifierPrk,
+                pass_key_params: passKeyBundle.passKeyParams,
+                wrapped_master_key: wrappedMasterKey,
+                wrapped_root_key: wrappedRootKey,
+                pbk: prk.toJSON(),
+                wrapped_prk: wrappedPrk,
+                sig_pbk: sigPrk.toJSON(),
+                wrapped_sig_prk: wrappedSigPrk,
+            })
+                .toPromise();
+            // API call to create user on cognito
+            const attributes = {};
+            user.claims.forEach((claim) => {
+                attributes[claim.type] = claim.value;
+            });
+            // Random suffix for uniqueness. If there's a duplicate, then used just needs to
+            // sign up again. But chances of collision is low.
+            const suffix = this.keyFactory.randomDigitsNoZeros(4);
+            const cognitoUser = yield this.auth.signUp({
+                username: `${email.split('@')[0]}.${suffix}`,
+                password: this.passwordService.getPassIdpString(passKeyBundle.passIdp),
+                attributes,
+                // Unfortunately, validationData is not passed to the post
+                // confirmation cognito trigger. So can can't do the association there.
+                // The current workflow will create a new user on LR before signing up
+                // with Cognito. Then Cognito can use the user.id and user.pre_sign_up_token to
+                // do the validation of the attributes.
+                // validationData: [
+                //   new CognitoUserAttribute({
+                //     Name: "user_id",
+                //     Value: String(user.id)
+                //   }),
+                //   new CognitoUserAttribute({
+                //     Name: "user_pre_sign_up_token",
+                //     Value: user.pre_sign_up_token
+                //   })
+                // ]
+                clientMetadata: {
+                    user_id: String(user.id),
+                    user_pre_sign_up_token: String(user.pre_sign_up_token),
+                },
+            });
+            return {
+                username: cognitoUser.user.getUsername(),
+                userId: user.id,
+                preSignUpToken: user.pre_sign_up_token,
+                userSub: cognitoUser.userSub,
+            };
+        });
+    }
+    hibpBreachedAccounts(account) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // The account is just the email
+            try {
+                const response = yield this.http
+                    .get(`${this.config.authUrl}users/hibp/breachedaccount/${account}/?truncateResponse=false`)
+                    .toPromise();
+                return response;
+            }
+            catch (error) {
+                if (error.status === 404) {
+                    return null;
+                }
+                else {
+                    throw error;
+                }
+            }
+        });
+    }
+}
+RegisterService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RegisterService_Factory() { return new RegisterService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.AuthClass), i0.ɵɵinject(i3.HttpClient), i0.ɵɵinject(i4.KeyFactoryService), i0.ɵɵinject(i5.EncryptionService), i0.ɵɵinject(i6.PasswordService)); }, token: RegisterService, providedIn: "root" });
+RegisterService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+RegisterService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: AuthClass },
+    { type: HttpClient },
+    { type: KeyFactoryService },
+    { type: EncryptionService },
+    { type: PasswordService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"register.service.js","sourceRoot":"C:/Projects/newrepo/kc-client/projects/core/src/","sources":["lib/auth/register.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,EAAmB,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;;;;;;;;AAMrD,MAAM,OAAO,eAAe;IAC1B,YAC6B,MAAuB,EAC1C,IAAe,EACf,IAAgB,EAChB,UAA6B,EAC7B,iBAAoC,EACpC,eAAgC;QALb,WAAM,GAAN,MAAM,CAAiB;QAC1C,SAAI,GAAJ,IAAI,CAAW;QACf,SAAI,GAAJ,IAAI,CAAY;QAChB,eAAU,GAAV,UAAU,CAAmB;QAC7B,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,oBAAe,GAAf,eAAe,CAAiB;IACvC,CAAC;IAEJ;;;OAGG;IACU,WAAW,CAAC,KAAa;;YACpC,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI;iBACjC,IAAI,CAAe,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,mBAAmB,EAAE;gBAC7D,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,QAAQ;aAClB,CAAC;iBACD,SAAS,EAAE,CAAC;YACf,OAAO,QAAQ,CAAC;QAClB,CAAC;KAAA;IAEY,WAAW,CAAC,WAAmB;;YAC1C,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI;iBACjC,IAAI,CAAe,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,iBAAiB,EAAE;gBAC3D,OAAO,EAAE,WAAW;gBACpB,OAAO,EAAE,QAAQ;aAClB,CAAC;iBACD,SAAS,EAAE,CAAC;YACf,OAAO,QAAQ,CAAC;QAClB,CAAC;KAAA;IAEY,uBAAuB,CAClC,cAAsB,EACtB,gBAAwB;;YAExB,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI;iBAC9B,IAAI,CAAY,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,eAAe,EAAE;gBACtD,QAAQ,EAAE,cAAc;gBACxB,MAAM,EAAE,gBAAgB;aACzB,CAAC;iBACD,SAAS,EAAE,CAAC;YACf,OAAO,KAAK,CAAC;QACf,CAAC;KAAA;IAEY,QAAQ,CACnB,KAAa,EACb,QAAgB,EAChB,cAAsB,EACtB,iBAAyB,EACzB,mBAAsC,OAAO;;YAE7C,4FAA4F;YAC5F,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAClE,QAAQ,CACT,CAAC;YAEF,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YACpD,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAC3D,aAAa,CAAC,OAAO,EACrB,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CACvB,CAAC;YAEF,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YAClD,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CACzD,SAAS,EACT,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CACrB,CAAC;YAEF,qBAAqB;YACrB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAC;YACjD,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CACrD,OAAO,EACP,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CACjB,CAAC;YAEF,kBAAkB;YAClB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,CAAC;YACxD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CACxD,OAAO,EACP,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CACpB,CAAC;YAEF,4BAA4B;YAC5B,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI;iBACzB,IAAI,CAAM,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,QAAQ,EAAE;gBACzC,MAAM,EAAE;oBACN;wBACE,IAAI,EAAE,gBAAgB;wBACtB,KAAK,EAAE,iBAAiB;wBACxB,QAAQ,EAAE,cAAc;qBACzB;iBACF;gBACD,eAAe,EAAE,aAAa,CAAC,aAAa;gBAC5C,qBAAqB,EAAE,aAAa,CAAC,eAAe,CAAC,MAAM,EAAE;gBAC7D,6BAA6B,EAAE,aAAa,CAAC,yBAAyB;gBACtE,eAAe,EAAE,aAAa,CAAC,aAAa;gBAC5C,kBAAkB,EAAE,gBAAgB;gBACpC,gBAAgB,EAAE,cAAc;gBAChC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE;gBACjB,WAAW,EAAE,UAAU;gBACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE;gBACxB,eAAe,EAAE,aAAa;aAC/B,CAAC;iBACD,SAAS,EAAE,CAAC;YAEf,qCAAqC;YACrC,MAAM,UAAU,GAAG,EAAE,CAAC;YACtB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gBAC5B,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;YACvC,CAAC,CAAC,CAAC;YAEH,gFAAgF;YAChF,kDAAkD;YAClD,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;YAEtD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;gBACzC,QAAQ,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,MAAM,EAAE;gBAC5C,QAAQ,EAAE,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,aAAa,CAAC,OAAO,CAAC;gBACtE,UAAU;gBACV,0DAA0D;gBAC1D,uEAAuE;gBACvE,sEAAsE;gBACtE,+EAA+E;gBAC/E,uCAAuC;gBACvC,oBAAoB;gBACpB,+BAA+B;gBAC/B,uBAAuB;gBACvB,6BAA6B;gBAC7B,QAAQ;gBACR,+BAA+B;gBAC/B,sCAAsC;gBACtC,oCAAoC;gBACpC,OAAO;gBACP,IAAI;gBACJ,cAAc,EAAE;oBACd,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;oBACxB,sBAAsB,EAAE,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC;iBACvD;aACF,CAAC,CAAC;YAEH,OAAO;gBACL,QAAQ,EAAE,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE;gBACxC,MAAM,EAAE,IAAI,CAAC,EAAE;gBACf,cAAc,EAAE,IAAI,CAAC,iBAAiB;gBACtC,OAAO,EAAE,WAAW,CAAC,OAAO;aAC7B,CAAC;QACJ,CAAC;KAAA;IAEY,oBAAoB,CAAC,OAAe;;YAC/C,gCAAgC;YAChC,IAAI;gBACF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI;qBAC7B,GAAG,CACF,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,8BAA8B,OAAO,0BAA0B,CACtF;qBACA,SAAS,EAAE,CAAC;gBACf,OAAO,QAAQ,CAAC;aACjB;YAAC,OAAO,KAAK,EAAE;gBACd,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,EAAE;oBACxB,OAAO,IAAI,CAAC;iBACb;qBAAM;oBACL,MAAM,KAAK,CAAC;iBACb;aACF;QACH,CAAC;KAAA;;;;YA1KF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;4CAGI,MAAM,SAAC,SAAS;YAZZ,SAAS;YAFT,UAAU;YAIV,iBAAiB;YADjB,iBAAiB;YAGjB,eAAe","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Inject, Injectable } from '@angular/core';\r\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { KeyFactoryService } from '../cryptography/key-factory.service';\r\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\r\nimport { PasswordService } from './password.service';\r\nimport { RegisterResult } from './auth.types';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class RegisterService {\r\n  constructor(\r\n    @Inject(LR_CONFIG) private config: LifeReadyConfig,\r\n    private auth: AuthClass,\r\n    private http: HttpClient,\r\n    private keyFactory: KeyFactoryService,\r\n    private encryptionService: EncryptionService,\r\n    private passwordService: PasswordService\r\n  ) {}\r\n\r\n  /**\r\n   * Request a verification code to be sent out to an email.\r\n   * @return Info needed to be submitted along with the verification code\r\n   */\r\n  public async verifyEmail(email: string): Promise<string> {\r\n    const { claim_id } = await this.http\r\n      .post<{ claim_id }>(`${this.config.authUrl}cove/claim/email/`, {\r\n        address: email,\r\n        context: 'signup',\r\n      })\r\n      .toPromise();\r\n    return claim_id;\r\n  }\r\n\r\n  public async verifyPhone(phoneNumber: string): Promise<string> {\r\n    const { claim_id } = await this.http\r\n      .post<{ claim_id }>(`${this.config.authUrl}cove/claim/sms/`, {\r\n        address: phoneNumber,\r\n        context: 'signup',\r\n      })\r\n      .toPromise();\r\n    return claim_id;\r\n  }\r\n\r\n  public async confirmVerificationCode(\r\n    verificationId: string,\r\n    verificationCode: string\r\n  ): Promise<string> {\r\n    const { token } = await this.http\r\n      .post<{ token }>(`${this.config.authUrl}cove/respond/`, {\r\n        claim_id: verificationId,\r\n        v_code: verificationCode,\r\n      })\r\n      .toPromise();\r\n    return token;\r\n  }\r\n\r\n  public async register(\r\n    email: string,\r\n    password: string,\r\n    verificationId: string,\r\n    verificationToken: string,\r\n    verificationType: 'email' | 'phone' = 'email'\r\n  ): Promise<RegisterResult> {\r\n    // Generate the key material needed for PassIdp which will be the password used for Cognito.\r\n    const passKeyBundle = await this.passwordService.createPassKeyBundle(\r\n      password\r\n    );\r\n\r\n    const masterKey = await this.keyFactory.createKey();\r\n    const wrappedMasterKey = await this.encryptionService.encrypt(\r\n      passKeyBundle.passKey,\r\n      masterKey.toJSON(true)\r\n    );\r\n\r\n    const rootKey = await this.keyFactory.createKey();\r\n    const wrappedRootKey = await this.encryptionService.encrypt(\r\n      masterKey,\r\n      rootKey.toJSON(true)\r\n    );\r\n\r\n    // Encryption PKC key\r\n    const prk = await this.keyFactory.createPkcKey();\r\n    const wrappedPrk = await this.encryptionService.encrypt(\r\n      rootKey,\r\n      prk.toJSON(true)\r\n    );\r\n\r\n    // Signing PKC key\r\n    const sigPrk = await this.keyFactory.createPkcSignKey();\r\n    const wrappedSigPrk = await this.encryptionService.encrypt(\r\n      rootKey,\r\n      sigPrk.toJSON(true)\r\n    );\r\n\r\n    // API call to setup profile\r\n    const user = await this.http\r\n      .post<any>(`${this.config.authUrl}users/`, {\r\n        claims: [\r\n          {\r\n            type: verificationType,\r\n            token: verificationToken,\r\n            claim_id: verificationId,\r\n          },\r\n        ],\r\n        pass_idp_params: passKeyBundle.passIdpParams,\r\n        pass_idp_verifier_pbk: passKeyBundle.passIdpVerifier.toJSON(),\r\n        wrapped_pass_idp_verifier_prk: passKeyBundle.wrappedPassIdpVerifierPrk,\r\n        pass_key_params: passKeyBundle.passKeyParams,\r\n        wrapped_master_key: wrappedMasterKey,\r\n        wrapped_root_key: wrappedRootKey,\r\n        pbk: prk.toJSON(), // public encryption key\r\n        wrapped_prk: wrappedPrk,\r\n        sig_pbk: sigPrk.toJSON(), // public signing key\r\n        wrapped_sig_prk: wrappedSigPrk,\r\n      })\r\n      .toPromise();\r\n\r\n    // API call to create user on cognito\r\n    const attributes = {};\r\n    user.claims.forEach((claim) => {\r\n      attributes[claim.type] = claim.value;\r\n    });\r\n\r\n    // Random suffix for uniqueness. If there's a duplicate, then used just needs to\r\n    // sign up again. But chances of collision is low.\r\n    const suffix = this.keyFactory.randomDigitsNoZeros(4);\r\n\r\n    const cognitoUser = await this.auth.signUp({\r\n      username: `${email.split('@')[0]}.${suffix}`,\r\n      password: this.passwordService.getPassIdpString(passKeyBundle.passIdp),\r\n      attributes,\r\n      // Unfortunately, validationData is not passed to the post\r\n      // confirmation cognito trigger. So can can't do the association there.\r\n      // The current workflow will create a new user on LR before signing up\r\n      // with Cognito. Then Cognito can use the user.id and user.pre_sign_up_token to\r\n      // do the validation of the attributes.\r\n      // validationData: [\r\n      //   new CognitoUserAttribute({\r\n      //     Name: \"user_id\",\r\n      //     Value: String(user.id)\r\n      //   }),\r\n      //   new CognitoUserAttribute({\r\n      //     Name: \"user_pre_sign_up_token\",\r\n      //     Value: user.pre_sign_up_token\r\n      //   })\r\n      // ]\r\n      clientMetadata: {\r\n        user_id: String(user.id),\r\n        user_pre_sign_up_token: String(user.pre_sign_up_token),\r\n      },\r\n    });\r\n\r\n    return {\r\n      username: cognitoUser.user.getUsername(),\r\n      userId: user.id,\r\n      preSignUpToken: user.pre_sign_up_token,\r\n      userSub: cognitoUser.userSub,\r\n    };\r\n  }\r\n\r\n  public async hibpBreachedAccounts(account: string): Promise<any> {\r\n    // The account is just the email\r\n    try {\r\n      const response = await this.http\r\n        .get(\r\n          `${this.config.authUrl}users/hibp/breachedaccount/${account}/?truncateResponse=false`\r\n        )\r\n        .toPromise();\r\n      return response;\r\n    } catch (error) {\r\n      if (error.status === 404) {\r\n        return null;\r\n      } else {\r\n        throw error;\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}